tesseract  4.0.0-1-g2a2b
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 nullptr.
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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>
1666 class TessCallback1 {
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>
1688 class TessResultCallback2 {
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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_ = nullptr;
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:
5388  const T* object_;
5389  MemberSignature member_;
5390  typename remove_reference<P1>::type p1_;
5391  typename remove_reference<P2>::type p2_;
5392 
5393  public:
5394  inline _ConstTessMemberResultCallback_2_3(const T* object, MemberSignature member, P1 p1, P2 p2)
5395  : object_(object),
5396  member_(member), p1_(p1), p2_(p2) { }
5397 
5398  virtual R Run(A1 a1,A2 a2,A3 a3) {
5399  if (!del) {
5400  R result = (object_->*member_)(p1_,p2_,a1,a2,a3);
5401  return result;
5402  } else {
5403  R result = (object_->*member_)(p1_,p2_,a1,a2,a3);
5404  // zero out the pointer to ensure segfault if used again
5405  member_ = nullptr;
5406  delete this;
5407  return result;
5408  }
5409  }
5410 };
5411 
5412 template <bool del, class T, class P1, class P2, class A1, class A2, class A3>
5413 class _ConstTessMemberResultCallback_2_3<del, void, T, P1, P2, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
5414  public:
5416  typedef void (T::*MemberSignature)(P1,P2,A1,A2,A3) const;
5417 
5418  private:
5419  const T* object_;
5420  MemberSignature member_;
5421  typename remove_reference<P1>::type p1_;
5422  typename remove_reference<P2>::type p2_;
5423 
5424  public:
5425  inline _ConstTessMemberResultCallback_2_3(const T* object, MemberSignature member, P1 p1, P2 p2)
5426  : object_(object),
5427  member_(member), p1_(p1), p2_(p2) { }
5428 
5429  virtual void Run(A1 a1,A2 a2,A3 a3) {
5430  if (!del) {
5431  (object_->*member_)(p1_,p2_,a1,a2,a3);
5432  } else {
5433  (object_->*member_)(p1_,p2_,a1,a2,a3);
5434  // zero out the pointer to ensure segfault if used again
5435  member_ = nullptr;
5436  delete this;
5437  }
5438  }
5439 };
5440 
5441 #ifndef SWIG
5442 template <class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3>
5444 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2,A3) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
5445  return new _ConstTessMemberResultCallback_2_3<true,R,T1,P1,P2,A1,A2,A3>(obj, member, p1, p2);
5446 }
5447 #endif
5448 
5449 #ifndef SWIG
5450 template <class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3>
5452 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2,A3) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
5453  return new _ConstTessMemberResultCallback_2_3<false,R,T1,P1,P2,A1,A2,A3>(obj, member, p1, p2);
5454 }
5455 #endif
5456 
5457 template <bool del, class R, class T, class P1, class P2, class A1, class A2, class A3>
5459  public:
5461  typedef R (T::*MemberSignature)(P1,P2,A1,A2,A3) ;
5462 
5463  private:
5464  T* object_;
5465  MemberSignature member_;
5466  typename remove_reference<P1>::type p1_;
5467  typename remove_reference<P2>::type p2_;
5468 
5469  public:
5470  inline _TessMemberResultCallback_2_3(T* object, MemberSignature member, P1 p1, P2 p2)
5471  : object_(object),
5472  member_(member), p1_(p1), p2_(p2) { }
5473 
5474 
5475  virtual R Run(A1 a1,A2 a2,A3 a3) {
5476  if (!del) {
5477  R result = (object_->*member_)(p1_,p2_,a1,a2,a3);
5478  return result;
5479  } else {
5480  R result = (object_->*member_)(p1_,p2_,a1,a2,a3);
5481  // zero out the pointer to ensure segfault if used again
5482  member_ = nullptr;
5483  delete this;
5484  return result;
5485  }
5486  }
5487 };
5488 
5489 template <bool del, class T, class P1, class P2, class A1, class A2, class A3>
5490 class _TessMemberResultCallback_2_3<del, void, T, P1, P2, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
5491  public:
5493  typedef void (T::*MemberSignature)(P1,P2,A1,A2,A3) ;
5494 
5495  private:
5496  T* object_;
5497  MemberSignature member_;
5498  typename remove_reference<P1>::type p1_;
5499  typename remove_reference<P2>::type p2_;
5500 
5501  public:
5502  inline _TessMemberResultCallback_2_3(T* object, MemberSignature member, P1 p1, P2 p2)
5503  : object_(object),
5504  member_(member), p1_(p1), p2_(p2) { }
5505 
5506  virtual void Run(A1 a1,A2 a2,A3 a3) {
5507  if (!del) {
5508  (object_->*member_)(p1_,p2_,a1,a2,a3);
5509  } else {
5510  (object_->*member_)(p1_,p2_,a1,a2,a3);
5511  // zero out the pointer to ensure segfault if used again
5512  member_ = nullptr;
5513  delete this;
5514  }
5515  }
5516 };
5517 
5518 #ifndef SWIG
5519 template <class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3>
5521 NewTessCallback(T1* obj, R (T2::*member)(P1,P2,A1,A2,A3) , typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
5522  return new _TessMemberResultCallback_2_3<true,R,T1,P1,P2,A1,A2,A3>(obj, member, p1, p2);
5523 }
5524 #endif
5525 
5526 #ifndef SWIG
5527 template <class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3>
5529 NewPermanentTessCallback(T1* obj, R (T2::*member)(P1,P2,A1,A2,A3) , typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
5530  return new _TessMemberResultCallback_2_3<false,R,T1,P1,P2,A1,A2,A3>(obj, member, p1, p2);
5531 }
5532 #endif
5533 
5534 template <bool del, class R, class P1, class P2, class A1, class A2, class A3>
5536  public:
5538  typedef R (*FunctionSignature)(P1,P2,A1,A2,A3);
5539 
5540  private:
5541  FunctionSignature function_;
5542  typename remove_reference<P1>::type p1_;
5543  typename remove_reference<P2>::type p2_;
5544 
5545  public:
5547  : function_(function), p1_(p1), p2_(p2) { }
5548 
5549  virtual R Run(A1 a1,A2 a2,A3 a3) {
5550  if (!del) {
5551  R result = (*function_)(p1_,p2_,a1,a2,a3);
5552  return result;
5553  } else {
5554  R result = (*function_)(p1_,p2_,a1,a2,a3);
5555  // zero out the pointer to ensure segfault if used again
5556  function_ = nullptr;
5557  delete this;
5558  return result;
5559  }
5560  }
5561 };
5562 
5563 template <bool del, class P1, class P2, class A1, class A2, class A3>
5564 class _TessFunctionResultCallback_2_3<del, void, P1, P2, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
5565  public:
5567  typedef void (*FunctionSignature)(P1,P2,A1,A2,A3);
5568 
5569  private:
5570  FunctionSignature function_;
5571  typename remove_reference<P1>::type p1_;
5572  typename remove_reference<P2>::type p2_;
5573 
5574  public:
5576  : function_(function), p1_(p1), p2_(p2) { }
5577 
5578  virtual void Run(A1 a1,A2 a2,A3 a3) {
5579  if (!del) {
5580  (*function_)(p1_,p2_,a1,a2,a3);
5581  } else {
5582  (*function_)(p1_,p2_,a1,a2,a3);
5583  // zero out the pointer to ensure segfault if used again
5584  function_ = nullptr;
5585  delete this;
5586  }
5587  }
5588 };
5589 
5590 template <class R, class P1, class P2, class A1, class A2, class A3>
5592 NewTessCallback(R (*function)(P1,P2,A1,A2,A3), typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
5593  return new _TessFunctionResultCallback_2_3<true,R,P1,P2,A1,A2,A3>(function, p1, p2);
5594 }
5595 
5596 template <class R, class P1, class P2, class A1, class A2, class A3>
5598 NewPermanentTessCallback(R (*function)(P1,P2,A1,A2,A3), typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
5599  return new _TessFunctionResultCallback_2_3<false,R,P1,P2,A1,A2,A3>(function, p1, p2);
5600 }
5601 
5602 template <bool del, class R, class T, class P1, class P2, class P3, class A1, class A2, class A3>
5604  public:
5606  typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2,A3) const;
5607 
5608  private:
5609  const T* object_;
5610  MemberSignature member_;
5611  typename remove_reference<P1>::type p1_;
5612  typename remove_reference<P2>::type p2_;
5613  typename remove_reference<P3>::type p3_;
5614 
5615  public:
5616  inline _ConstTessMemberResultCallback_3_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
5617  : object_(object),
5618  member_(member), p1_(p1), p2_(p2), p3_(p3) { }
5619 
5620  virtual R Run(A1 a1,A2 a2,A3 a3) {
5621  if (!del) {
5622  R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3);
5623  return result;
5624  } else {
5625  R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3);
5626  // zero out the pointer to ensure segfault if used again
5627  member_ = nullptr;
5628  delete this;
5629  return result;
5630  }
5631  }
5632 };
5633 
5634 template <bool del, class T, class P1, class P2, class P3, class A1, class A2, class A3>
5635 class _ConstTessMemberResultCallback_3_3<del, void, T, P1, P2, P3, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
5636  public:
5638  typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2,A3) const;
5639 
5640  private:
5641  const T* object_;
5642  MemberSignature member_;
5643  typename remove_reference<P1>::type p1_;
5644  typename remove_reference<P2>::type p2_;
5645  typename remove_reference<P3>::type p3_;
5646 
5647  public:
5648  inline _ConstTessMemberResultCallback_3_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
5649  : object_(object),
5650  member_(member), p1_(p1), p2_(p2), p3_(p3) { }
5651 
5652  virtual void Run(A1 a1,A2 a2,A3 a3) {
5653  if (!del) {
5654  (object_->*member_)(p1_,p2_,p3_,a1,a2,a3);
5655  } else {
5656  (object_->*member_)(p1_,p2_,p3_,a1,a2,a3);
5657  // zero out the pointer to ensure segfault if used again
5658  member_ = nullptr;
5659  delete this;
5660  }
5661  }
5662 };
5663 
5664 #ifndef SWIG
5665 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3>
5667 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
5668  return new _ConstTessMemberResultCallback_3_3<true,R,T1,P1,P2,P3,A1,A2,A3>(obj, member, p1, p2, p3);
5669 }
5670 #endif
5671 
5672 #ifndef SWIG
5673 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3>
5675 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
5676  return new _ConstTessMemberResultCallback_3_3<false,R,T1,P1,P2,P3,A1,A2,A3>(obj, member, p1, p2, p3);
5677 }
5678 #endif
5679 
5680 template <bool del, class R, class T, class P1, class P2, class P3, class A1, class A2, class A3>
5682  public:
5684  typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2,A3) ;
5685 
5686  private:
5687  T* object_;
5688  MemberSignature member_;
5689  typename remove_reference<P1>::type p1_;
5690  typename remove_reference<P2>::type p2_;
5691  typename remove_reference<P3>::type p3_;
5692 
5693  public:
5694  inline _TessMemberResultCallback_3_3(T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
5695  : object_(object),
5696  member_(member), p1_(p1), p2_(p2), p3_(p3) { }
5697 
5698  virtual R Run(A1 a1,A2 a2,A3 a3) {
5699  if (!del) {
5700  R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3);
5701  return result;
5702  } else {
5703  R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3);
5704  // zero out the pointer to ensure segfault if used again
5705  member_ = nullptr;
5706  delete this;
5707  return result;
5708  }
5709  }
5710 };
5711 
5712 template <bool del, class T, class P1, class P2, class P3, class A1, class A2, class A3>
5713 class _TessMemberResultCallback_3_3<del, void, T, P1, P2, P3, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
5714  public:
5716  typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2,A3) ;
5717 
5718  private:
5719  T* object_;
5720  MemberSignature member_;
5721  typename remove_reference<P1>::type p1_;
5722  typename remove_reference<P2>::type p2_;
5723  typename remove_reference<P3>::type p3_;
5724 
5725  public:
5726  inline _TessMemberResultCallback_3_3(T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
5727  : object_(object),
5728  member_(member), p1_(p1), p2_(p2), p3_(p3) { }
5729 
5730  virtual void Run(A1 a1,A2 a2,A3 a3) {
5731  if (!del) {
5732  (object_->*member_)(p1_,p2_,p3_,a1,a2,a3);
5733  } else {
5734  (object_->*member_)(p1_,p2_,p3_,a1,a2,a3);
5735  // zero out the pointer to ensure segfault if used again
5736  member_ = nullptr;
5737  delete this;
5738  }
5739  }
5740 };
5741 
5742 #ifndef SWIG
5743 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3>
5745 NewTessCallback(T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
5746  return new _TessMemberResultCallback_3_3<true,R,T1,P1,P2,P3,A1,A2,A3>(obj, member, p1, p2, p3);
5747 }
5748 #endif
5749 
5750 #ifndef SWIG
5751 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3>
5753 NewPermanentTessCallback(T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
5754  return new _TessMemberResultCallback_3_3<false,R,T1,P1,P2,P3,A1,A2,A3>(obj, member, p1, p2, p3);
5755 }
5756 #endif
5757 
5758 template <bool del, class R, class P1, class P2, class P3, class A1, class A2, class A3>
5760  public:
5762  typedef R (*FunctionSignature)(P1,P2,P3,A1,A2,A3);
5763 
5764  private:
5765  FunctionSignature function_;
5766  typename remove_reference<P1>::type p1_;
5767  typename remove_reference<P2>::type p2_;
5768  typename remove_reference<P3>::type p3_;
5769 
5770  public:
5771  inline _TessFunctionResultCallback_3_3(FunctionSignature function, P1 p1, P2 p2, P3 p3)
5772  : function_(function), p1_(p1), p2_(p2), p3_(p3) { }
5773 
5774  virtual R Run(A1 a1,A2 a2,A3 a3) {
5775  if (!del) {
5776  R result = (*function_)(p1_,p2_,p3_,a1,a2,a3);
5777  return result;
5778  } else {
5779  R result = (*function_)(p1_,p2_,p3_,a1,a2,a3);
5780  // zero out the pointer to ensure segfault if used again
5781  function_ = nullptr;
5782  delete this;
5783  return result;
5784  }
5785  }
5786 };
5787 
5788 template <bool del, class P1, class P2, class P3, class A1, class A2, class A3>
5789 class _TessFunctionResultCallback_3_3<del, void, P1, P2, P3, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
5790  public:
5792  typedef void (*FunctionSignature)(P1,P2,P3,A1,A2,A3);
5793 
5794  private:
5795  FunctionSignature function_;
5796  typename remove_reference<P1>::type p1_;
5797  typename remove_reference<P2>::type p2_;
5798  typename remove_reference<P3>::type p3_;
5799 
5800  public:
5801  inline _TessFunctionResultCallback_3_3(FunctionSignature function, P1 p1, P2 p2, P3 p3)
5802  : function_(function), p1_(p1), p2_(p2), p3_(p3) { }
5803 
5804  virtual void Run(A1 a1,A2 a2,A3 a3) {
5805  if (!del) {
5806  (*function_)(p1_,p2_,p3_,a1,a2,a3);
5807  } else {
5808  (*function_)(p1_,p2_,p3_,a1,a2,a3);
5809  // zero out the pointer to ensure segfault if used again
5810  function_ = nullptr;
5811  delete this;
5812  }
5813  }
5814 };
5815 
5816 template <class R, class P1, class P2, class P3, class A1, class A2, class A3>
5818 NewTessCallback(R (*function)(P1,P2,P3,A1,A2,A3), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
5819  return new _TessFunctionResultCallback_3_3<true,R,P1,P2,P3,A1,A2,A3>(function, p1, p2, p3);
5820 }
5821 
5822 template <class R, class P1, class P2, class P3, class A1, class A2, class A3>
5824 NewPermanentTessCallback(R (*function)(P1,P2,P3,A1,A2,A3), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
5825  return new _TessFunctionResultCallback_3_3<false,R,P1,P2,P3,A1,A2,A3>(function, p1, p2, p3);
5826 }
5827 
5828 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
5830  public:
5832  typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3) const;
5833 
5834  private:
5835  const T* object_;
5836  MemberSignature member_;
5837  typename remove_reference<P1>::type p1_;
5838  typename remove_reference<P2>::type p2_;
5839  typename remove_reference<P3>::type p3_;
5840  typename remove_reference<P4>::type p4_;
5841 
5842  public:
5843  inline _ConstTessMemberResultCallback_4_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
5844  : object_(object),
5845  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
5846 
5847  virtual R Run(A1 a1,A2 a2,A3 a3) {
5848  if (!del) {
5849  R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3);
5850  return result;
5851  } else {
5852  R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3);
5853  // zero out the pointer to ensure segfault if used again
5854  member_ = nullptr;
5855  delete this;
5856  return result;
5857  }
5858  }
5859 };
5860 
5861 template <bool del, class T, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
5862 class _ConstTessMemberResultCallback_4_3<del, void, T, P1, P2, P3, P4, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
5863  public:
5865  typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3) const;
5866 
5867  private:
5868  const T* object_;
5869  MemberSignature member_;
5870  typename remove_reference<P1>::type p1_;
5871  typename remove_reference<P2>::type p2_;
5872  typename remove_reference<P3>::type p3_;
5873  typename remove_reference<P4>::type p4_;
5874 
5875  public:
5876  inline _ConstTessMemberResultCallback_4_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
5877  : object_(object),
5878  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
5879 
5880  virtual void Run(A1 a1,A2 a2,A3 a3) {
5881  if (!del) {
5882  (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3);
5883  } else {
5884  (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3);
5885  // zero out the pointer to ensure segfault if used again
5886  member_ = nullptr;
5887  delete this;
5888  }
5889  }
5890 };
5891 
5892 #ifndef SWIG
5893 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
5895 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
5896  return new _ConstTessMemberResultCallback_4_3<true,R,T1,P1,P2,P3,P4,A1,A2,A3>(obj, member, p1, p2, p3, p4);
5897 }
5898 #endif
5899 
5900 #ifndef SWIG
5901 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
5903 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
5904  return new _ConstTessMemberResultCallback_4_3<false,R,T1,P1,P2,P3,P4,A1,A2,A3>(obj, member, p1, p2, p3, p4);
5905 }
5906 #endif
5907 
5908 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
5910  public:
5912  typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3) ;
5913 
5914  private:
5915  T* object_;
5916  MemberSignature member_;
5917  typename remove_reference<P1>::type p1_;
5918  typename remove_reference<P2>::type p2_;
5919  typename remove_reference<P3>::type p3_;
5920  typename remove_reference<P4>::type p4_;
5921 
5922  public:
5923  inline _TessMemberResultCallback_4_3(T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
5924  : object_(object),
5925  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
5926 
5927  virtual R Run(A1 a1,A2 a2,A3 a3) {
5928  if (!del) {
5929  R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3);
5930  return result;
5931  } else {
5932  R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3);
5933  // zero out the pointer to ensure segfault if used again
5934  member_ = nullptr;
5935  delete this;
5936  return result;
5937  }
5938  }
5939 };
5940 
5941 template <bool del, class T, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
5942 class _TessMemberResultCallback_4_3<del, void, T, P1, P2, P3, P4, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
5943  public:
5945  typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3) ;
5946 
5947  private:
5948  T* object_;
5949  MemberSignature member_;
5950  typename remove_reference<P1>::type p1_;
5951  typename remove_reference<P2>::type p2_;
5952  typename remove_reference<P3>::type p3_;
5953  typename remove_reference<P4>::type p4_;
5954 
5955  public:
5956  inline _TessMemberResultCallback_4_3(T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
5957  : object_(object),
5958  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
5959 
5960  virtual void Run(A1 a1,A2 a2,A3 a3) {
5961  if (!del) {
5962  (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3);
5963  } else {
5964  (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3);
5965  // zero out the pointer to ensure segfault if used again
5966  member_ = nullptr;
5967  delete this;
5968  }
5969  }
5970 };
5971 
5972 #ifndef SWIG
5973 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
5975 NewTessCallback(T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
5976  return new _TessMemberResultCallback_4_3<true,R,T1,P1,P2,P3,P4,A1,A2,A3>(obj, member, p1, p2, p3, p4);
5977 }
5978 #endif
5979 
5980 #ifndef SWIG
5981 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
5983 NewPermanentTessCallback(T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
5984  return new _TessMemberResultCallback_4_3<false,R,T1,P1,P2,P3,P4,A1,A2,A3>(obj, member, p1, p2, p3, p4);
5985 }
5986 #endif
5987 
5988 template <bool del, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
5990  public:
5992  typedef R (*FunctionSignature)(P1,P2,P3,P4,A1,A2,A3);
5993 
5994  private:
5995  FunctionSignature function_;
5996  typename remove_reference<P1>::type p1_;
5997  typename remove_reference<P2>::type p2_;
5998  typename remove_reference<P3>::type p3_;
5999  typename remove_reference<P4>::type p4_;
6000 
6001  public:
6002  inline _TessFunctionResultCallback_4_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
6003  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
6004 
6005  virtual R Run(A1 a1,A2 a2,A3 a3) {
6006  if (!del) {
6007  R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3);
6008  return result;
6009  } else {
6010  R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3);
6011  // zero out the pointer to ensure segfault if used again
6012  function_ = nullptr;
6013  delete this;
6014  return result;
6015  }
6016  }
6017 };
6018 
6019 template <bool del, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
6020 class _TessFunctionResultCallback_4_3<del, void, P1, P2, P3, P4, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
6021  public:
6023  typedef void (*FunctionSignature)(P1,P2,P3,P4,A1,A2,A3);
6024 
6025  private:
6026  FunctionSignature function_;
6027  typename remove_reference<P1>::type p1_;
6028  typename remove_reference<P2>::type p2_;
6029  typename remove_reference<P3>::type p3_;
6030  typename remove_reference<P4>::type p4_;
6031 
6032  public:
6033  inline _TessFunctionResultCallback_4_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
6034  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
6035 
6036  virtual void Run(A1 a1,A2 a2,A3 a3) {
6037  if (!del) {
6038  (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3);
6039  } else {
6040  (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3);
6041  // zero out the pointer to ensure segfault if used again
6042  function_ = nullptr;
6043  delete this;
6044  }
6045  }
6046 };
6047 
6048 template <class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
6050 NewTessCallback(R (*function)(P1,P2,P3,P4,A1,A2,A3), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
6051  return new _TessFunctionResultCallback_4_3<true,R,P1,P2,P3,P4,A1,A2,A3>(function, p1, p2, p3, p4);
6052 }
6053 
6054 template <class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
6056 NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,A1,A2,A3), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
6057  return new _TessFunctionResultCallback_4_3<false,R,P1,P2,P3,P4,A1,A2,A3>(function, p1, p2, p3, p4);
6058 }
6059 
6060 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
6062  public:
6064  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3) const;
6065 
6066  private:
6067  const T* object_;
6068  MemberSignature member_;
6069  typename remove_reference<P1>::type p1_;
6070  typename remove_reference<P2>::type p2_;
6071  typename remove_reference<P3>::type p3_;
6072  typename remove_reference<P4>::type p4_;
6073  typename remove_reference<P5>::type p5_;
6074 
6075  public:
6076  inline _ConstTessMemberResultCallback_5_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
6077  : object_(object),
6078  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
6079 
6080  virtual R Run(A1 a1,A2 a2,A3 a3) {
6081  if (!del) {
6082  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
6083  return result;
6084  } else {
6085  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
6086  // zero out the pointer to ensure segfault if used again
6087  member_ = nullptr;
6088  delete this;
6089  return result;
6090  }
6091  }
6092 };
6093 
6094 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
6095 class _ConstTessMemberResultCallback_5_3<del, void, T, P1, P2, P3, P4, P5, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
6096  public:
6098  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3) const;
6099 
6100  private:
6101  const T* object_;
6102  MemberSignature member_;
6103  typename remove_reference<P1>::type p1_;
6104  typename remove_reference<P2>::type p2_;
6105  typename remove_reference<P3>::type p3_;
6106  typename remove_reference<P4>::type p4_;
6107  typename remove_reference<P5>::type p5_;
6108 
6109  public:
6110  inline _ConstTessMemberResultCallback_5_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
6111  : object_(object),
6112  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
6113 
6114  virtual void Run(A1 a1,A2 a2,A3 a3) {
6115  if (!del) {
6116  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
6117  } else {
6118  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
6119  // zero out the pointer to ensure segfault if used again
6120  member_ = nullptr;
6121  delete this;
6122  }
6123  }
6124 };
6125 
6126 #ifndef SWIG
6127 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
6129 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3) 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) {
6130  return new _ConstTessMemberResultCallback_5_3<true,R,T1,P1,P2,P3,P4,P5,A1,A2,A3>(obj, member, p1, p2, p3, p4, p5);
6131 }
6132 #endif
6133 
6134 #ifndef SWIG
6135 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
6137 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3) 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) {
6138  return new _ConstTessMemberResultCallback_5_3<false,R,T1,P1,P2,P3,P4,P5,A1,A2,A3>(obj, member, p1, p2, p3, p4, p5);
6139 }
6140 #endif
6141 
6142 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
6144  public:
6146  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3) ;
6147 
6148  private:
6149  T* object_;
6150  MemberSignature member_;
6151  typename remove_reference<P1>::type p1_;
6152  typename remove_reference<P2>::type p2_;
6153  typename remove_reference<P3>::type p3_;
6154  typename remove_reference<P4>::type p4_;
6155  typename remove_reference<P5>::type p5_;
6156 
6157  public:
6158  inline _TessMemberResultCallback_5_3(T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
6159  : object_(object),
6160  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
6161 
6162  virtual R Run(A1 a1,A2 a2,A3 a3) {
6163  if (!del) {
6164  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
6165  return result;
6166  } else {
6167  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
6168  // zero out the pointer to ensure segfault if used again
6169  member_ = nullptr;
6170  delete this;
6171  return result;
6172  }
6173  }
6174 };
6175 
6176 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
6177 class _TessMemberResultCallback_5_3<del, void, T, P1, P2, P3, P4, P5, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
6178  public:
6180  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3) ;
6181 
6182  private:
6183  T* object_;
6184  MemberSignature member_;
6185  typename remove_reference<P1>::type p1_;
6186  typename remove_reference<P2>::type p2_;
6187  typename remove_reference<P3>::type p3_;
6188  typename remove_reference<P4>::type p4_;
6189  typename remove_reference<P5>::type p5_;
6190 
6191  public:
6192  inline _TessMemberResultCallback_5_3(T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
6193  : object_(object),
6194  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
6195 
6196  virtual void Run(A1 a1,A2 a2,A3 a3) {
6197  if (!del) {
6198  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
6199  } else {
6200  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
6201  // zero out the pointer to ensure segfault if used again
6202  member_ = nullptr;
6203  delete this;
6204  }
6205  }
6206 };
6207 
6208 #ifndef SWIG
6209 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
6211 NewTessCallback(T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3) , 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) {
6212  return new _TessMemberResultCallback_5_3<true,R,T1,P1,P2,P3,P4,P5,A1,A2,A3>(obj, member, p1, p2, p3, p4, p5);
6213 }
6214 #endif
6215 
6216 #ifndef SWIG
6217 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
6219 NewPermanentTessCallback(T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3) , 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) {
6220  return new _TessMemberResultCallback_5_3<false,R,T1,P1,P2,P3,P4,P5,A1,A2,A3>(obj, member, p1, p2, p3, p4, p5);
6221 }
6222 #endif
6223 
6224 template <bool del, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
6226  public:
6228  typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2,A3);
6229 
6230  private:
6231  FunctionSignature function_;
6232  typename remove_reference<P1>::type p1_;
6233  typename remove_reference<P2>::type p2_;
6234  typename remove_reference<P3>::type p3_;
6235  typename remove_reference<P4>::type p4_;
6236  typename remove_reference<P5>::type p5_;
6237 
6238  public:
6239  inline _TessFunctionResultCallback_5_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
6240  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
6241 
6242  virtual R Run(A1 a1,A2 a2,A3 a3) {
6243  if (!del) {
6244  R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
6245  return result;
6246  } else {
6247  R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
6248  // zero out the pointer to ensure segfault if used again
6249  function_ = nullptr;
6250  delete this;
6251  return result;
6252  }
6253  }
6254 };
6255 
6256 template <bool del, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
6257 class _TessFunctionResultCallback_5_3<del, void, P1, P2, P3, P4, P5, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
6258  public:
6260  typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2,A3);
6261 
6262  private:
6263  FunctionSignature function_;
6264  typename remove_reference<P1>::type p1_;
6265  typename remove_reference<P2>::type p2_;
6266  typename remove_reference<P3>::type p3_;
6267  typename remove_reference<P4>::type p4_;
6268  typename remove_reference<P5>::type p5_;
6269 
6270  public:
6271  inline _TessFunctionResultCallback_5_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
6272  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
6273 
6274  virtual void Run(A1 a1,A2 a2,A3 a3) {
6275  if (!del) {
6276  (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
6277  } else {
6278  (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
6279  // zero out the pointer to ensure segfault if used again
6280  function_ = nullptr;
6281  delete this;
6282  }
6283  }
6284 };
6285 
6286 template <class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
6288 NewTessCallback(R (*function)(P1,P2,P3,P4,P5,A1,A2,A3), 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) {
6289  return new _TessFunctionResultCallback_5_3<true,R,P1,P2,P3,P4,P5,A1,A2,A3>(function, p1, p2, p3, p4, p5);
6290 }
6291 
6292 template <class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
6294 NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,A1,A2,A3), 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) {
6295  return new _TessFunctionResultCallback_5_3<false,R,P1,P2,P3,P4,P5,A1,A2,A3>(function, p1, p2, p3, p4, p5);
6296 }
6297 
6298 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
6300  public:
6302  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3) const;
6303 
6304  private:
6305  const T* object_;
6306  MemberSignature member_;
6307  typename remove_reference<P1>::type p1_;
6308  typename remove_reference<P2>::type p2_;
6309  typename remove_reference<P3>::type p3_;
6310  typename remove_reference<P4>::type p4_;
6311  typename remove_reference<P5>::type p5_;
6312  typename remove_reference<P6>::type p6_;
6313 
6314  public:
6315  inline _ConstTessMemberResultCallback_6_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
6316  : object_(object),
6317  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
6318 
6319  virtual R Run(A1 a1,A2 a2,A3 a3) {
6320  if (!del) {
6321  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
6322  return result;
6323  } else {
6324  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
6325  // zero out the pointer to ensure segfault if used again
6326  member_ = nullptr;
6327  delete this;
6328  return result;
6329  }
6330  }
6331 };
6332 
6333 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
6334 class _ConstTessMemberResultCallback_6_3<del, void, T, P1, P2, P3, P4, P5, P6, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
6335  public:
6337  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3) const;
6338 
6339  private:
6340  const T* object_;
6341  MemberSignature member_;
6342  typename remove_reference<P1>::type p1_;
6343  typename remove_reference<P2>::type p2_;
6344  typename remove_reference<P3>::type p3_;
6345  typename remove_reference<P4>::type p4_;
6346  typename remove_reference<P5>::type p5_;
6347  typename remove_reference<P6>::type p6_;
6348 
6349  public:
6350  inline _ConstTessMemberResultCallback_6_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
6351  : object_(object),
6352  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
6353 
6354  virtual void Run(A1 a1,A2 a2,A3 a3) {
6355  if (!del) {
6356  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
6357  } else {
6358  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
6359  // zero out the pointer to ensure segfault if used again
6360  member_ = nullptr;
6361  delete this;
6362  }
6363  }
6364 };
6365 
6366 #ifndef SWIG
6367 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
6369 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3) 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) {
6370  return new _ConstTessMemberResultCallback_6_3<true,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3>(obj, member, p1, p2, p3, p4, p5, p6);
6371 }
6372 #endif
6373 
6374 #ifndef SWIG
6375 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
6377 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3) 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) {
6378  return new _ConstTessMemberResultCallback_6_3<false,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3>(obj, member, p1, p2, p3, p4, p5, p6);
6379 }
6380 #endif
6381 
6382 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
6384  public:
6386  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3) ;
6387 
6388  private:
6389  T* object_;
6390  MemberSignature member_;
6391  typename remove_reference<P1>::type p1_;
6392  typename remove_reference<P2>::type p2_;
6393  typename remove_reference<P3>::type p3_;
6394  typename remove_reference<P4>::type p4_;
6395  typename remove_reference<P5>::type p5_;
6396  typename remove_reference<P6>::type p6_;
6397 
6398  public:
6399  inline _TessMemberResultCallback_6_3(T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
6400  : object_(object),
6401  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
6402 
6403  virtual R Run(A1 a1,A2 a2,A3 a3) {
6404  if (!del) {
6405  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
6406  return result;
6407  } else {
6408  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
6409  // zero out the pointer to ensure segfault if used again
6410  member_ = nullptr;
6411  delete this;
6412  return result;
6413  }
6414  }
6415 };
6416 
6417 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
6418 class _TessMemberResultCallback_6_3<del, void, T, P1, P2, P3, P4, P5, P6, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
6419  public:
6421  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3) ;
6422 
6423  private:
6424  T* object_;
6425  MemberSignature member_;
6426  typename remove_reference<P1>::type p1_;
6427  typename remove_reference<P2>::type p2_;
6428  typename remove_reference<P3>::type p3_;
6429  typename remove_reference<P4>::type p4_;
6430  typename remove_reference<P5>::type p5_;
6431  typename remove_reference<P6>::type p6_;
6432 
6433  public:
6434  inline _TessMemberResultCallback_6_3(T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
6435  : object_(object),
6436  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
6437 
6438  virtual void Run(A1 a1,A2 a2,A3 a3) {
6439  if (!del) {
6440  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
6441  } else {
6442  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
6443  // zero out the pointer to ensure segfault if used again
6444  member_ = nullptr;
6445  delete this;
6446  }
6447  }
6448 };
6449 
6450 #ifndef SWIG
6451 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
6453 NewTessCallback(T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3) , 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) {
6454  return new _TessMemberResultCallback_6_3<true,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3>(obj, member, p1, p2, p3, p4, p5, p6);
6455 }
6456 #endif
6457 
6458 #ifndef SWIG
6459 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
6461 NewPermanentTessCallback(T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3) , 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) {
6462  return new _TessMemberResultCallback_6_3<false,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3>(obj, member, p1, p2, p3, p4, p5, p6);
6463 }
6464 #endif
6465 
6466 template <bool del, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
6468  public:
6470  typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3);
6471 
6472  private:
6473  FunctionSignature function_;
6474  typename remove_reference<P1>::type p1_;
6475  typename remove_reference<P2>::type p2_;
6476  typename remove_reference<P3>::type p3_;
6477  typename remove_reference<P4>::type p4_;
6478  typename remove_reference<P5>::type p5_;
6479  typename remove_reference<P6>::type p6_;
6480 
6481  public:
6482  inline _TessFunctionResultCallback_6_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
6483  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
6484 
6485  virtual R Run(A1 a1,A2 a2,A3 a3) {
6486  if (!del) {
6487  R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
6488  return result;
6489  } else {
6490  R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
6491  // zero out the pointer to ensure segfault if used again
6492  function_ = nullptr;
6493  delete this;
6494  return result;
6495  }
6496  }
6497 };
6498 
6499 template <bool del, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
6500 class _TessFunctionResultCallback_6_3<del, void, P1, P2, P3, P4, P5, P6, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
6501  public:
6503  typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3);
6504 
6505  private:
6506  FunctionSignature function_;
6507  typename remove_reference<P1>::type p1_;
6508  typename remove_reference<P2>::type p2_;
6509  typename remove_reference<P3>::type p3_;
6510  typename remove_reference<P4>::type p4_;
6511  typename remove_reference<P5>::type p5_;
6512  typename remove_reference<P6>::type p6_;
6513 
6514  public:
6515  inline _TessFunctionResultCallback_6_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
6516  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
6517 
6518  virtual void Run(A1 a1,A2 a2,A3 a3) {
6519  if (!del) {
6520  (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
6521  } else {
6522  (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
6523  // zero out the pointer to ensure segfault if used again
6524  function_ = nullptr;
6525  delete this;
6526  }
6527  }
6528 };
6529 
6530 template <class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
6532 NewTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1,A2,A3), 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) {
6533  return new _TessFunctionResultCallback_6_3<true,R,P1,P2,P3,P4,P5,P6,A1,A2,A3>(function, p1, p2, p3, p4, p5, p6);
6534 }
6535 
6536 template <class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
6538 NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1,A2,A3), 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) {
6539  return new _TessFunctionResultCallback_6_3<false,R,P1,P2,P3,P4,P5,P6,A1,A2,A3>(function, p1, p2, p3, p4, p5, p6);
6540 }
6541 
6542 template <bool del, class R, class T, class A1, class A2, class A3, class A4>
6544  public:
6546  typedef R (T::*MemberSignature)(A1,A2,A3,A4) const;
6547 
6548  private:
6549  const T* object_;
6550  MemberSignature member_;
6551 
6552  public:
6553  inline _ConstTessMemberResultCallback_0_4(const T* object, MemberSignature member)
6554  : object_(object),
6555  member_(member) { }
6556 
6557  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
6558  if (!del) {
6559  R result = (object_->*member_)(a1,a2,a3,a4);
6560  return result;
6561  } else {
6562  R result = (object_->*member_)(a1,a2,a3,a4);
6563  // zero out the pointer to ensure segfault if used again
6564  member_ = nullptr;
6565  delete this;
6566  return result;
6567  }
6568  }
6569 };
6570 
6571 template <bool del, class T, class A1, class A2, class A3, class A4>
6572 class _ConstTessMemberResultCallback_0_4<del, void, T, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
6573  public:
6575  typedef void (T::*MemberSignature)(A1,A2,A3,A4) const;
6576 
6577  private:
6578  const T* object_;
6579  MemberSignature member_;
6580 
6581  public:
6582  inline _ConstTessMemberResultCallback_0_4(const T* object, MemberSignature member)
6583  : object_(object),
6584  member_(member) { }
6585 
6586  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
6587  if (!del) {
6588  (object_->*member_)(a1,a2,a3,a4);
6589  } else {
6590  (object_->*member_)(a1,a2,a3,a4);
6591  // zero out the pointer to ensure segfault if used again
6592  member_ = nullptr;
6593  delete this;
6594  }
6595  }
6596 };
6597 
6598 #ifndef SWIG
6599 template <class T1, class T2, class R, class A1, class A2, class A3, class A4>
6601 NewTessCallback(const T1* obj, R (T2::*member)(A1,A2,A3,A4) const) {
6603 }
6604 #endif
6605 
6606 #ifndef SWIG
6607 template <class T1, class T2, class R, class A1, class A2, class A3, class A4>
6609 NewPermanentTessCallback(const T1* obj, R (T2::*member)(A1,A2,A3,A4) const) {
6611 }
6612 #endif
6613 
6614 template <bool del, class R, class T, class A1, class A2, class A3, class A4>
6616  public:
6618  typedef R (T::*MemberSignature)(A1,A2,A3,A4) ;
6619 
6620  private:
6621  T* object_;
6622  MemberSignature member_;
6623 
6624  public:
6626  : object_(object),
6627  member_(member) { }
6628 
6629  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
6630  if (!del) {
6631  R result = (object_->*member_)(a1,a2,a3,a4);
6632  return result;
6633  } else {
6634  R result = (object_->*member_)(a1,a2,a3,a4);
6635  // zero out the pointer to ensure segfault if used again
6636  member_ = nullptr;
6637  delete this;
6638  return result;
6639  }
6640  }
6641 };
6642 
6643 template <bool del, class T, class A1, class A2, class A3, class A4>
6644 class _TessMemberResultCallback_0_4<del, void, T, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
6645  public:
6647  typedef void (T::*MemberSignature)(A1,A2,A3,A4) ;
6648 
6649  private:
6650  T* object_;
6651  MemberSignature member_;
6652 
6653  public:
6655  : object_(object),
6656  member_(member) { }
6657 
6658  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
6659  if (!del) {
6660  (object_->*member_)(a1,a2,a3,a4);
6661  } else {
6662  (object_->*member_)(a1,a2,a3,a4);
6663  // zero out the pointer to ensure segfault if used again
6664  member_ = nullptr;
6665  delete this;
6666  }
6667  }
6668 };
6669 
6670 #ifndef SWIG
6671 template <class T1, class T2, class R, class A1, class A2, class A3, class A4>
6673 NewTessCallback(T1* obj, R (T2::*member)(A1,A2,A3,A4)) {
6675 }
6676 #endif
6677 
6678 #ifndef SWIG
6679 template <class T1, class T2, class R, class A1, class A2, class A3, class A4>
6681 NewPermanentTessCallback(T1* obj, R (T2::*member)(A1,A2,A3,A4)) {
6683 }
6684 #endif
6685 
6686 template <bool del, class R, class A1, class A2, class A3, class A4>
6688  public:
6690  typedef R (*FunctionSignature)(A1,A2,A3,A4);
6691 
6692  private:
6693  FunctionSignature function_;
6694 
6695  public:
6697  : function_(function) { }
6698 
6699  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
6700  if (!del) {
6701  R result = (*function_)(a1,a2,a3,a4);
6702  return result;
6703  } else {
6704  R result = (*function_)(a1,a2,a3,a4);
6705  // zero out the pointer to ensure segfault if used again
6706  function_ = nullptr;
6707  delete this;
6708  return result;
6709  }
6710  }
6711 };
6712 
6713 template <bool del, class A1, class A2, class A3, class A4>
6714 class _TessFunctionResultCallback_0_4<del, void, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
6715  public:
6717  typedef void (*FunctionSignature)(A1,A2,A3,A4);
6718 
6719  private:
6720  FunctionSignature function_;
6721 
6722  public:
6724  : function_(function) { }
6725 
6726  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
6727  if (!del) {
6728  (*function_)(a1,a2,a3,a4);
6729  } else {
6730  (*function_)(a1,a2,a3,a4);
6731  // zero out the pointer to ensure segfault if used again
6732  function_ = nullptr;
6733  delete this;
6734  }
6735  }
6736 };
6737 
6738 template <class R, class A1, class A2, class A3, class A4>
6740 NewTessCallback(R (*function)(A1,A2,A3,A4)) {
6742 }
6743 
6744 template <class R, class A1, class A2, class A3, class A4>
6746 NewPermanentTessCallback(R (*function)(A1,A2,A3,A4)) {
6748 }
6749 
6750 template <bool del, class R, class T, class P1, class A1, class A2, class A3, class A4>
6752  public:
6754  typedef R (T::*MemberSignature)(P1,A1,A2,A3,A4) const;
6755 
6756  private:
6757  const T* object_;
6758  MemberSignature member_;
6759  typename remove_reference<P1>::type p1_;
6760 
6761  public:
6762  inline _ConstTessMemberResultCallback_1_4(const T* object, MemberSignature member, P1 p1)
6763  : object_(object),
6764  member_(member), p1_(p1) { }
6765 
6766  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
6767  if (!del) {
6768  R result = (object_->*member_)(p1_,a1,a2,a3,a4);
6769  return result;
6770  } else {
6771  R result = (object_->*member_)(p1_,a1,a2,a3,a4);
6772  // zero out the pointer to ensure segfault if used again
6773  member_ = nullptr;
6774  delete this;
6775  return result;
6776  }
6777  }
6778 };
6779 
6780 template <bool del, class T, class P1, class A1, class A2, class A3, class A4>
6781 class _ConstTessMemberResultCallback_1_4<del, void, T, P1, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
6782  public:
6784  typedef void (T::*MemberSignature)(P1,A1,A2,A3,A4) const;
6785 
6786  private:
6787  const T* object_;
6788  MemberSignature member_;
6789  typename remove_reference<P1>::type p1_;
6790 
6791  public:
6792  inline _ConstTessMemberResultCallback_1_4(const T* object, MemberSignature member, P1 p1)
6793  : object_(object),
6794  member_(member), p1_(p1) { }
6795 
6796  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
6797  if (!del) {
6798  (object_->*member_)(p1_,a1,a2,a3,a4);
6799  } else {
6800  (object_->*member_)(p1_,a1,a2,a3,a4);
6801  // zero out the pointer to ensure segfault if used again
6802  member_ = nullptr;
6803  delete this;
6804  }
6805  }
6806 };
6807 
6808 #ifndef SWIG
6809 template <class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4>
6811 NewTessCallback(const T1* obj, R (T2::*member)(P1,A1,A2,A3,A4) const, typename Identity<P1>::type p1) {
6813 }
6814 #endif
6815 
6816 #ifndef SWIG
6817 template <class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4>
6819 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,A1,A2,A3,A4) const, typename Identity<P1>::type p1) {
6821 }
6822 #endif
6823 
6824 template <bool del, class R, class T, class P1, class A1, class A2, class A3, class A4>
6826  public:
6828  typedef R (T::*MemberSignature)(P1,A1,A2,A3,A4) ;
6829 
6830  private:
6831  T* object_;
6832  MemberSignature member_;
6833  typename remove_reference<P1>::type p1_;
6834 
6835  public:
6836  inline _TessMemberResultCallback_1_4(T* object, MemberSignature member, P1 p1)
6837  : object_(object),
6838  member_(member), p1_(p1) { }
6839 
6840  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
6841  if (!del) {
6842  R result = (object_->*member_)(p1_,a1,a2,a3,a4);
6843  return result;
6844  } else {
6845  R result = (object_->*member_)(p1_,a1,a2,a3,a4);
6846  // zero out the pointer to ensure segfault if used again
6847  member_ = nullptr;
6848  delete this;
6849  return result;
6850  }
6851  }
6852 };
6853 
6854 template <bool del, class T, class P1, class A1, class A2, class A3, class A4>
6855 class _TessMemberResultCallback_1_4<del, void, T, P1, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
6856  public:
6858  typedef void (T::*MemberSignature)(P1,A1,A2,A3,A4) ;
6859 
6860  private:
6861  T* object_;
6862  MemberSignature member_;
6863  typename remove_reference<P1>::type p1_;
6864 
6865  public:
6866  inline _TessMemberResultCallback_1_4(T* object, MemberSignature member, P1 p1)
6867  : object_(object),
6868  member_(member), p1_(p1) { }
6869 
6870  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
6871  if (!del) {
6872  (object_->*member_)(p1_,a1,a2,a3,a4);
6873  } else {
6874  (object_->*member_)(p1_,a1,a2,a3,a4);
6875  // zero out the pointer to ensure segfault if used again
6876  member_ = nullptr;
6877  delete this;
6878  }
6879  }
6880 };
6881 
6882 #ifndef SWIG
6883 template <class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4>
6885 NewTessCallback(T1* obj, R (T2::*member)(P1,A1,A2,A3,A4) , typename Identity<P1>::type p1) {
6886  return new _TessMemberResultCallback_1_4<true,R,T1,P1,A1,A2,A3,A4>(obj, member, p1);
6887 }
6888 #endif
6889 
6890 #ifndef SWIG
6891 template <class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4>
6893 NewPermanentTessCallback(T1* obj, R (T2::*member)(P1,A1,A2,A3,A4) , typename Identity<P1>::type p1) {
6895 }
6896 #endif
6897 
6898 template <bool del, class R, class P1, class A1, class A2, class A3, class A4>
6900  public:
6902  typedef R (*FunctionSignature)(P1,A1,A2,A3,A4);
6903 
6904  private:
6905  FunctionSignature function_;
6906  typename remove_reference<P1>::type p1_;
6907 
6908  public:
6910  : function_(function), p1_(p1) { }
6911 
6912  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
6913  if (!del) {
6914  R result = (*function_)(p1_,a1,a2,a3,a4);
6915  return result;
6916  } else {
6917  R result = (*function_)(p1_,a1,a2,a3,a4);
6918  // zero out the pointer to ensure segfault if used again
6919  function_ = nullptr;
6920  delete this;
6921  return result;
6922  }
6923  }
6924 };
6925 
6926 template <bool del, class P1, class A1, class A2, class A3, class A4>
6927 class _TessFunctionResultCallback_1_4<del, void, P1, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
6928  public:
6930  typedef void (*FunctionSignature)(P1,A1,A2,A3,A4);
6931 
6932  private:
6933  FunctionSignature function_;
6934  typename remove_reference<P1>::type p1_;
6935 
6936  public:
6938  : function_(function), p1_(p1) { }
6939 
6940  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
6941  if (!del) {
6942  (*function_)(p1_,a1,a2,a3,a4);
6943  } else {
6944  (*function_)(p1_,a1,a2,a3,a4);
6945  // zero out the pointer to ensure segfault if used again
6946  function_ = nullptr;
6947  delete this;
6948  }
6949  }
6950 };
6951 
6952 template <class R, class P1, class A1, class A2, class A3, class A4>
6954 NewTessCallback(R (*function)(P1,A1,A2,A3,A4), typename Identity<P1>::type p1) {
6956 }
6957 
6958 template <class R, class P1, class A1, class A2, class A3, class A4>
6960 NewPermanentTessCallback(R (*function)(P1,A1,A2,A3,A4), typename Identity<P1>::type p1) {
6962 }
6963 
6964 template <bool del, class R, class T, class P1, class P2, class A1, class A2, class A3, class A4>
6966  public:
6968  typedef R (T::*MemberSignature)(P1,P2,A1,A2,A3,A4) const;
6969 
6970  private:
6971  const T* object_;
6972  MemberSignature member_;
6973  typename remove_reference<P1>::type p1_;
6974  typename remove_reference<P2>::type p2_;
6975 
6976  public:
6977  inline _ConstTessMemberResultCallback_2_4(const T* object, MemberSignature member, P1 p1, P2 p2)
6978  : object_(object),
6979  member_(member), p1_(p1), p2_(p2) { }
6980 
6981  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
6982  if (!del) {
6983  R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4);
6984  return result;
6985  } else {
6986  R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4);
6987  // zero out the pointer to ensure segfault if used again
6988  member_ = nullptr;
6989  delete this;
6990  return result;
6991  }
6992  }
6993 };
6994 
6995 template <bool del, class T, class P1, class P2, class A1, class A2, class A3, class A4>
6996 class _ConstTessMemberResultCallback_2_4<del, void, T, P1, P2, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
6997  public:
6999  typedef void (T::*MemberSignature)(P1,P2,A1,A2,A3,A4) const;
7000 
7001  private:
7002  const T* object_;
7003  MemberSignature member_;
7004  typename remove_reference<P1>::type p1_;
7005  typename remove_reference<P2>::type p2_;
7006 
7007  public:
7008  inline _ConstTessMemberResultCallback_2_4(const T* object, MemberSignature member, P1 p1, P2 p2)
7009  : object_(object),
7010  member_(member), p1_(p1), p2_(p2) { }
7011 
7012  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
7013  if (!del) {
7014  (object_->*member_)(p1_,p2_,a1,a2,a3,a4);
7015  } else {
7016  (object_->*member_)(p1_,p2_,a1,a2,a3,a4);
7017  // zero out the pointer to ensure segfault if used again
7018  member_ = nullptr;
7019  delete this;
7020  }
7021  }
7022 };
7023 
7024 #ifndef SWIG
7025 template <class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4>
7027 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
7029 }
7030 #endif
7031 
7032 #ifndef SWIG
7033 template <class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4>
7035 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
7037 }
7038 #endif
7039 
7040 template <bool del, class R, class T, class P1, class P2, class A1, class A2, class A3, class A4>
7042  public:
7044  typedef R (T::*MemberSignature)(P1,P2,A1,A2,A3,A4) ;
7045 
7046  private:
7047  T* object_;
7048  MemberSignature member_;
7049  typename remove_reference<P1>::type p1_;
7050  typename remove_reference<P2>::type p2_;
7051 
7052  public:
7053  inline _TessMemberResultCallback_2_4(T* object, MemberSignature member, P1 p1, P2 p2)
7054  : object_(object),
7055  member_(member), p1_(p1), p2_(p2) { }
7056 
7057  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
7058  if (!del) {
7059  R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4);
7060  return result;
7061  } else {
7062  R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4);
7063  // zero out the pointer to ensure segfault if used again
7064  member_ = nullptr;
7065  delete this;
7066  return result;
7067  }
7068  }
7069 };
7070 
7071 template <bool del, class T, class P1, class P2, class A1, class A2, class A3, class A4>
7072 class _TessMemberResultCallback_2_4<del, void, T, P1, P2, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
7073  public:
7075  typedef void (T::*MemberSignature)(P1,P2,A1,A2,A3,A4) ;
7076 
7077  private:
7078  T* object_;
7079  MemberSignature member_;
7080  typename remove_reference<P1>::type p1_;
7081  typename remove_reference<P2>::type p2_;
7082 
7083  public:
7084  inline _TessMemberResultCallback_2_4(T* object, MemberSignature member, P1 p1, P2 p2)
7085  : object_(object),
7086  member_(member), p1_(p1), p2_(p2) { }
7087 
7088  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
7089  if (!del) {
7090  (object_->*member_)(p1_,p2_,a1,a2,a3,a4);
7091  } else {
7092  (object_->*member_)(p1_,p2_,a1,a2,a3,a4);
7093  // zero out the pointer to ensure segfault if used again
7094  member_ = nullptr;
7095  delete this;
7096  }
7097  }
7098 };
7099 
7100 #ifndef SWIG
7101 template <class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4>
7103 NewTessCallback(T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4) , typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
7104  return new _TessMemberResultCallback_2_4<true,R,T1,P1,P2,A1,A2,A3,A4>(obj, member, p1, p2);
7105 }
7106 #endif
7107 
7108 #ifndef SWIG
7109 template <class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4>
7111 NewPermanentTessCallback(T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4) , typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
7112  return new _TessMemberResultCallback_2_4<false,R,T1,P1,P2,A1,A2,A3,A4>(obj, member, p1, p2);
7113 }
7114 #endif
7115 
7116 template <bool del, class R, class P1, class P2, class A1, class A2, class A3, class A4>
7118  public:
7120  typedef R (*FunctionSignature)(P1,P2,A1,A2,A3,A4);
7121 
7122  private:
7123  FunctionSignature function_;
7124  typename remove_reference<P1>::type p1_;
7125  typename remove_reference<P2>::type p2_;
7126 
7127  public:
7129  : function_(function), p1_(p1), p2_(p2) { }
7130 
7131  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
7132  if (!del) {
7133  R result = (*function_)(p1_,p2_,a1,a2,a3,a4);
7134  return result;
7135  } else {
7136  R result = (*function_)(p1_,p2_,a1,a2,a3,a4);
7137  // zero out the pointer to ensure segfault if used again
7138  function_ = nullptr;
7139  delete this;
7140  return result;
7141  }
7142  }
7143 };
7144 
7145 template <bool del, class P1, class P2, class A1, class A2, class A3, class A4>
7146 class _TessFunctionResultCallback_2_4<del, void, P1, P2, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
7147  public:
7149  typedef void (*FunctionSignature)(P1,P2,A1,A2,A3,A4);
7150 
7151  private:
7152  FunctionSignature function_;
7153  typename remove_reference<P1>::type p1_;
7154  typename remove_reference<P2>::type p2_;
7155 
7156  public:
7158  : function_(function), p1_(p1), p2_(p2) { }
7159 
7160  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
7161  if (!del) {
7162  (*function_)(p1_,p2_,a1,a2,a3,a4);
7163  } else {
7164  (*function_)(p1_,p2_,a1,a2,a3,a4);
7165  // zero out the pointer to ensure segfault if used again
7166  function_ = nullptr;
7167  delete this;
7168  }
7169  }
7170 };
7171 
7172 template <class R, class P1, class P2, class A1, class A2, class A3, class A4>
7174 NewTessCallback(R (*function)(P1,P2,A1,A2,A3,A4), typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
7175  return new _TessFunctionResultCallback_2_4<true,R,P1,P2,A1,A2,A3,A4>(function, p1, p2);
7176 }
7177 
7178 template <class R, class P1, class P2, class A1, class A2, class A3, class A4>
7180 NewPermanentTessCallback(R (*function)(P1,P2,A1,A2,A3,A4), typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
7182 }
7183 
7184 template <bool del, class R, class T, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
7186  public:
7188  typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4) const;
7189 
7190  private:
7191  const T* object_;
7192  MemberSignature member_;
7193  typename remove_reference<P1>::type p1_;
7194  typename remove_reference<P2>::type p2_;
7195  typename remove_reference<P3>::type p3_;
7196 
7197  public:
7198  inline _ConstTessMemberResultCallback_3_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
7199  : object_(object),
7200  member_(member), p1_(p1), p2_(p2), p3_(p3) { }
7201 
7202  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
7203  if (!del) {
7204  R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4);
7205  return result;
7206  } else {
7207  R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4);
7208  // zero out the pointer to ensure segfault if used again
7209  member_ = nullptr;
7210  delete this;
7211  return result;
7212  }
7213  }
7214 };
7215 
7216 template <bool del, class T, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
7217 class _ConstTessMemberResultCallback_3_4<del, void, T, P1, P2, P3, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
7218  public:
7220  typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4) const;
7221 
7222  private:
7223  const T* object_;
7224  MemberSignature member_;
7225  typename remove_reference<P1>::type p1_;
7226  typename remove_reference<P2>::type p2_;
7227  typename remove_reference<P3>::type p3_;
7228 
7229  public:
7230  inline _ConstTessMemberResultCallback_3_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
7231  : object_(object),
7232  member_(member), p1_(p1), p2_(p2), p3_(p3) { }
7233 
7234  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
7235  if (!del) {
7236  (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4);
7237  } else {
7238  (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4);
7239  // zero out the pointer to ensure segfault if used again
7240  member_ = nullptr;
7241  delete this;
7242  }
7243  }
7244 };
7245 
7246 #ifndef SWIG
7247 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
7249 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3,A4) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
7250  return new _ConstTessMemberResultCallback_3_4<true,R,T1,P1,P2,P3,A1,A2,A3,A4>(obj, member, p1, p2, p3);
7251 }
7252 #endif
7253 
7254 #ifndef SWIG
7255 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
7257 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3,A4) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
7258  return new _ConstTessMemberResultCallback_3_4<false,R,T1,P1,P2,P3,A1,A2,A3,A4>(obj, member, p1, p2, p3);
7259 }
7260 #endif
7261 
7262 template <bool del, class R, class T, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
7264  public:
7266  typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4) ;
7267 
7268  private:
7269  T* object_;
7270  MemberSignature member_;
7271  typename remove_reference<P1>::type p1_;
7272  typename remove_reference<P2>::type p2_;
7273  typename remove_reference<P3>::type p3_;
7274 
7275  public:
7276  inline _TessMemberResultCallback_3_4(T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
7277  : object_(object),
7278  member_(member), p1_(p1), p2_(p2), p3_(p3) { }
7279 
7280  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
7281  if (!del) {
7282  R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4);
7283  return result;
7284  } else {
7285  R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4);
7286  // zero out the pointer to ensure segfault if used again
7287  member_ = nullptr;
7288  delete this;
7289  return result;
7290  }
7291  }
7292 };
7293 
7294 template <bool del, class T, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
7295 class _TessMemberResultCallback_3_4<del, void, T, P1, P2, P3, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
7296  public:
7298  typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4) ;
7299 
7300  private:
7301  T* object_;
7302  MemberSignature member_;
7303  typename remove_reference<P1>::type p1_;
7304  typename remove_reference<P2>::type p2_;
7305  typename remove_reference<P3>::type p3_;
7306 
7307  public:
7308  inline _TessMemberResultCallback_3_4(T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
7309  : object_(object),
7310  member_(member), p1_(p1), p2_(p2), p3_(p3) { }
7311 
7312  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
7313  if (!del) {
7314  (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4);
7315  } else {
7316  (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4);
7317  // zero out the pointer to ensure segfault if used again
7318  member_ = nullptr;
7319  delete this;
7320  }
7321  }
7322 };
7323 
7324 #ifndef SWIG
7325 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
7327 NewTessCallback(T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3,A4) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
7328  return new _TessMemberResultCallback_3_4<true,R,T1,P1,P2,P3,A1,A2,A3,A4>(obj, member, p1, p2, p3);
7329 }
7330 #endif
7331 
7332 #ifndef SWIG
7333 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
7335 NewPermanentTessCallback(T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3,A4) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
7336  return new _TessMemberResultCallback_3_4<false,R,T1,P1,P2,P3,A1,A2,A3,A4>(obj, member, p1, p2, p3);
7337 }
7338 #endif
7339 
7340 template <bool del, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
7342  public:
7344  typedef R (*FunctionSignature)(P1,P2,P3,A1,A2,A3,A4);
7345 
7346  private:
7347  FunctionSignature function_;
7348  typename remove_reference<P1>::type p1_;
7349  typename remove_reference<P2>::type p2_;
7350  typename remove_reference<P3>::type p3_;
7351 
7352  public:
7353  inline _TessFunctionResultCallback_3_4(FunctionSignature function, P1 p1, P2 p2, P3 p3)
7354  : function_(function), p1_(p1), p2_(p2), p3_(p3) { }
7355 
7356  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
7357  if (!del) {
7358  R result = (*function_)(p1_,p2_,p3_,a1,a2,a3,a4);
7359  return result;
7360  } else {
7361  R result = (*function_)(p1_,p2_,p3_,a1,a2,a3,a4);
7362  // zero out the pointer to ensure segfault if used again
7363  function_ = nullptr;
7364  delete this;
7365  return result;
7366  }
7367  }
7368 };
7369 
7370 template <bool del, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
7371 class _TessFunctionResultCallback_3_4<del, void, P1, P2, P3, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
7372  public:
7374  typedef void (*FunctionSignature)(P1,P2,P3,A1,A2,A3,A4);
7375 
7376  private:
7377  FunctionSignature function_;
7378  typename remove_reference<P1>::type p1_;
7379  typename remove_reference<P2>::type p2_;
7380  typename remove_reference<P3>::type p3_;
7381 
7382  public:
7383  inline _TessFunctionResultCallback_3_4(FunctionSignature function, P1 p1, P2 p2, P3 p3)
7384  : function_(function), p1_(p1), p2_(p2), p3_(p3) { }
7385 
7386  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
7387  if (!del) {
7388  (*function_)(p1_,p2_,p3_,a1,a2,a3,a4);
7389  } else {
7390  (*function_)(p1_,p2_,p3_,a1,a2,a3,a4);
7391  // zero out the pointer to ensure segfault if used again
7392  function_ = nullptr;
7393  delete this;
7394  }
7395  }
7396 };
7397 
7398 template <class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
7400 NewTessCallback(R (*function)(P1,P2,P3,A1,A2,A3,A4), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
7401  return new _TessFunctionResultCallback_3_4<true,R,P1,P2,P3,A1,A2,A3,A4>(function, p1, p2, p3);
7402 }
7403 
7404 template <class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
7406 NewPermanentTessCallback(R (*function)(P1,P2,P3,A1,A2,A3,A4), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
7407  return new _TessFunctionResultCallback_3_4<false,R,P1,P2,P3,A1,A2,A3,A4>(function, p1, p2, p3);
7408 }
7409 
7410 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
7412  public:
7414  typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4) const;
7415 
7416  private:
7417  const T* object_;
7418  MemberSignature member_;
7419  typename remove_reference<P1>::type p1_;
7420  typename remove_reference<P2>::type p2_;
7421  typename remove_reference<P3>::type p3_;
7422  typename remove_reference<P4>::type p4_;
7423 
7424  public:
7425  inline _ConstTessMemberResultCallback_4_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
7426  : object_(object),
7427  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
7428 
7429  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
7430  if (!del) {
7431  R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
7432  return result;
7433  } else {
7434  R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
7435  // zero out the pointer to ensure segfault if used again
7436  member_ = nullptr;
7437  delete this;
7438  return result;
7439  }
7440  }
7441 };
7442 
7443 template <bool del, class T, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
7444 class _ConstTessMemberResultCallback_4_4<del, void, T, P1, P2, P3, P4, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
7445  public:
7447  typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4) const;
7448 
7449  private:
7450  const T* object_;
7451  MemberSignature member_;
7452  typename remove_reference<P1>::type p1_;
7453  typename remove_reference<P2>::type p2_;
7454  typename remove_reference<P3>::type p3_;
7455  typename remove_reference<P4>::type p4_;
7456 
7457  public:
7458  inline _ConstTessMemberResultCallback_4_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
7459  : object_(object),
7460  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
7461 
7462  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
7463  if (!del) {
7464  (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
7465  } else {
7466  (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
7467  // zero out the pointer to ensure segfault if used again
7468  member_ = nullptr;
7469  delete this;
7470  }
7471  }
7472 };
7473 
7474 #ifndef SWIG
7475 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
7477 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3,A4) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
7478  return new _ConstTessMemberResultCallback_4_4<true,R,T1,P1,P2,P3,P4,A1,A2,A3,A4>(obj, member, p1, p2, p3, p4);
7479 }
7480 #endif
7481 
7482 #ifndef SWIG
7483 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
7485 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3,A4) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
7486  return new _ConstTessMemberResultCallback_4_4<false,R,T1,P1,P2,P3,P4,A1,A2,A3,A4>(obj, member, p1, p2, p3, p4);
7487 }
7488 #endif
7489 
7490 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
7492  public:
7494  typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4) ;
7495 
7496  private:
7497  T* object_;
7498  MemberSignature member_;
7499  typename remove_reference<P1>::type p1_;
7500  typename remove_reference<P2>::type p2_;
7501  typename remove_reference<P3>::type p3_;
7502  typename remove_reference<P4>::type p4_;
7503 
7504  public:
7505  inline _TessMemberResultCallback_4_4(T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
7506  : object_(object),
7507  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
7508 
7509  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
7510  if (!del) {
7511  R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
7512  return result;
7513  } else {
7514  R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
7515  // zero out the pointer to ensure segfault if used again
7516  member_ = nullptr;
7517  delete this;
7518  return result;
7519  }
7520  }
7521 };
7522 
7523 template <bool del, class T, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
7524 class _TessMemberResultCallback_4_4<del, void, T, P1, P2, P3, P4, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
7525  public:
7527  typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4) ;
7528 
7529  private:
7530  T* object_;
7531  MemberSignature member_;
7532  typename remove_reference<P1>::type p1_;
7533  typename remove_reference<P2>::type p2_;
7534  typename remove_reference<P3>::type p3_;
7535  typename remove_reference<P4>::type p4_;
7536 
7537  public:
7538  inline _TessMemberResultCallback_4_4(T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
7539  : object_(object),
7540  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
7541 
7542  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
7543  if (!del) {
7544  (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
7545  } else {
7546  (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
7547  // zero out the pointer to ensure segfault if used again
7548  member_ = nullptr;
7549  delete this;
7550  }
7551  }
7552 };
7553 
7554 #ifndef SWIG
7555 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
7557 NewTessCallback(T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3,A4) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
7558  return new _TessMemberResultCallback_4_4<true,R,T1,P1,P2,P3,P4,A1,A2,A3,A4>(obj, member, p1, p2, p3, p4);
7559 }
7560 #endif
7561 
7562 #ifndef SWIG
7563 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
7565 NewPermanentTessCallback(T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3,A4) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
7566  return new _TessMemberResultCallback_4_4<false,R,T1,P1,P2,P3,P4,A1,A2,A3,A4>(obj, member, p1, p2, p3, p4);
7567 }
7568 #endif
7569 
7570 template <bool del, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
7572  public:
7574  typedef R (*FunctionSignature)(P1,P2,P3,P4,A1,A2,A3,A4);
7575 
7576  private:
7577  FunctionSignature function_;
7578  typename remove_reference<P1>::type p1_;
7579  typename remove_reference<P2>::type p2_;
7580  typename remove_reference<P3>::type p3_;
7581  typename remove_reference<P4>::type p4_;
7582 
7583  public:
7584  inline _TessFunctionResultCallback_4_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
7585  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
7586 
7587  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
7588  if (!del) {
7589  R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
7590  return result;
7591  } else {
7592  R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
7593  // zero out the pointer to ensure segfault if used again
7594  function_ = nullptr;
7595  delete this;
7596  return result;
7597  }
7598  }
7599 };
7600 
7601 template <bool del, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
7602 class _TessFunctionResultCallback_4_4<del, void, P1, P2, P3, P4, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
7603  public:
7605  typedef void (*FunctionSignature)(P1,P2,P3,P4,A1,A2,A3,A4);
7606 
7607  private:
7608  FunctionSignature function_;
7609  typename remove_reference<P1>::type p1_;
7610  typename remove_reference<P2>::type p2_;
7611  typename remove_reference<P3>::type p3_;
7612  typename remove_reference<P4>::type p4_;
7613 
7614  public:
7615  inline _TessFunctionResultCallback_4_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
7616  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
7617 
7618  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
7619  if (!del) {
7620  (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
7621  } else {
7622  (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
7623  // zero out the pointer to ensure segfault if used again
7624  function_ = nullptr;
7625  delete this;
7626  }
7627  }
7628 };
7629 
7630 template <class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
7632 NewTessCallback(R (*function)(P1,P2,P3,P4,A1,A2,A3,A4), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
7633  return new _TessFunctionResultCallback_4_4<true,R,P1,P2,P3,P4,A1,A2,A3,A4>(function, p1, p2, p3, p4);
7634 }
7635 
7636 template <class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
7638 NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,A1,A2,A3,A4), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
7639  return new _TessFunctionResultCallback_4_4<false,R,P1,P2,P3,P4,A1,A2,A3,A4>(function, p1, p2, p3, p4);
7640 }
7641 
7642 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
7644  public:
7646  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4) const;
7647 
7648  private:
7649  const T* object_;
7650  MemberSignature member_;
7651  typename remove_reference<P1>::type p1_;
7652  typename remove_reference<P2>::type p2_;
7653  typename remove_reference<P3>::type p3_;
7654  typename remove_reference<P4>::type p4_;
7655  typename remove_reference<P5>::type p5_;
7656 
7657  public:
7658  inline _ConstTessMemberResultCallback_5_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
7659  : object_(object),
7660  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
7661 
7662  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
7663  if (!del) {
7664  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
7665  return result;
7666  } else {
7667  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
7668  // zero out the pointer to ensure segfault if used again
7669  member_ = nullptr;
7670  delete this;
7671  return result;
7672  }
7673  }
7674 };
7675 
7676 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
7677 class _ConstTessMemberResultCallback_5_4<del, void, T, P1, P2, P3, P4, P5, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
7678  public:
7680  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4) const;
7681 
7682  private:
7683  const T* object_;
7684  MemberSignature member_;
7685  typename remove_reference<P1>::type p1_;
7686  typename remove_reference<P2>::type p2_;
7687  typename remove_reference<P3>::type p3_;
7688  typename remove_reference<P4>::type p4_;
7689  typename remove_reference<P5>::type p5_;
7690 
7691  public:
7692  inline _ConstTessMemberResultCallback_5_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
7693  : object_(object),
7694  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
7695 
7696  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
7697  if (!del) {
7698  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
7699  } else {
7700  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
7701  // zero out the pointer to ensure segfault if used again
7702  member_ = nullptr;
7703  delete this;
7704  }
7705  }
7706 };
7707 
7708 #ifndef SWIG
7709 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
7711 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3,A4) 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) {
7712  return new _ConstTessMemberResultCallback_5_4<true,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4>(obj, member, p1, p2, p3, p4, p5);
7713 }
7714 #endif
7715 
7716 #ifndef SWIG
7717 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
7719 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3,A4) 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) {
7720  return new _ConstTessMemberResultCallback_5_4<false,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4>(obj, member, p1, p2, p3, p4, p5);
7721 }
7722 #endif
7723 
7724 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
7726  public:
7728  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4) ;
7729 
7730  private:
7731  T* object_;
7732  MemberSignature member_;
7733  typename remove_reference<P1>::type p1_;
7734  typename remove_reference<P2>::type p2_;
7735  typename remove_reference<P3>::type p3_;
7736  typename remove_reference<P4>::type p4_;
7737  typename remove_reference<P5>::type p5_;
7738 
7739  public:
7740  inline _TessMemberResultCallback_5_4(T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
7741  : object_(object),
7742  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
7743 
7744  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
7745  if (!del) {
7746  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
7747  return result;
7748  } else {
7749  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
7750  // zero out the pointer to ensure segfault if used again
7751  member_ = nullptr;
7752  delete this;
7753  return result;
7754  }
7755  }
7756 };
7757 
7758 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
7759 class _TessMemberResultCallback_5_4<del, void, T, P1, P2, P3, P4, P5, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
7760  public:
7762  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4) ;
7763 
7764  private:
7765  T* object_;
7766  MemberSignature member_;
7767  typename remove_reference<P1>::type p1_;
7768  typename remove_reference<P2>::type p2_;
7769  typename remove_reference<P3>::type p3_;
7770  typename remove_reference<P4>::type p4_;
7771  typename remove_reference<P5>::type p5_;
7772 
7773  public:
7774  inline _TessMemberResultCallback_5_4(T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
7775  : object_(object),
7776  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
7777 
7778  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
7779  if (!del) {
7780  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
7781  } else {
7782  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
7783  // zero out the pointer to ensure segfault if used again
7784  member_ = nullptr;
7785  delete this;
7786  }
7787  }
7788 };
7789 
7790 #ifndef SWIG
7791 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
7793 NewTessCallback(T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3,A4) , 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) {
7794  return new _TessMemberResultCallback_5_4<true,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4>(obj, member, p1, p2, p3, p4, p5);
7795 }
7796 #endif
7797 
7798 #ifndef SWIG
7799 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
7801 NewPermanentTessCallback(T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3,A4) , 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) {
7802  return new _TessMemberResultCallback_5_4<false,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4>(obj, member, p1, p2, p3, p4, p5);
7803 }
7804 #endif
7805 
7806 template <bool del, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
7808  public:
7810  typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4);
7811 
7812  private:
7813  FunctionSignature function_;
7814  typename remove_reference<P1>::type p1_;
7815  typename remove_reference<P2>::type p2_;
7816  typename remove_reference<P3>::type p3_;
7817  typename remove_reference<P4>::type p4_;
7818  typename remove_reference<P5>::type p5_;
7819 
7820  public:
7821  inline _TessFunctionResultCallback_5_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
7822  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
7823 
7824  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
7825  if (!del) {
7826  R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
7827  return result;
7828  } else {
7829  R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
7830  // zero out the pointer to ensure segfault if used again
7831  function_ = nullptr;
7832  delete this;
7833  return result;
7834  }
7835  }
7836 };
7837 
7838 template <bool del, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
7839 class _TessFunctionResultCallback_5_4<del, void, P1, P2, P3, P4, P5, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
7840  public:
7842  typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4);
7843 
7844  private:
7845  FunctionSignature function_;
7846  typename remove_reference<P1>::type p1_;
7847  typename remove_reference<P2>::type p2_;
7848  typename remove_reference<P3>::type p3_;
7849  typename remove_reference<P4>::type p4_;
7850  typename remove_reference<P5>::type p5_;
7851 
7852  public:
7853  inline _TessFunctionResultCallback_5_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
7854  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
7855 
7856  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
7857  if (!del) {
7858  (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
7859  } else {
7860  (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
7861  // zero out the pointer to ensure segfault if used again
7862  function_ = nullptr;
7863  delete this;
7864  }
7865  }
7866 };
7867 
7868 template <class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
7870 NewTessCallback(R (*function)(P1,P2,P3,P4,P5,A1,A2,A3,A4), 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) {
7871  return new _TessFunctionResultCallback_5_4<true,R,P1,P2,P3,P4,P5,A1,A2,A3,A4>(function, p1, p2, p3, p4, p5);
7872 }
7873 
7874 template <class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
7876 NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,A1,A2,A3,A4), 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) {
7877  return new _TessFunctionResultCallback_5_4<false,R,P1,P2,P3,P4,P5,A1,A2,A3,A4>(function, p1, p2, p3, p4, p5);
7878 }
7879 
7880 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4>
7882  public:
7884  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) const;
7885 
7886  private:
7887  const T* object_;
7888  MemberSignature member_;
7889  typename remove_reference<P1>::type p1_;
7890  typename remove_reference<P2>::type p2_;
7891  typename remove_reference<P3>::type p3_;
7892  typename remove_reference<P4>::type p4_;
7893  typename remove_reference<P5>::type p5_;
7894  typename remove_reference<P6>::type p6_;
7895 
7896  public:
7897  inline _ConstTessMemberResultCallback_6_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
7898  : object_(object),
7899  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
7900 
7901  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
7902  if (!del) {
7903  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
7904  return result;
7905  } else {
7906  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
7907  // zero out the pointer to ensure segfault if used again
7908  member_ = nullptr;
7909  delete this;
7910  return result;
7911  }
7912  }
7913 };
7914 
7915 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4>
7916 class _ConstTessMemberResultCallback_6_4<del, void, T, P1, P2, P3, P4, P5, P6, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
7917  public:
7919  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) const;
7920 
7921  private:
7922  const T* object_;
7923  MemberSignature member_;
7924  typename remove_reference<P1>::type p1_;
7925  typename remove_reference<P2>::type p2_;
7926  typename remove_reference<P3>::type p3_;
7927  typename remove_reference<P4>::type p4_;
7928  typename remove_reference<P5>::type p5_;
7929  typename remove_reference<P6>::type p6_;
7930 
7931  public:
7932  inline _ConstTessMemberResultCallback_6_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
7933  : object_(object),
7934  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
7935 
7936  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
7937  if (!del) {
7938  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
7939  } else {
7940  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
7941  // zero out the pointer to ensure segfault if used again
7942  member_ = nullptr;
7943  delete this;
7944  }
7945  }
7946 };
7947 
7948 #ifndef SWIG
7949 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4>
7951 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) 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) {
7952  return new _ConstTessMemberResultCallback_6_4<true,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4>(obj, member, p1, p2, p3, p4, p5, p6);
7953 }
7954 #endif
7955 
7956 #ifndef SWIG
7957 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4>
7959 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) 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) {
7960  return new _ConstTessMemberResultCallback_6_4<false,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4>(obj, member, p1, p2, p3, p4, p5, p6);
7961 }
7962 #endif
7963 
7964 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4>
7966  public:
7968  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) ;
7969 
7970  private:
7971  T* object_;
7972  MemberSignature member_;
7973  typename remove_reference<P1>::type p1_;
7974  typename remove_reference<P2>::type p2_;
7975  typename remove_reference<P3>::type p3_;
7976  typename remove_reference<P4>::type p4_;
7977  typename remove_reference<P5>::type p5_;
7978  typename remove_reference<P6>::type p6_;
7979 
7980  public:
7981  inline _TessMemberResultCallback_6_4(T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
7982  : object_(object),
7983  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
7984 
7985  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
7986  if (!del) {
7987  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
7988  return result;
7989  } else {
7990  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
7991  // zero out the pointer to ensure segfault if used again
7992  member_ = nullptr;
7993  delete this;
7994  return result;
7995  }
7996  }
7997 };
7998 
7999 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4>
8000 class _TessMemberResultCallback_6_4<del, void, T, P1, P2, P3, P4, P5, P6, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
8001  public:
8003  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) ;
8004 
8005  private:
8006  T* object_;
8007  MemberSignature member_;
8008  typename remove_reference<P1>::type p1_;
8009  typename remove_reference<P2>::type p2_;
8010  typename remove_reference<P3>::type p3_;
8011  typename remove_reference<P4>::type p4_;
8012  typename remove_reference<P5>::type p5_;
8013  typename remove_reference<P6>::type p6_;
8014 
8015  public:
8016  inline _TessMemberResultCallback_6_4(T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
8017  : object_(object),
8018  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
8019 
8020  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
8021  if (!del) {
8022  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
8023  } else {
8024  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
8025  // zero out the pointer to ensure segfault if used again
8026  member_ = nullptr;
8027  delete this;
8028  }
8029  }
8030 };
8031 
8032 #ifndef SWIG
8033 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4>
8035 NewTessCallback(T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) , 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) {
8036  return new _TessMemberResultCallback_6_4<true,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4>(obj, member, p1, p2, p3, p4, p5, p6);
8037 }
8038 #endif
8039 
8040 #ifndef SWIG
8041 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4>
8043 NewPermanentTessCallback(T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) , 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) {
8044  return new _TessMemberResultCallback_6_4<false,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4>(obj, member, p1, p2, p3, p4, p5, p6);
8045 }
8046 #endif
8047 
8048 template <bool del, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4>
8050  public:
8052  typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4);
8053 
8054  private:
8055  FunctionSignature function_;
8056  typename remove_reference<P1>::type p1_;
8057  typename remove_reference<P2>::type p2_;
8058  typename remove_reference<P3>::type p3_;
8059  typename remove_reference<P4>::type p4_;
8060  typename remove_reference<P5>::type p5_;
8061  typename remove_reference<P6>::type p6_;
8062 
8063  public:
8064  inline _TessFunctionResultCallback_6_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
8065  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
8066 
8067  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
8068  if (!del) {
8069  R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
8070  return result;
8071  } else {
8072  R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
8073  // zero out the pointer to ensure segfault if used again
8074  function_ = nullptr;
8075  delete this;
8076  return result;
8077  }
8078  }
8079 };
8080 
8081 template <bool del, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4>
8082 class _TessFunctionResultCallback_6_4<del, void, P1, P2, P3, P4, P5, P6, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
8083  public:
8085  typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4);
8086 
8087  private:
8088  FunctionSignature function_;
8089  typename remove_reference<P1>::type p1_;
8090  typename remove_reference<P2>::type p2_;
8091  typename remove_reference<P3>::type p3_;
8092  typename remove_reference<P4>::type p4_;
8093  typename remove_reference<P5>::type p5_;
8094  typename remove_reference<P6>::type p6_;
8095 
8096  public:
8097  inline _TessFunctionResultCallback_6_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
8098  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
8099 
8100  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
8101  if (!del) {
8102  (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
8103  } else {
8104  (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
8105  // zero out the pointer to ensure segfault if used again
8106  function_ = nullptr;
8107  delete this;
8108  }
8109  }
8110 };
8111 
8112 template <class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4>
8114 NewTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4), 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) {
8115  return new _TessFunctionResultCallback_6_4<true,R,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4>(function, p1, p2, p3, p4, p5, p6);
8116 }
8117 
8118 template <class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4>
8120 NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4), 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) {
8121  return new _TessFunctionResultCallback_6_4<false,R,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4>(function, p1, p2, p3, p4, p5, p6);
8122 }
8123 
8124 template <class A1,class A2,class A3,class A4,class A5>
8126  public:
8127  virtual ~TessCallback5() { }
8128  virtual void Run(A1,A2,A3,A4,A5) = 0;
8129 };
8130 
8131 template <class R, class A1,class A2,class A3,class A4,class A5>
8133  public:
8134  virtual ~TessResultCallback5() { }
8135  virtual R Run(A1,A2,A3,A4,A5) = 0;
8136 };
8137 
8138 template <bool del, class R, class T, class A1, class A2, class A3, class A4, class A5>
8140  public:
8142  typedef R (T::*MemberSignature)(A1,A2,A3,A4,A5) const;
8143 
8144  private:
8145  const T* object_;
8146  MemberSignature member_;
8147 
8148  public:
8149  inline _ConstTessMemberResultCallback_0_5(const T* object, MemberSignature member)
8150  : object_(object),
8151  member_(member) { }
8152 
8153  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
8154  if (!del) {
8155  R result = (object_->*member_)(a1,a2,a3,a4,a5);
8156  return result;
8157  } else {
8158  R result = (object_->*member_)(a1,a2,a3,a4,a5);
8159  // zero out the pointer to ensure segfault if used again
8160  member_ = nullptr;
8161  delete this;
8162  return result;
8163  }
8164  }
8165 };
8166 
8167 template <bool del, class T, class A1, class A2, class A3, class A4, class A5>
8168 class _ConstTessMemberResultCallback_0_5<del, void, T, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
8169  public:
8171  typedef void (T::*MemberSignature)(A1,A2,A3,A4,A5) const;
8172 
8173  private:
8174  const T* object_;
8175  MemberSignature member_;
8176 
8177  public:
8178  inline _ConstTessMemberResultCallback_0_5(const T* object, MemberSignature member)
8179  : object_(object),
8180  member_(member) { }
8181 
8182  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
8183  if (!del) {
8184  (object_->*member_)(a1,a2,a3,a4,a5);
8185  } else {
8186  (object_->*member_)(a1,a2,a3,a4,a5);
8187  // zero out the pointer to ensure segfault if used again
8188  member_ = nullptr;
8189  delete this;
8190  }
8191  }
8192 };
8193 
8194 #ifndef SWIG
8195 template <class T1, class T2, class R, class A1, class A2, class A3, class A4, class A5>
8197 NewTessCallback(const T1* obj, R (T2::*member)(A1,A2,A3,A4,A5) const) {
8199 }
8200 #endif
8201 
8202 #ifndef SWIG
8203 template <class T1, class T2, class R, class A1, class A2, class A3, class A4, class A5>
8205 NewPermanentTessCallback(const T1* obj, R (T2::*member)(A1,A2,A3,A4,A5) const) {
8207 }
8208 #endif
8209 
8210 template <bool del, class R, class T, class A1, class A2, class A3, class A4, class A5>
8211 class _TessMemberResultCallback_0_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
8212  public:
8214  typedef R (T::*MemberSignature)(A1,A2,A3,A4,A5) ;
8215 
8216  private:
8217  T* object_;
8218  MemberSignature member_;
8219 
8220  public:
8222  : object_(object),
8223  member_(member) { }
8224 
8225  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
8226  if (!del) {
8227  R result = (object_->*member_)(a1,a2,a3,a4,a5);
8228  return result;
8229  } else {
8230  R result = (object_->*member_)(a1,a2,a3,a4,a5);
8231  // zero out the pointer to ensure segfault if used again
8232  member_ = nullptr;
8233  delete this;
8234  return result;
8235  }
8236  }
8237 };
8238 
8239 template <bool del, class T, class A1, class A2, class A3, class A4, class A5>
8240 class _TessMemberResultCallback_0_5<del, void, T, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
8241  public:
8243  typedef void (T::*MemberSignature)(A1,A2,A3,A4,A5) ;
8244 
8245  private:
8246  T* object_;
8247  MemberSignature member_;
8248 
8249  public:
8251  : object_(object),
8252  member_(member) { }
8253 
8254  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
8255  if (!del) {
8256  (object_->*member_)(a1,a2,a3,a4,a5);
8257  } else {
8258  (object_->*member_)(a1,a2,a3,a4,a5);
8259  // zero out the pointer to ensure segfault if used again
8260  member_ = nullptr;
8261  delete this;
8262  }
8263  }
8264 };
8265 
8266 #ifndef SWIG
8267 template <class T1, class T2, class R, class A1, class A2, class A3, class A4, class A5>
8269 NewTessCallback(T1* obj, R (T2::*member)(A1,A2,A3,A4,A5)) {
8271 }
8272 #endif
8273 
8274 #ifndef SWIG
8275 template <class T1, class T2, class R, class A1, class A2, class A3, class A4, class A5>
8277 NewPermanentTessCallback(T1* obj, R (T2::*member)(A1,A2,A3,A4,A5)) {
8279 }
8280 #endif
8281 
8282 template <bool del, class R, class A1, class A2, class A3, class A4, class A5>
8283 class _TessFunctionResultCallback_0_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
8284  public:
8286  typedef R (*FunctionSignature)(A1,A2,A3,A4,A5);
8287 
8288  private:
8289  FunctionSignature function_;
8290 
8291  public:
8293  : function_(function) { }
8294 
8295  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
8296  if (!del) {
8297  R result = (*function_)(a1,a2,a3,a4,a5);
8298  return result;
8299  } else {
8300  R result = (*function_)(a1,a2,a3,a4,a5);
8301  // zero out the pointer to ensure segfault if used again
8302  function_ = nullptr;
8303  delete this;
8304  return result;
8305  }
8306  }
8307 };
8308 
8309 template <bool del, class A1, class A2, class A3, class A4, class A5>
8310 class _TessFunctionResultCallback_0_5<del, void, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
8311  public:
8313  typedef void (*FunctionSignature)(A1,A2,A3,A4,A5);
8314 
8315  private:
8316  FunctionSignature function_;
8317 
8318  public:
8320  : function_(function) { }
8321 
8322  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
8323  if (!del) {
8324  (*function_)(a1,a2,a3,a4,a5);
8325  } else {
8326  (*function_)(a1,a2,a3,a4,a5);
8327  // zero out the pointer to ensure segfault if used again
8328  function_ = nullptr;
8329  delete this;
8330  }
8331  }
8332 };
8333 
8334 template <class R, class A1, class A2, class A3, class A4, class A5>
8336 NewTessCallback(R (*function)(A1,A2,A3,A4,A5)) {
8338 }
8339 
8340 template <class R, class A1, class A2, class A3, class A4, class A5>
8342 NewPermanentTessCallback(R (*function)(A1,A2,A3,A4,A5)) {
8344 }
8345 
8346 template <bool del, class R, class T, class P1, class A1, class A2, class A3, class A4, class A5>
8348  public:
8350  typedef R (T::*MemberSignature)(P1,A1,A2,A3,A4,A5) const;
8351 
8352  private:
8353  const T* object_;
8354  MemberSignature member_;
8355  typename remove_reference<P1>::type p1_;
8356 
8357  public:
8358  inline _ConstTessMemberResultCallback_1_5(const T* object, MemberSignature member, P1 p1)
8359  : object_(object),
8360  member_(member), p1_(p1) { }
8361 
8362  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
8363  if (!del) {
8364  R result = (object_->*member_)(p1_,a1,a2,a3,a4,a5);
8365  return result;
8366  } else {
8367  R result = (object_->*member_)(p1_,a1,a2,a3,a4,a5);
8368  // zero out the pointer to ensure segfault if used again
8369  member_ = nullptr;
8370  delete this;
8371  return result;
8372  }
8373  }
8374 };
8375 
8376 template <bool del, class T, class P1, class A1, class A2, class A3, class A4, class A5>
8377 class _ConstTessMemberResultCallback_1_5<del, void, T, P1, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
8378  public:
8380  typedef void (T::*MemberSignature)(P1,A1,A2,A3,A4,A5) const;
8381 
8382  private:
8383  const T* object_;
8384  MemberSignature member_;
8385  typename remove_reference<P1>::type p1_;
8386 
8387  public:
8388  inline _ConstTessMemberResultCallback_1_5(const T* object, MemberSignature member, P1 p1)
8389  : object_(object),
8390  member_(member), p1_(p1) { }
8391 
8392  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
8393  if (!del) {
8394  (object_->*member_)(p1_,a1,a2,a3,a4,a5);
8395  } else {
8396  (object_->*member_)(p1_,a1,a2,a3,a4,a5);
8397  // zero out the pointer to ensure segfault if used again
8398  member_ = nullptr;
8399  delete this;
8400  }
8401  }
8402 };
8403 
8404 #ifndef SWIG
8405 template <class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4, class A5>
8407 NewTessCallback(const T1* obj, R (T2::*member)(P1,A1,A2,A3,A4,A5) const, typename Identity<P1>::type p1) {
8409 }
8410 #endif
8411 
8412 #ifndef SWIG
8413 template <class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4, class A5>
8415 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,A1,A2,A3,A4,A5) const, typename Identity<P1>::type p1) {
8417 }
8418 #endif
8419 
8420 template <bool del, class R, class T, class P1, class A1, class A2, class A3, class A4, class A5>
8421 class _TessMemberResultCallback_1_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
8422  public:
8424  typedef R (T::*MemberSignature)(P1,A1,A2,A3,A4,A5) ;
8425 
8426  private:
8427  T* object_;
8428  MemberSignature member_;
8429  typename remove_reference<P1>::type p1_;
8430 
8431  public:
8432  inline _TessMemberResultCallback_1_5(T* object, MemberSignature member, P1 p1)
8433  : object_(object),
8434  member_(member), p1_(p1) { }
8435 
8436  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
8437  if (!del) {
8438  R result = (object_->*member_)(p1_,a1,a2,a3,a4,a5);
8439  return result;
8440  } else {
8441  R result = (object_->*member_)(p1_,a1,a2,a3,a4,a5);
8442  // zero out the pointer to ensure segfault if used again
8443  member_ = nullptr;
8444  delete this;
8445  return result;
8446  }
8447  }
8448 };
8449 
8450 template <bool del, class T, class P1, class A1, class A2, class A3, class A4, class A5>
8451 class _TessMemberResultCallback_1_5<del, void, T, P1, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
8452  public:
8454  typedef void (T::*MemberSignature)(P1,A1,A2,A3,A4,A5) ;
8455 
8456  private:
8457  T* object_;
8458  MemberSignature member_;
8459  typename remove_reference<P1>::type p1_;
8460 
8461  public:
8462  inline _TessMemberResultCallback_1_5(T* object, MemberSignature member, P1 p1)
8463  : object_(object),
8464  member_(member), p1_(p1) { }
8465 
8466  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
8467  if (!del) {
8468  (object_->*member_)(p1_,a1,a2,a3,a4,a5);
8469  } else {
8470  (object_->*member_)(p1_,a1,a2,a3,a4,a5);
8471  // zero out the pointer to ensure segfault if used again
8472  member_ = nullptr;
8473  delete this;
8474  }
8475  }
8476 };
8477 
8478 #ifndef SWIG
8479 template <class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4, class A5>
8481 NewTessCallback(T1* obj, R (T2::*member)(P1,A1,A2,A3,A4,A5) , typename Identity<P1>::type p1) {
8483 }
8484 #endif
8485 
8486 #ifndef SWIG
8487 template <class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4, class A5>
8489 NewPermanentTessCallback(T1* obj, R (T2::*member)(P1,A1,A2,A3,A4,A5) , typename Identity<P1>::type p1) {
8491 }
8492 #endif
8493 
8494 template <bool del, class R, class P1, class A1, class A2, class A3, class A4, class A5>
8495 class _TessFunctionResultCallback_1_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
8496  public:
8498  typedef R (*FunctionSignature)(P1,A1,A2,A3,A4,A5);
8499 
8500  private:
8501  FunctionSignature function_;
8502  typename remove_reference<P1>::type p1_;
8503 
8504  public:
8506  : function_(function), p1_(p1) { }
8507 
8508  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
8509  if (!del) {
8510  R result = (*function_)(p1_,a1,a2,a3,a4,a5);
8511  return result;
8512  } else {
8513  R result = (*function_)(p1_,a1,a2,a3,a4,a5);
8514  // zero out the pointer to ensure segfault if used again
8515  function_ = nullptr;
8516  delete this;
8517  return result;
8518  }
8519  }
8520 };
8521 
8522 template <bool del, class P1, class A1, class A2, class A3, class A4, class A5>
8523 class _TessFunctionResultCallback_1_5<del, void, P1, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
8524  public:
8526  typedef void (*FunctionSignature)(P1,A1,A2,A3,A4,A5);
8527 
8528  private:
8529  FunctionSignature function_;
8530  typename remove_reference<P1>::type p1_;
8531 
8532  public:
8534  : function_(function), p1_(p1) { }
8535 
8536  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
8537  if (!del) {
8538  (*function_)(p1_,a1,a2,a3,a4,a5);
8539  } else {
8540  (*function_)(p1_,a1,a2,a3,a4,a5);
8541  // zero out the pointer to ensure segfault if used again
8542  function_ = nullptr;
8543  delete this;
8544  }
8545  }
8546 };
8547 
8548 template <class R, class P1, class A1, class A2, class A3, class A4, class A5>
8550 NewTessCallback(R (*function)(P1,A1,A2,A3,A4,A5), typename Identity<P1>::type p1) {
8552 }
8553 
8554 template <class R, class P1, class A1, class A2, class A3, class A4, class A5>
8556 NewPermanentTessCallback(R (*function)(P1,A1,A2,A3,A4,A5), typename Identity<P1>::type p1) {
8558 }
8559 
8560 template <bool del, class R, class T, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
8562  public:
8564  typedef R (T::*MemberSignature)(P1,P2,A1,A2,A3,A4,A5) const;
8565 
8566  private:
8567  const T* object_;
8568  MemberSignature member_;
8569  typename remove_reference<P1>::type p1_;
8570  typename remove_reference<P2>::type p2_;
8571 
8572  public:
8573  inline _ConstTessMemberResultCallback_2_5(const T* object, MemberSignature member, P1 p1, P2 p2)
8574  : object_(object),
8575  member_(member), p1_(p1), p2_(p2) { }
8576 
8577  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
8578  if (!del) {
8579  R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5);
8580  return result;
8581  } else {
8582  R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5);
8583  // zero out the pointer to ensure segfault if used again
8584  member_ = nullptr;
8585  delete this;
8586  return result;
8587  }
8588  }
8589 };
8590 
8591 template <bool del, class T, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
8592 class _ConstTessMemberResultCallback_2_5<del, void, T, P1, P2, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
8593  public:
8595  typedef void (T::*MemberSignature)(P1,P2,A1,A2,A3,A4,A5) const;
8596 
8597  private:
8598  const T* object_;
8599  MemberSignature member_;
8600  typename remove_reference<P1>::type p1_;
8601  typename remove_reference<P2>::type p2_;
8602 
8603  public:
8604  inline _ConstTessMemberResultCallback_2_5(const T* object, MemberSignature member, P1 p1, P2 p2)
8605  : object_(object),
8606  member_(member), p1_(p1), p2_(p2) { }
8607 
8608  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
8609  if (!del) {
8610  (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5);
8611  } else {
8612  (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5);
8613  // zero out the pointer to ensure segfault if used again
8614  member_ = nullptr;
8615  delete this;
8616  }
8617  }
8618 };
8619 
8620 #ifndef SWIG
8621 template <class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
8623 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4,A5) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
8625 }
8626 #endif
8627 
8628 #ifndef SWIG
8629 template <class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
8631 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4,A5) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
8633 }
8634 #endif
8635 
8636 template <bool del, class R, class T, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
8637 class _TessMemberResultCallback_2_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
8638  public:
8640  typedef R (T::*MemberSignature)(P1,P2,A1,A2,A3,A4,A5) ;
8641 
8642  private:
8643  T* object_;
8644  MemberSignature member_;
8645  typename remove_reference<P1>::type p1_;
8646  typename remove_reference<P2>::type p2_;
8647 
8648  public:
8649  inline _TessMemberResultCallback_2_5(T* object, MemberSignature member, P1 p1, P2 p2)
8650  : object_(object),
8651  member_(member), p1_(p1), p2_(p2) { }
8652 
8653  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
8654  if (!del) {
8655  R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5);
8656  return result;
8657  } else {
8658  R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5);
8659  // zero out the pointer to ensure segfault if used again
8660  member_ = nullptr;
8661  delete this;
8662  return result;
8663  }
8664  }
8665 };
8666 
8667 template <bool del, class T, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
8668 class _TessMemberResultCallback_2_5<del, void, T, P1, P2, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
8669  public:
8671  typedef void (T::*MemberSignature)(P1,P2,A1,A2,A3,A4,A5) ;
8672 
8673  private:
8674  T* object_;
8675  MemberSignature member_;
8676  typename remove_reference<P1>::type p1_;
8677  typename remove_reference<P2>::type p2_;
8678 
8679  public:
8680  inline _TessMemberResultCallback_2_5(T* object, MemberSignature member, P1 p1, P2 p2)
8681  : object_(object),
8682  member_(member), p1_(p1), p2_(p2) { }
8683 
8684  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
8685  if (!del) {
8686  (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5);
8687  } else {
8688  (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5);
8689  // zero out the pointer to ensure segfault if used again
8690  member_ = nullptr;
8691  delete this;
8692  }
8693  }
8694 };
8695 
8696 #ifndef SWIG
8697 template <class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
8699 NewTessCallback(T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4,A5) , typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
8700  return new _TessMemberResultCallback_2_5<true,R,T1,P1,P2,A1,A2,A3,A4,A5>(obj, member, p1, p2);
8701 }
8702 #endif
8703 
8704 #ifndef SWIG
8705 template <class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
8707 NewPermanentTessCallback(T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4,A5) , typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
8709 }
8710 #endif
8711 
8712 template <bool del, class R, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
8713 class _TessFunctionResultCallback_2_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
8714  public:
8716  typedef R (*FunctionSignature)(P1,P2,A1,A2,A3,A4,A5);
8717 
8718  private:
8719  FunctionSignature function_;
8720  typename remove_reference<P1>::type p1_;
8721  typename remove_reference<P2>::type p2_;
8722 
8723  public:
8725  : function_(function), p1_(p1), p2_(p2) { }
8726 
8727  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
8728  if (!del) {
8729  R result = (*function_)(p1_,p2_,a1,a2,a3,a4,a5);
8730  return result;
8731  } else {
8732  R result = (*function_)(p1_,p2_,a1,a2,a3,a4,a5);
8733  // zero out the pointer to ensure segfault if used again
8734  function_ = nullptr;
8735  delete this;
8736  return result;
8737  }
8738  }
8739 };
8740 
8741 template <bool del, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
8742 class _TessFunctionResultCallback_2_5<del, void, P1, P2, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
8743  public:
8745  typedef void (*FunctionSignature)(P1,P2,A1,A2,A3,A4,A5);
8746 
8747  private:
8748  FunctionSignature function_;
8749  typename remove_reference<P1>::type p1_;
8750  typename remove_reference<P2>::type p2_;
8751 
8752  public:
8754  : function_(function), p1_(p1), p2_(p2) { }
8755 
8756  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
8757  if (!del) {
8758  (*function_)(p1_,p2_,a1,a2,a3,a4,a5);
8759  } else {
8760  (*function_)(p1_,p2_,a1,a2,a3,a4,a5);
8761  // zero out the pointer to ensure segfault if used again
8762  function_ = nullptr;
8763  delete this;
8764  }
8765  }
8766 };
8767 
8768 template <class R, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
8770 NewTessCallback(R (*function)(P1,P2,A1,A2,A3,A4,A5), typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
8772 }
8773 
8774 template <class R, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
8776 NewPermanentTessCallback(R (*function)(P1,P2,A1,A2,A3,A4,A5), typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
8778 }
8779 
8780 template <bool del, class R, class T, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
8782  public:
8784  typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4,A5) const;
8785 
8786  private:
8787  const T* object_;
8788  MemberSignature member_;
8789  typename remove_reference<P1>::type p1_;
8790  typename remove_reference<P2>::type p2_;
8791  typename remove_reference<P3>::type p3_;
8792 
8793  public:
8794  inline _ConstTessMemberResultCallback_3_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
8795  : object_(object),
8796  member_(member), p1_(p1), p2_(p2), p3_(p3) { }
8797 
8798  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
8799  if (!del) {
8800  R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
8801  return result;
8802  } else {
8803  R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
8804  // zero out the pointer to ensure segfault if used again
8805  member_ = nullptr;
8806  delete this;
8807  return result;
8808  }
8809  }
8810 };
8811 
8812 template <bool del, class T, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
8813 class _ConstTessMemberResultCallback_3_5<del, void, T, P1, P2, P3, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
8814  public:
8816  typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4,A5) const;
8817 
8818  private:
8819  const T* object_;
8820  MemberSignature member_;
8821  typename remove_reference<P1>::type p1_;
8822  typename remove_reference<P2>::type p2_;
8823  typename remove_reference<P3>::type p3_;
8824 
8825  public:
8826  inline _ConstTessMemberResultCallback_3_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
8827  : object_(object),
8828  member_(member), p1_(p1), p2_(p2), p3_(p3) { }
8829 
8830  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
8831  if (!del) {
8832  (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
8833  } else {
8834  (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
8835  // zero out the pointer to ensure segfault if used again
8836  member_ = nullptr;
8837  delete this;
8838  }
8839  }
8840 };
8841 
8842 #ifndef SWIG
8843 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
8845 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3,A4,A5) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
8847 }
8848 #endif
8849 
8850 #ifndef SWIG
8851 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
8853 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3,A4,A5) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
8855 }
8856 #endif
8857 
8858 template <bool del, class R, class T, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
8859 class _TessMemberResultCallback_3_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
8860  public:
8862  typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4,A5) ;
8863 
8864  private:
8865  T* object_;
8866  MemberSignature member_;
8867  typename remove_reference<P1>::type p1_;
8868  typename remove_reference<P2>::type p2_;
8869  typename remove_reference<P3>::type p3_;
8870 
8871  public:
8872  inline _TessMemberResultCallback_3_5(T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
8873  : object_(object),
8874  member_(member), p1_(p1), p2_(p2), p3_(p3) { }
8875 
8876  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
8877  if (!del) {
8878  R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
8879  return result;
8880  } else {
8881  R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
8882  // zero out the pointer to ensure segfault if used again
8883  member_ = nullptr;
8884  delete this;
8885  return result;
8886  }
8887  }
8888 };
8889 
8890 template <bool del, class T, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
8891 class _TessMemberResultCallback_3_5<del, void, T, P1, P2, P3, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
8892  public:
8894  typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4,A5) ;
8895 
8896  private:
8897  T* object_;
8898  MemberSignature member_;
8899  typename remove_reference<P1>::type p1_;
8900  typename remove_reference<P2>::type p2_;
8901  typename remove_reference<P3>::type p3_;
8902 
8903  public:
8904  inline _TessMemberResultCallback_3_5(T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
8905  : object_(object),
8906  member_(member), p1_(p1), p2_(p2), p3_(p3) { }
8907 
8908  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
8909  if (!del) {
8910  (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
8911  } else {
8912  (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
8913  // zero out the pointer to ensure segfault if used again
8914  member_ = nullptr;
8915  delete this;
8916  }
8917  }
8918 };
8919 
8920 #ifndef SWIG
8921 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
8923 NewTessCallback(T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3,A4,A5) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
8924  return new _TessMemberResultCallback_3_5<true,R,T1,P1,P2,P3,A1,A2,A3,A4,A5>(obj, member, p1, p2, p3);
8925 }
8926 #endif
8927 
8928 #ifndef SWIG
8929 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
8931 NewPermanentTessCallback(T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3,A4,A5) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
8932  return new _TessMemberResultCallback_3_5<false,R,T1,P1,P2,P3,A1,A2,A3,A4,A5>(obj, member, p1, p2, p3);
8933 }
8934 #endif
8935 
8936 template <bool del, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
8937 class _TessFunctionResultCallback_3_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
8938  public:
8940  typedef R (*FunctionSignature)(P1,P2,P3,A1,A2,A3,A4,A5);
8941 
8942  private:
8943  FunctionSignature function_;
8944  typename remove_reference<P1>::type p1_;
8945  typename remove_reference<P2>::type p2_;
8946  typename remove_reference<P3>::type p3_;
8947 
8948  public:
8949  inline _TessFunctionResultCallback_3_5(FunctionSignature function, P1 p1, P2 p2, P3 p3)
8950  : function_(function), p1_(p1), p2_(p2), p3_(p3) { }
8951 
8952  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
8953  if (!del) {
8954  R result = (*function_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
8955  return result;
8956  } else {
8957  R result = (*function_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
8958  // zero out the pointer to ensure segfault if used again
8959  function_ = nullptr;
8960  delete this;
8961  return result;
8962  }
8963  }
8964 };
8965 
8966 template <bool del, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
8967 class _TessFunctionResultCallback_3_5<del, void, P1, P2, P3, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
8968  public:
8970  typedef void (*FunctionSignature)(P1,P2,P3,A1,A2,A3,A4,A5);
8971 
8972  private:
8973  FunctionSignature function_;
8974  typename remove_reference<P1>::type p1_;
8975  typename remove_reference<P2>::type p2_;
8976  typename remove_reference<P3>::type p3_;
8977 
8978  public:
8979  inline _TessFunctionResultCallback_3_5(FunctionSignature function, P1 p1, P2 p2, P3 p3)
8980  : function_(function), p1_(p1), p2_(p2), p3_(p3) { }
8981 
8982  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
8983  if (!del) {
8984  (*function_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
8985  } else {
8986  (*function_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
8987  // zero out the pointer to ensure segfault if used again
8988  function_ = nullptr;
8989  delete this;
8990  }
8991  }
8992 };
8993 
8994 template <class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
8996 NewTessCallback(R (*function)(P1,P2,P3,A1,A2,A3,A4,A5), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
8997  return new _TessFunctionResultCallback_3_5<true,R,P1,P2,P3,A1,A2,A3,A4,A5>(function, p1, p2, p3);
8998 }
8999 
9000 template <class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
9002 NewPermanentTessCallback(R (*function)(P1,P2,P3,A1,A2,A3,A4,A5), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
9004 }
9005 
9006 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
9008  public:
9010  typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4,A5) const;
9011 
9012  private:
9013  const T* object_;
9014  MemberSignature member_;
9015  typename remove_reference<P1>::type p1_;
9016  typename remove_reference<P2>::type p2_;
9017  typename remove_reference<P3>::type p3_;
9018  typename remove_reference<P4>::type p4_;
9019 
9020  public:
9021  inline _ConstTessMemberResultCallback_4_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
9022  : object_(object),
9023  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
9024 
9025  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
9026  if (!del) {
9027  R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
9028  return result;
9029  } else {
9030  R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
9031  // zero out the pointer to ensure segfault if used again
9032  member_ = nullptr;
9033  delete this;
9034  return result;
9035  }
9036  }
9037 };
9038 
9039 template <bool del, class T, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
9040 class _ConstTessMemberResultCallback_4_5<del, void, T, P1, P2, P3, P4, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
9041  public:
9043  typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4,A5) const;
9044 
9045  private:
9046  const T* object_;
9047  MemberSignature member_;
9048  typename remove_reference<P1>::type p1_;
9049  typename remove_reference<P2>::type p2_;
9050  typename remove_reference<P3>::type p3_;
9051  typename remove_reference<P4>::type p4_;
9052 
9053  public:
9054  inline _ConstTessMemberResultCallback_4_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
9055  : object_(object),
9056  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
9057 
9058  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
9059  if (!del) {
9060  (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
9061  } else {
9062  (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
9063  // zero out the pointer to ensure segfault if used again
9064  member_ = nullptr;
9065  delete this;
9066  }
9067  }
9068 };
9069 
9070 #ifndef SWIG
9071 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
9073 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3,A4,A5) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
9074  return new _ConstTessMemberResultCallback_4_5<true,R,T1,P1,P2,P3,P4,A1,A2,A3,A4,A5>(obj, member, p1, p2, p3, p4);
9075 }
9076 #endif
9077 
9078 #ifndef SWIG
9079 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
9081 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3,A4,A5) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
9082  return new _ConstTessMemberResultCallback_4_5<false,R,T1,P1,P2,P3,P4,A1,A2,A3,A4,A5>(obj, member, p1, p2, p3, p4);
9083 }
9084 #endif
9085 
9086 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
9087 class _TessMemberResultCallback_4_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
9088  public:
9090  typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4,A5) ;
9091 
9092  private:
9093  T* object_;
9094  MemberSignature member_;
9095  typename remove_reference<P1>::type p1_;
9096  typename remove_reference<P2>::type p2_;
9097  typename remove_reference<P3>::type p3_;
9098  typename remove_reference<P4>::type p4_;
9099 
9100  public:
9101  inline _TessMemberResultCallback_4_5(T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
9102  : object_(object),
9103  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
9104 
9105  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
9106  if (!del) {
9107  R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
9108  return result;
9109  } else {
9110  R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
9111  // zero out the pointer to ensure segfault if used again
9112  member_ = nullptr;
9113  delete this;
9114  return result;
9115  }
9116  }
9117 };
9118 
9119 template <bool del, class T, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
9120 class _TessMemberResultCallback_4_5<del, void, T, P1, P2, P3, P4, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
9121  public:
9123  typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4,A5) ;
9124 
9125  private:
9126  T* object_;
9127  MemberSignature member_;
9128  typename remove_reference<P1>::type p1_;
9129  typename remove_reference<P2>::type p2_;
9130  typename remove_reference<P3>::type p3_;
9131  typename remove_reference<P4>::type p4_;
9132 
9133  public:
9134  inline _TessMemberResultCallback_4_5(T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
9135  : object_(object),
9136  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
9137 
9138  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
9139  if (!del) {
9140  (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
9141  } else {
9142  (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
9143  // zero out the pointer to ensure segfault if used again
9144  member_ = nullptr;
9145  delete this;
9146  }
9147  }
9148 };
9149 
9150 #ifndef SWIG
9151 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
9153 NewTessCallback(T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3,A4,A5) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
9154  return new _TessMemberResultCallback_4_5<true,R,T1,P1,P2,P3,P4,A1,A2,A3,A4,A5>(obj, member, p1, p2, p3, p4);
9155 }
9156 #endif
9157 
9158 #ifndef SWIG
9159 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
9161 NewPermanentTessCallback(T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3,A4,A5) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
9162  return new _TessMemberResultCallback_4_5<false,R,T1,P1,P2,P3,P4,A1,A2,A3,A4,A5>(obj, member, p1, p2, p3, p4);
9163 }
9164 #endif
9165 
9166 template <bool del, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
9167 class _TessFunctionResultCallback_4_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
9168  public:
9170  typedef R (*FunctionSignature)(P1,P2,P3,P4,A1,A2,A3,A4,A5);
9171 
9172  private:
9173  FunctionSignature function_;
9174  typename remove_reference<P1>::type p1_;
9175  typename remove_reference<P2>::type p2_;
9176  typename remove_reference<P3>::type p3_;
9177  typename remove_reference<P4>::type p4_;
9178 
9179  public:
9180  inline _TessFunctionResultCallback_4_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
9181  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
9182 
9183  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
9184  if (!del) {
9185  R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
9186  return result;
9187  } else {
9188  R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
9189  // zero out the pointer to ensure segfault if used again
9190  function_ = nullptr;
9191  delete this;
9192  return result;
9193  }
9194  }
9195 };
9196 
9197 template <bool del, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
9198 class _TessFunctionResultCallback_4_5<del, void, P1, P2, P3, P4, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
9199  public:
9201  typedef void (*FunctionSignature)(P1,P2,P3,P4,A1,A2,A3,A4,A5);
9202 
9203  private:
9204  FunctionSignature function_;
9205  typename remove_reference<P1>::type p1_;
9206  typename remove_reference<P2>::type p2_;
9207  typename remove_reference<P3>::type p3_;
9208  typename remove_reference<P4>::type p4_;
9209 
9210  public:
9211  inline _TessFunctionResultCallback_4_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
9212  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
9213 
9214  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
9215  if (!del) {
9216  (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
9217  } else {
9218  (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
9219  // zero out the pointer to ensure segfault if used again
9220  function_ = nullptr;
9221  delete this;
9222  }
9223  }
9224 };
9225 
9226 template <class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
9228 NewTessCallback(R (*function)(P1,P2,P3,P4,A1,A2,A3,A4,A5), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
9229  return new _TessFunctionResultCallback_4_5<true,R,P1,P2,P3,P4,A1,A2,A3,A4,A5>(function, p1, p2, p3, p4);
9230 }
9231 
9232 template <class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
9234 NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,A1,A2,A3,A4,A5), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
9235  return new _TessFunctionResultCallback_4_5<false,R,P1,P2,P3,P4,A1,A2,A3,A4,A5>(function, p1, p2, p3, p4);
9236 }
9237 
9238 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4, class A5>
9240  public:
9242  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) const;
9243 
9244  private:
9245  const T* object_;
9246  MemberSignature member_;
9247  typename remove_reference<P1>::type p1_;
9248  typename remove_reference<P2>::type p2_;
9249  typename remove_reference<P3>::type p3_;
9250  typename remove_reference<P4>::type p4_;
9251  typename remove_reference<P5>::type p5_;
9252 
9253  public:
9254  inline _ConstTessMemberResultCallback_5_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
9255  : object_(object),
9256  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
9257 
9258 
9259  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
9260  if (!del) {
9261  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
9262  return result;
9263  } else {
9264  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
9265  // zero out the pointer to ensure segfault if used again
9266  member_ = nullptr;
9267  delete this;
9268  return result;
9269  }
9270  }
9271 };
9272 
9273 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4, class A5>
9274 class _ConstTessMemberResultCallback_5_5<del, void, T, P1, P2, P3, P4, P5, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
9275  public:
9277  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) const;
9278 
9279  private:
9280  const T* object_;
9281  MemberSignature member_;
9282  typename remove_reference<P1>::type p1_;
9283  typename remove_reference<P2>::type p2_;
9284  typename remove_reference<P3>::type p3_;
9285  typename remove_reference<P4>::type p4_;
9286  typename remove_reference<P5>::type p5_;
9287 
9288  public:
9289  inline _ConstTessMemberResultCallback_5_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
9290  : object_(object),
9291  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
9292 
9293  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
9294  if (!del) {
9295  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
9296  } else {
9297  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
9298  // zero out the pointer to ensure segfault if used again
9299  member_ = nullptr;
9300  delete this;
9301  }
9302  }
9303 };
9304 
9305 #ifndef SWIG
9306 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4, class A5>
9308 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) 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) {
9309  return new _ConstTessMemberResultCallback_5_5<true,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4,A5>(obj, member, p1, p2, p3, p4, p5);
9310 }
9311 #endif
9312 
9313 #ifndef SWIG
9314 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4, class A5>
9316 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) 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) {
9317  return new _ConstTessMemberResultCallback_5_5<false,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4,A5>(obj, member, p1, p2, p3, p4, p5);
9318 }
9319 #endif
9320 
9321 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4, class A5>
9322 class _TessMemberResultCallback_5_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
9323  public:
9325  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) ;
9326 
9327  private:
9328  T* object_;
9329  MemberSignature member_;
9330  typename remove_reference<P1>::type p1_;
9331  typename remove_reference<P2>::type p2_;
9332  typename remove_reference<P3>::type p3_;
9333  typename remove_reference<P4>::type p4_;
9334  typename remove_reference<P5>::type p5_;
9335 
9336  public:
9337  inline _TessMemberResultCallback_5_5(T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
9338  : object_(object),
9339  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
9340 
9341  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
9342  if (!del) {
9343  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
9344  return result;
9345  } else {
9346  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
9347  // zero out the pointer to ensure segfault if used again
9348  member_ = nullptr;
9349  delete this;
9350  return result;
9351  }
9352  }
9353 };
9354 
9355 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4, class A5>
9356 class _TessMemberResultCallback_5_5<del, void, T, P1, P2, P3, P4, P5, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
9357  public:
9359  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) ;
9360 
9361  private:
9362  T* object_;
9363  MemberSignature member_;
9364  typename remove_reference<P1>::type p1_;
9365  typename remove_reference<P2>::type p2_;
9366  typename remove_reference<P3>::type p3_;
9367  typename remove_reference<P4>::type p4_;
9368  typename remove_reference<P5>::type p5_;
9369 
9370  public:
9371  inline _TessMemberResultCallback_5_5(T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
9372  : object_(object),
9373  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
9374 
9375  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
9376  if (!del) {
9377  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
9378  } else {
9379  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
9380  // zero out the pointer to ensure segfault if used again
9381  member_ = nullptr;
9382  delete this;
9383  }
9384  }
9385 };
9386 
9387 #ifndef SWIG
9388 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4, class A5>
9390 NewTessCallback(T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) , 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) {
9391  return new _TessMemberResultCallback_5_5<true,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4,A5>(obj, member, p1, p2, p3, p4, p5);
9392 }
9393 #endif
9394 
9395 #ifndef SWIG
9396 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4, class A5>
9398 NewPermanentTessCallback(T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) , 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) {
9399  return new _TessMemberResultCallback_5_5<false,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4,A5>(obj, member, p1, p2, p3, p4, p5);
9400 }
9401 #endif
9402 
9403 template <bool del, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4, class A5>
9404 class _TessFunctionResultCallback_5_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
9405  public:
9407  typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5);
9408 
9409  private:
9410  FunctionSignature function_;
9411  typename remove_reference<P1>::type p1_;
9412  typename remove_reference<P2>::type p2_;
9413  typename remove_reference<P3>::type p3_;
9414  typename remove_reference<P4>::type p4_;
9415  typename remove_reference<P5>::type p5_;
9416 
9417  public:
9418  inline _TessFunctionResultCallback_5_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
9419  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
9420 
9421  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
9422  if (!del) {
9423  R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
9424  return result;
9425  } else {
9426  R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
9427  // zero out the pointer to ensure segfault if used again
9428  function_ = nullptr;
9429  delete this;
9430  return result;
9431  }
9432  }
9433 };
9434 
9435 template <bool del, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4, class A5>
9436 class _TessFunctionResultCallback_5_5<del, void, P1, P2, P3, P4, P5, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
9437  public:
9439  typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5);
9440 
9441  private:
9442  FunctionSignature function_;
9443  typename remove_reference<P1>::type p1_;
9444  typename remove_reference<P2>::type p2_;
9445  typename remove_reference<P3>::type p3_;
9446  typename remove_reference<P4>::type p4_;
9447  typename remove_reference<P5>::type p5_;
9448 
9449  public:
9450  inline _TessFunctionResultCallback_5_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
9451  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
9452 
9453  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
9454  if (!del) {
9455  (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
9456  } else {
9457  (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
9458  // zero out the pointer to ensure segfault if used again
9459  function_ = nullptr;
9460  delete this;
9461  }
9462  }
9463 };
9464 
9465 template <class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4, class A5>
9467 NewTessCallback(R (*function)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5), 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) {
9468  return new _TessFunctionResultCallback_5_5<true,R,P1,P2,P3,P4,P5,A1,A2,A3,A4,A5>(function, p1, p2, p3, p4, p5);
9469 }
9470 
9471 template <class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4, class A5>
9473 NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5), 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) {
9474  return new _TessFunctionResultCallback_5_5<false,R,P1,P2,P3,P4,P5,A1,A2,A3,A4,A5>(function, p1, p2, p3, p4, p5);
9475 }
9476 
9477 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4, class A5>
9479  public:
9481  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) const;
9482 
9483  private:
9484  const T* object_;
9485  MemberSignature member_;
9486  typename remove_reference<P1>::type p1_;
9487  typename remove_reference<P2>::type p2_;
9488  typename remove_reference<P3>::type p3_;
9489  typename remove_reference<P4>::type p4_;
9490  typename remove_reference<P5>::type p5_;
9491  typename remove_reference<P6>::type p6_;
9492 
9493  public:
9494  inline _ConstTessMemberResultCallback_6_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
9495  : object_(object),
9496  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
9497 
9498  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
9499  if (!del) {
9500  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
9501  return result;
9502  } else {
9503  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
9504  // zero out the pointer to ensure segfault if used again
9505  member_ = nullptr;
9506  delete this;
9507  return result;
9508  }
9509  }
9510 };
9511 
9512 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4, class A5>
9513 class _ConstTessMemberResultCallback_6_5<del, void, T, P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
9514  public:
9516  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) const;
9517 
9518  private:
9519  const T* object_;
9520  MemberSignature member_;
9521  typename remove_reference<P1>::type p1_;
9522  typename remove_reference<P2>::type p2_;
9523  typename remove_reference<P3>::type p3_;
9524  typename remove_reference<P4>::type p4_;
9525  typename remove_reference<P5>::type p5_;
9526  typename remove_reference<P6>::type p6_;
9527 
9528  public:
9529  inline _ConstTessMemberResultCallback_6_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
9530  : object_(object),
9531  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
9532 
9533  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
9534  if (!del) {
9535  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
9536  } else {
9537  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
9538  // zero out the pointer to ensure segfault if used again
9539  member_ = nullptr;
9540  delete this;
9541  }
9542  }
9543 };
9544 
9545 #ifndef SWIG
9546 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4, class A5>
9548 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) 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) {
9549  return new _ConstTessMemberResultCallback_6_5<true,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5>(obj, member, p1, p2, p3, p4, p5, p6);
9550 }
9551 #endif
9552 
9553 #ifndef SWIG
9554 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4, class A5>
9556 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) 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) {
9557  return new _ConstTessMemberResultCallback_6_5<false,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5>(obj, member, p1, p2, p3, p4, p5, p6);
9558 }
9559 #endif
9560 
9561 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4, class A5>
9562 class _TessMemberResultCallback_6_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
9563  public:
9565  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) ;
9566 
9567  private:
9568  T* object_;
9569  MemberSignature member_;
9570  typename remove_reference<P1>::type p1_;
9571  typename remove_reference<P2>::type p2_;
9572  typename remove_reference<P3>::type p3_;
9573  typename remove_reference<P4>::type p4_;
9574  typename remove_reference<P5>::type p5_;
9575  typename remove_reference<P6>::type p6_;
9576 
9577  public:
9578  inline _TessMemberResultCallback_6_5(T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
9579  : object_(object),
9580  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
9581 
9582  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
9583  if (!del) {
9584  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
9585  return result;
9586  } else {
9587  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
9588  // zero out the pointer to ensure segfault if used again
9589  member_ = nullptr;
9590  delete this;
9591  return result;
9592  }
9593  }
9594 };
9595 
9596 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4, class A5>
9597 class _TessMemberResultCallback_6_5<del, void, T, P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
9598  public:
9600  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) ;
9601 
9602  private:
9603  T* object_;
9604  MemberSignature member_;
9605  typename remove_reference<P1>::type p1_;
9606  typename remove_reference<P2>::type p2_;
9607  typename remove_reference<P3>::type p3_;
9608  typename remove_reference<P4>::type p4_;
9609  typename remove_reference<P5>::type p5_;
9610  typename remove_reference<P6>::type p6_;
9611 
9612  public:
9613  inline _TessMemberResultCallback_6_5(T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
9614  : object_(object),
9615  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
9616 
9617  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
9618  if (!del) {
9619  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
9620  } else {
9621  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
9622  // zero out the pointer to ensure segfault if used again
9623  member_ = nullptr;
9624  delete this;
9625  }
9626  }
9627 };
9628 
9629 #ifndef SWIG
9630 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4, class A5>
9632 NewTessCallback(T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) , 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) {
9633  return new _TessMemberResultCallback_6_5<true,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5>(obj, member, p1, p2, p3, p4, p5, p6);
9634 }
9635 #endif
9636 
9637 #ifndef SWIG
9638 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4, class A5>
9640 NewPermanentTessCallback(T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) , 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) {
9641  return new _TessMemberResultCallback_6_5<false,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5>(obj, member, p1, p2, p3, p4, p5, p6);
9642 }
9643 #endif
9644 
9645 template <bool del, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4, class A5>
9646 class _TessFunctionResultCallback_6_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
9647  public:
9649  typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5);
9650 
9651  private:
9652  FunctionSignature function_;
9653  typename remove_reference<P1>::type p1_;
9654  typename remove_reference<P2>::type p2_;
9655  typename remove_reference<P3>::type p3_;
9656  typename remove_reference<P4>::type p4_;
9657  typename remove_reference<P5>::type p5_;
9658  typename remove_reference<P6>::type p6_;
9659 
9660  public:
9661  inline _TessFunctionResultCallback_6_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
9662  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
9663 
9664  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
9665  if (!del) {
9666  R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
9667  return result;
9668  } else {
9669  R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
9670  // zero out the pointer to ensure segfault if used again
9671  function_ = nullptr;
9672  delete this;
9673  return result;
9674  }
9675  }
9676 };
9677 
9678 template <bool del, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4, class A5>
9679 class _TessFunctionResultCallback_6_5<del, void, P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
9680  public:
9682  typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5);
9683 
9684  private:
9685  FunctionSignature function_;
9686  typename remove_reference<P1>::type p1_;
9687  typename remove_reference<P2>::type p2_;
9688  typename remove_reference<P3>::type p3_;
9689  typename remove_reference<P4>::type p4_;
9690  typename remove_reference<P5>::type p5_;
9691  typename remove_reference<P6>::type p6_;
9692 
9693  public:
9694  inline _TessFunctionResultCallback_6_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
9695  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
9696 
9697  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
9698  if (!del) {
9699  (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
9700  } else {
9701  (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
9702  // zero out the pointer to ensure segfault if used again
9703  function_ = nullptr;
9704  delete this;
9705  }
9706  }
9707 };
9708 
9709 template <class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4, class A5>
9711 NewTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5), 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) {
9712  return new _TessFunctionResultCallback_6_5<true,R,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5>(function, p1, p2, p3, p4, p5, p6);
9713 }
9714 
9715 template <class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4, class A5>
9717 NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5), 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) {
9718  return new _TessFunctionResultCallback_6_5<false,R,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5>(function, p1, p2, p3, p4, p5, p6);
9719 }
9720 
9721 #endif // TESS_CALLBACK_SPECIALIZATIONS_H_
_TessFunctionResultCallback_3_3(FunctionSignature function, P1 p1, P2 p2, P3 p3)
TessResultCallback4< R, A1, A2, A3, A4 > base
_TessMemberResultCallback_1_0(T *object, MemberSignature member, P1 p1)
Definition: tesscallback.h:403
TessResultCallback< R > base
Definition: tesscallback.h:438
_TessFunctionResultCallback_0_2(FunctionSignature function)
virtual ~TessResultCallback1()
_ConstTessMemberResultCallback_5_0(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
TessResultCallback2< R, A1, A2 > base
virtual R Run(A1 a1, A2 a2)
R(T::* MemberSignature)(P1, P2, P3, A1, A2) const
_ConstTessMemberResultCallback_0_5(const T *object, MemberSignature member)
_TessMemberResultCallback_2_1(T *object, MemberSignature member, P1 p1, P2 p2)
_ConstTessMemberResultCallback_4_3(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
R(* FunctionSignature)(P1, P2, P3, P4, P5, A1)
TessResultCallback5< R, A1, A2, A3, A4, A5 > base
R(T::* MemberSignature)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5) const
_TessMemberResultCallback_1_5(T *object, MemberSignature member, P1 p1)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
TessResultCallback5< R, A1, A2, A3, A4, A5 > base
TessResultCallback2< R, A1, A2 > base
R(* FunctionSignature)(P1, P2, P3, P4, P5)
virtual ~TessResultCallback2()
R(T::* MemberSignature)(P1, P2, P3, P4, P5, A1, A2, A3) const
_ConstTessMemberResultCallback_3_2(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3)
TessResultCallback2< R, A1, A2 > base
virtual ~TessCallback4()
_TessFunctionResultCallback_1_3(FunctionSignature function, P1 p1)
_ConstTessMemberResultCallback_6_5(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
TessResultCallback3< R, A1, A2, A3 > base
virtual void Run(A1, A2, A3)=0
TessResultCallback< R > base
virtual R Run(A1 a1, A2 a2, A3 a3)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4)
TessResultCallback< R > base
_TessMemberResultCallback_4_4(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
_ConstTessMemberResultCallback_3_1(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3)
_ConstTessMemberResultCallback_5_1(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
_TessMemberResultCallback_4_5(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
TessResultCallback4< R, A1, A2, A3, A4 > base
TessResultCallback3< R, A1, A2, A3 > base
_ConstTessMemberResultCallback_0_4(const T *object, MemberSignature member)
_TessMemberResultCallback_2_0(T *object, MemberSignature member, P1 p1, P2 p2)
Definition: tesscallback.h:591
TessResultCallback< R > base
TessResultCallback4< R, A1, A2, A3, A4 > base
_TessFunctionResultCallback_4_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
virtual R Run(A1 a1, A2 a2)
_TessFunctionResultCallback_5_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
R(* FunctionSignature)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4)
R(* FunctionSignature)(P1, P2, P3, A1, A2, A3)
_ConstTessMemberResultCallback_5_0(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
_TessMemberResultCallback_5_5(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
TessResultCallback3< R, A1, A2, A3 > base
_TessFunctionResultCallback_2_0(FunctionSignature function, P1 p1, P2 p2)
Definition: tesscallback.h:696
TessResultCallback5< R, A1, A2, A3, A4, A5 > base
_TessMemberResultCallback_0_3(T *object, MemberSignature member)
_TessFunctionResultCallback_6_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
R(T::* MemberSignature)(P1, P2, P3, A1, A2)
_TessFunctionResultCallback_3_2(FunctionSignature function, P1 p1, P2 p2, P3 p3)
_TessMemberResultCallback_6_2(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
_TessMemberResultCallback_3_2(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3)
_TessFunctionResultCallback_2_5(FunctionSignature function, P1 p1, P2 p2)
virtual R Run(A1 a1, A2 a2, A3 a3)
TessResultCallback5< R, A1, A2, A3, A4, A5 > base
TessResultCallback< R > base
Definition: tesscallback.h:45
R(T::* MemberSignature)(P1, P2, P3, A1) const
R(T::* MemberSignature)(P1, P2, P3, P4, A1, A2, A3, A4, A5)
_TessMemberResultCallback_3_1(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3)
R(* FunctionSignature)(P1, P2, P3, P4, A1, A2)
TessResultCallback1< R, A1 > base
TessResultCallback1< R, A1 > base
virtual R Run(A1 a1, A2 a2, A3 a3)
_TessMemberResultCallback_5_3(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
TessResultCallback1< R, A1 > base
_TessMemberResultCallback_3_4(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3)
_TessMemberResultCallback_1_1(T *object, MemberSignature member, P1 p1)
virtual R Run(A1 a1, A2 a2)
_TessMemberResultCallback_3_5(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3)
virtual void Run(A1, A2)=0
_TessMemberResultCallback_1_2(T *object, MemberSignature member, P1 p1)
TessResultCallback1< R, A1 > base
TessResultCallback2< R, A1, A2 > base
_TessMemberResultCallback_1_4(T *object, MemberSignature member, P1 p1)
R(* FunctionSignature)(A1, A2, A3)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
_ConstTessMemberResultCallback_6_3(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
R(* FunctionSignature)(P1, P2, P3, P4, A1, A2, A3)
_ConstTessMemberResultCallback_6_0(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
_ConstTessMemberResultCallback_1_3(T *object, MemberSignature member, P1 p1)
TessResultCallback< R > base
Definition: tesscallback.h:954
TessCallback3< A1, A2, A3 > base
TessResultCallback< R > base
Definition: tesscallback.h:806
_TessFunctionResultCallback_5_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
TessResultCallback3< R, A1, A2, A3 > base
TessResultCallback2< R, A1, A2 > base
R(T::* MemberSignature)(A1, A2, A3)
R(T::* MemberSignature)(P1, P2, P3, A1, A2, A3, A4, A5) const
R(T::* MemberSignature)(P1, P2, P3, P4, P5, A1, A2) const
TessResultCallback4< R, A1, A2, A3, A4 > base
_TessMemberResultCallback_3_4(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3)
_ConstTessMemberResultCallback_1_2(const T *object, MemberSignature member, P1 p1)
_ConstTessMemberResultCallback_5_2(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
virtual R Run(A1 a1, A2 a2, A3 a3)
_TessMemberResultCallback_2_2(T *object, MemberSignature member, P1 p1, P2 p2)
virtual R Run(A1 a1, A2 a2)
virtual R Run(A1, A2, A3, A4)=0
R(* FunctionSignature)(P1, A1, A2)
virtual R Run(A1 a1, A2 a2)
_TessMemberResultCallback_4_1(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
TessResultCallback1< R, A1 > base
R(T::* MemberSignature)(P1, A1) const
R(T::* MemberSignature)(P1, P2, P3, P4, P5, A1, A2, A3, A4)
_TessMemberResultCallback_4_4(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
TessResultCallback4< R, A1, A2, A3, A4 > base
_ConstTessMemberResultCallback_0_1(const T *object, MemberSignature member)
_TessMemberResultCallback_1_4(T *object, MemberSignature member, P1 p1)
TessResultCallback< R > base
Definition: tesscallback.h:581
R(* FunctionSignature)(P1, P2, P3, P4, P5, P6)
_TessMemberResultCallback_3_3(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4)
TessResultCallback2< R, A1, A2 > base
R(* FunctionSignature)(P1, P2, A1, A2, A3)
virtual R Run(A1 a1, A2 a2)
R(T::* MemberSignature)(P1, P2, P3, P4, P5, P6, A1, A2)
virtual void Run(A1, A2, A3, A4, A5)=0
TessResultCallback5< R, A1, A2, A3, A4, A5 > base
_ConstTessMemberResultCallback_3_0(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3)
Definition: tesscallback.h:738
_TessMemberResultCallback_5_2(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
R(T::* MemberSignature)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4) const
_TessFunctionResultCallback_1_1(FunctionSignature function, P1 p1)
_ConstTessMemberResultCallback_6_0(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
TessResultCallback5< R, A1, A2, A3, A4, A5 > base
TessResultCallback3< R, A1, A2, A3 > base
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4)
TessResultCallback4< R, A1, A2, A3, A4 > base
R(* FunctionSignature)(P1, P2, P3, P4, A1)
_TessFunctionResultCallback_2_3(FunctionSignature function, P1 p1, P2 p2)
_ConstTessMemberResultCallback_3_2(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3)
R(* FunctionSignature)(P1, P2, P3, P4, P5, A1, A2, A3, A4, A5)
_ConstTessMemberResultCallback_3_3(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3)
_ConstTessMemberResultCallback_6_2(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
_TessFunctionResultCallback_2_2(FunctionSignature function, P1 p1, P2 p2)
TessResultCallback3< R, A1, A2, A3 > base
R(* FunctionSignature)(P1, P2, P3)
Definition: tesscallback.h:885
R(T::* MemberSignature)(P1, P2, P3, P4, P5, A1) const
_TessFunctionResultCallback_4_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
virtual ~TessCallback2()
R(T::* MemberSignature)(P1, P2, P3, P4, P5, P6, A1, A2) const
_TessFunctionResultCallback_2_1(FunctionSignature function, P1 p1, P2 p2)
_TessMemberResultCallback_4_0(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
_ConstTessMemberResultCallback_6_5(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4)
_TessFunctionResultCallback_3_3(FunctionSignature function, P1 p1, P2 p2, P3 p3)
_TessMemberResultCallback_4_3(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
R(T::* MemberSignature)(P1, P2, P3, A1)
TessResultCallback5< R, A1, A2, A3, A4, A5 > base
R(T::* MemberSignature)(P1, P2, P3, P4) const
Definition: tesscallback.h:955
virtual R Run(A1, A2, A3, A4, A5)=0
TessResultCallback3< R, A1, A2, A3 > base
_ConstTessMemberResultCallback_3_1(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3)
TessResultCallback4< R, A1, A2, A3, A4 > base
virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4)
TessResultCallback< R > base
virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
R(T::* MemberSignature)(P1, P2, A1, A2, A3, A4, A5) const
R(T::* MemberSignature)(P1, P2, P3, A1, A2, A3, A4)
_ConstTessMemberResultCallback_2_0(const T *object, MemberSignature member, P1 p1, P2 p2)
Definition: tesscallback.h:514
_TessFunctionResultCallback_1_4(FunctionSignature function, P1 p1)
virtual R Run(A1 a1, A2 a2, A3 a3)
_TessFunctionResultCallback_1_4(FunctionSignature function, P1 p1)
_ConstTessMemberResultCallback_3_5(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3)
R(T::* MemberSignature)(P1, P2, P3, P4, P5, P6, A1) const
TessResultCallback3< R, A1, A2, A3 > base
_TessFunctionResultCallback_1_1(FunctionSignature function, P1 p1)
R(T::* MemberSignature)(P1, P2, P3, P4, A1, A2, A3, A4, A5) const
_ConstTessMemberResultCallback_1_3(T *object, MemberSignature member, P1 p1)
R(T::* MemberSignature)(P1, P2, P3, P4, P5, A1, A2, A3, A4, A5)
_ConstTessMemberResultCallback_0_0< false, R, T1 >::base * NewPermanentTessCallback(const T1 *obj, R(T2::*member)() const)
Definition: tesscallback.h:116
_TessFunctionResultCallback_0_3(FunctionSignature function)
_ConstTessMemberResultCallback_0_5(const T *object, MemberSignature member)
_TessFunctionResultCallback_5_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
virtual R Run(A1 a1, A2 a2)
_TessFunctionResultCallback_4_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
_TessFunctionResultCallback_5_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
_TessMemberResultCallback_5_3(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
_ConstTessMemberResultCallback_1_5(const T *object, MemberSignature member, P1 p1)
virtual R Run(A1 a1, A2 a2, A3 a3)
_ConstTessMemberResultCallback_6_4(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
TessResultCallback1< R, A1 > base
R(T::* MemberSignature)(P1, P2, P3, P4)
R(T::* MemberSignature)(P1, P2, P3, A1, A2, A3, A4) const
_TessFunctionResultCallback_0_5(FunctionSignature function)
_ConstTessMemberResultCallback_1_0(const T *object, MemberSignature member, P1 p1)
Definition: tesscallback.h:299
R(T::* MemberSignature)(P1, P2, P3, P4, A1, A2, A3) const
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4)
_TessFunctionResultCallback_0_4(FunctionSignature function)
R(T::* MemberSignature)(P1, P2, A1, A2, A3, A4) const
R(T::* MemberSignature)(P1, P2, A1) const
TessResultCallback< R > base
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4)
_TessFunctionResultCallback_6_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
_TessMemberResultCallback_2_3(T *object, MemberSignature member, P1 p1, P2 p2)
R(T::* MemberSignature)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5)
_TessFunctionResultCallback_3_5(FunctionSignature function, P1 p1, P2 p2, P3 p3)
R(T::* MemberSignature)(P1, P2, P3)
Definition: tesscallback.h:807
_TessMemberResultCallback_6_3(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
_TessFunctionResultCallback_4_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
R(T::* MemberSignature)(A1, A2, A3, A4, A5)
_ConstTessMemberResultCallback_4_5(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4)
_ConstTessMemberResultCallback_4_3(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
_TessMemberResultCallback_5_2(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
TessResultCallback3< R, A1, A2, A3 > base
_TessFunctionResultCallback_5_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
_TessFunctionResultCallback_6_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
_ConstTessMemberResultCallback_4_4(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4)
_TessFunctionResultCallback_1_2(FunctionSignature function, P1 p1)
_TessMemberResultCallback_6_5(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
R(* FunctionSignature)(P1, P2, P3, P4, P5, A1, A2, A3, A4)
_TessMemberResultCallback_3_2(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4)
_TessMemberResultCallback_0_5(T *object, MemberSignature member)
_ConstTessMemberResultCallback_5_5(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
R(T::* MemberSignature)(P1, P2, A1, A2, A3, A4, A5)
R(T::* MemberSignature)(P1, A1, A2, A3, A4, A5) const
R(* FunctionSignature)(P1, P2, P3, P4, P5, A1, A2, A3)
_ConstTessMemberResultCallback_5_4(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
_TessFunctionResultCallback_6_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
R(* FunctionSignature)(P1, P2, P3, A1)
_TessMemberResultCallback_4_1(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
_TessFunctionResultCallback_1_5(FunctionSignature function, P1 p1)
R(T::* MemberSignature)(P1, P2, A1)
_ConstTessMemberResultCallback_0_0(const T *object, MemberSignature member)
Definition: tesscallback.h:85
virtual ~TessCallback3()
_TessFunctionResultCallback_5_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
TessResultCallback1< R, A1 > base
TessResultCallback4< R, A1, A2, A3, A4 > base
_ConstTessMemberResultCallback_5_3(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
R(* FunctionSignature)(P1, P2, P3, P4, P5, P6, A1, A2)
R(T::* MemberSignature)(P1, P2, A1, A2)
TessResultCallback4< R, A1, A2, A3, A4 > base
R(T::* MemberSignature)(A1, A2, A3, A4, A5) const
_ConstTessMemberResultCallback_5_5(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
virtual void Run(A1)=0
virtual R Run(A1 a1, A2 a2, A3 a3)
_TessMemberResultCallback_5_0(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
virtual R Run(A1 a1, A2 a2, A3 a3)
_ConstTessMemberResultCallback_4_4(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
_TessMemberResultCallback_6_4(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4)
_ConstTessMemberResultCallback_2_0(const T *object, MemberSignature member, P1 p1, P2 p2)
Definition: tesscallback.h:545
_TessMemberResultCallback_2_5(T *object, MemberSignature member, P1 p1, P2 p2)
_TessMemberResultCallback_6_3(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
TessResultCallback< R > base
_TessFunctionResultCallback_6_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4)
R(T::* MemberSignature)(P1, P2, P3, P4, P5)
_TessMemberResultCallback_4_3(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
TessResultCallback5< R, A1, A2, A3, A4, A5 > base
_TessMemberResultCallback_1_5(T *object, MemberSignature member, P1 p1)
virtual R Run(A1 a1, A2 a2, A3 a3)
_TessMemberResultCallback_4_0(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
_ConstTessMemberResultCallback_4_1(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
R(T::* MemberSignature)(P1, P2, P3, A1, A2, A3)
TessResultCallback< R > base
virtual R Run(A1 a1, A2 a2)
_TessMemberResultCallback_4_2(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
R(T::* MemberSignature)(P1, P2, P3, P4, A1, A2)
_TessFunctionResultCallback_3_5(FunctionSignature function, P1 p1, P2 p2, P3 p3)
R(T::* MemberSignature)(P1, P2, P3, P4, A1)
_TessMemberResultCallback_4_5(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
R(T::* MemberSignature)(P1, P2, P3, P4, A1, A2, A3, A4) const
TessResultCallback4< R, A1, A2, A3, A4 > base
_TessMemberResultCallback_6_4(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4)
_TessMemberResultCallback_0_2(T *object, MemberSignature member)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
_TessFunctionResultCallback_4_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
R(* FunctionSignature)(P1, A1, A2, A3)
R(T::* MemberSignature)(P1, P2, A1, A2) const
TessResultCallback5< R, A1, A2, A3, A4, A5 > base
TessResultCallback3< R, A1, A2, A3 > base
_TessFunctionResultCallback_1_0(FunctionSignature function, P1 p1)
Definition: tesscallback.h:474
_TessMemberResultCallback_0_0(T *object, MemberSignature member)
Definition: tesscallback.h:134
R(T::* MemberSignature)(P1, P2, P3) const
Definition: tesscallback.h:728
_TessFunctionResultCallback_4_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
TessResultCallback1< R, A1 > base
TessResultCallback5< R, A1, A2, A3, A4, A5 > base
TessResultCallback< R > base
Definition: tesscallback.h:290
TessResultCallback4< R, A1, A2, A3, A4 > base
_TessFunctionResultCallback_6_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
_ConstTessMemberResultCallback_6_1(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
R(T::* MemberSignature)(P1, P2) const
Definition: tesscallback.h:505
R(T::* MemberSignature)(P1, P2, P3, P4, P5, P6)
TessResultCallback< R > base
Definition: tesscallback.h:504
_TessFunctionResultCallback_5_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
_TessFunctionResultCallback_4_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
TessResultCallback2< R, A1, A2 > base
R(* FunctionSignature)(A1, A2, A3, A4)
TessResultCallback1< R, A1 > base
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
TessResultCallback< R > base
Definition: tesscallback.h:884
_TessMemberResultCallback_0_2(T *object, MemberSignature member)
_TessFunctionResultCallback_5_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
TessResultCallback1< R, A1 > base
_TessFunctionResultCallback_0_2(FunctionSignature function)
_ConstTessMemberResultCallback_5_1(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
R(* FunctionSignature)(P1, P2, A1, A2, A3, A4)
_TessFunctionResultCallback_2_2(FunctionSignature function, P1 p1, P2 p2)
R(T::* MemberSignature)(P1, A1, A2) const
virtual R Run(A1 a1, A2 a2)
R(T::* MemberSignature)(P1, A1, A2, A3, A4) const
_TessMemberResultCallback_2_4(T *object, MemberSignature member, P1 p1, P2 p2)
TessResultCallback< R > base
Definition: tesscallback.h:126
TessResultCallback5< R, A1, A2, A3, A4, A5 > base
_ConstTessMemberResultCallback_0_4(const T *object, MemberSignature member)
_TessMemberResultCallback_3_0(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3)
Definition: tesscallback.h:817
R(T::* MemberSignature)(P1, P2, P3, P4, A1, A2, A3, A4)
R(* FunctionSignature)(P1, P2, P3, P4, P5, P6, A1)
_TessMemberResultCallback_0_4(T *object, MemberSignature member)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4)
R(* FunctionSignature)(P1, P2, P3, A1, A2, A3, A4, A5)
_TessMemberResultCallback_1_2(T *object, MemberSignature member, P1 p1)
_TessMemberResultCallback_6_0(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
TessResultCallback5< R, A1, A2, A3, A4, A5 > base
virtual R Run(A1 a1, A2 a2)
TessResultCallback5< R, A1, A2, A3, A4, A5 > base
virtual R Run(A1, A2)=0
_ConstTessMemberResultCallback_2_5(const T *object, MemberSignature member, P1 p1, P2 p2)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
_ConstTessMemberResultCallback_1_0(const T *object, MemberSignature member, P1 p1)
Definition: tesscallback.h:329
R(* FunctionSignature)(P1, P2, A1, A2)
R(T::* MemberSignature)(P1, P2, P3, P4, P5, A1, A2, A3, A4) const
virtual R Run(A1 a1, A2 a2, A3 a3)
TessResultCallback3< R, A1, A2, A3 > base
_TessFunctionResultCallback_6_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
_TessFunctionResultCallback_4_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
R(T::* MemberSignature)(P1, A1, A2, A3, A4)
_ConstTessMemberResultCallback_6_3(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
TessResultCallback4< R, A1, A2, A3, A4 > base
virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
virtual R Run(A1 a1, A2 a2)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4)
_TessFunctionResultCallback_2_3(FunctionSignature function, P1 p1, P2 p2)
_ConstTessMemberResultCallback_1_1(const T *object, MemberSignature member, P1 p1)
R(T::* MemberSignature)(P1, A1, A2)
R(T::* MemberSignature)(P1, P2, P3, P4, P5, A1, A2, A3)
virtual R Run(A1 a1, A2 a2)
TessResultCallback2< R, A1, A2 > base
TessResultCallback4< R, A1, A2, A3, A4 > base
virtual ~TessClosure()
_TessMemberResultCallback_3_3(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3)
_TessFunctionResultCallback_1_0(FunctionSignature function, P1 p1)
Definition: tesscallback.h:446
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4)
TessResultCallback2< R, A1, A2 > base
TessResultCallback2< R, A1, A2 > base
_TessMemberResultCallback_2_0(T *object, MemberSignature member, P1 p1, P2 p2)
Definition: tesscallback.h:622
_ConstTessMemberResultCallback_0_0(const T *object, MemberSignature member)
Definition: tesscallback.h:53
_TessMemberResultCallback_3_5(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3)
_TessFunctionResultCallback_0_1(FunctionSignature function)
virtual R Run(A1 a1, A2 a2)
_ConstTessMemberResultCallback_0_3(const T *object, MemberSignature member)
TessResultCallback1< R, A1 > base
TessResultCallback3< R, A1, A2, A3 > base
R(T::* MemberSignature)(P1, P2, P3, P4, A1, A2, A3)
static void FailIsRepeatable(const char *name)
_ConstTessMemberResultCallback_2_4(const T *object, MemberSignature member, P1 p1, P2 p2)
TessResultCallback< R > base
Definition: tesscallback.h:207
TessResultCallback1< R, A1 > base
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
virtual R Run(A1 a1, A2 a2, A3 a3)
TessResultCallback5< R, A1, A2, A3, A4, A5 > base
_ConstTessMemberResultCallback_3_3(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3)
_TessFunctionResultCallback_1_2(FunctionSignature function, P1 p1)
R(T::* MemberSignature)(A1, A2, A3, A4)
_ConstTessMemberResultCallback_0_2(const T *object, MemberSignature member)
TessResultCallback3< R, A1, A2, A3 > base
R(T::* MemberSignature)(A1, A2, A3) const
R(T::* MemberSignature)(P1, P2, P3, P4, P5, P6) const
_TessMemberResultCallback_5_0(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
_ConstTessMemberResultCallback_0_2(const T *object, MemberSignature member)
_TessFunctionResultCallback_4_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
TessResultCallback3< R, A1, A2, A3 > base
virtual R Run(A1 a1, A2 a2, A3 a3)
_ConstTessMemberResultCallback_2_3(const T *object, MemberSignature member, P1 p1, P2 p2)
virtual R Run(A1 a1, A2 a2, A3 a3)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
_ConstTessMemberResultCallback_2_5(const T *object, MemberSignature member, P1 p1, P2 p2)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4)
TessResultCallback3< R, A1, A2, A3 > base
_ConstTessMemberResultCallback_6_1(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4)
_ConstTessMemberResultCallback_6_4(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
R(* FunctionSignature)(P1, P2, A1)
_TessMemberResultCallback_2_4(T *object, MemberSignature member, P1 p1, P2 p2)
_TessFunctionResultCallback_5_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
virtual R Run()=0
R(T::* MemberSignature)(P1, P2, P3, P4, A1, A2) const
TessResultCallback1< R, A1 > base
_ConstTessMemberResultCallback_2_3(const T *object, MemberSignature member, P1 p1, P2 p2)
_ConstTessMemberResultCallback_3_4(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3)
R(T::* MemberSignature)(P1, P2, P3, P4, A1) const
virtual R Run(A1 a1, A2 a2, A3 a3)
R(T::* MemberSignature)(P1, P2, P3, P4, P5, P6, A1)
R(* FunctionSignature)(P1, P2, P3, A1, A2, A3, A4)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
TessResultCallback1< R, A1 > base
_TessMemberResultCallback_2_3(T *object, MemberSignature member, P1 p1, P2 p2)
R(T::* MemberSignature)(P1, P2, A1, A2, A3, A4)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
_ConstTessMemberResultCallback_4_2(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
virtual ~TessResultCallback5()
virtual R Run(A1 a1, A2 a2)
TessResultCallback2< R, A1, A2 > base
TessResultCallback3< R, A1, A2, A3 > base
virtual void Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
_TessMemberResultCallback_6_5(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
_TessMemberResultCallback_1_3(T *object, MemberSignature member, P1 p1)
R(T::* MemberSignature)(P1, P2, P3, A1, A2, A3, A4, A5)
_ConstTessMemberResultCallback_6_2(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
TessResultCallback< R > base
Definition: tesscallback.h:727
_TessFunctionResultCallback_2_4(FunctionSignature function, P1 p1, P2 p2)
_TessMemberResultCallback_0_1(T *object, MemberSignature member)
R(T::* MemberSignature)(A1, A2) const
_ConstTessMemberResultCallback_5_4(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
TessResultCallback2< R, A1, A2 > base
TessResultCallback4< R, A1, A2, A3, A4 > base
R(* FunctionSignature)(P1, P2, A1, A2, A3, A4, A5)
R(T::* MemberSignature)(P1, A1, A2, A3) const
R(* FunctionSignature)(P1, A1, A2, A3, A4)
TessResultCallback2< R, A1, A2 > base
_TessFunctionResultCallback_5_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
_TessFunctionResultCallback_0_0(FunctionSignature function)
Definition: tesscallback.h:214
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
R(T::* MemberSignature)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4)
R(* FunctionSignature)(P1, P2, P3, A1, A2)
TessResultCallback1< R, A1 > base
virtual ~TessResultCallback4()
TessResultCallback3< R, A1, A2, A3 > base
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4)
TessResultCallback2< R, A1, A2 > base
_TessFunctionResultCallback_0_1(FunctionSignature function)
_TessMemberResultCallback_6_1(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
_ConstTessMemberResultCallback_4_1(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
_TessFunctionResultCallback_5_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
TessResultCallback< R > base
Definition: tesscallback.h:364
_ConstTessMemberResultCallback_1_5(const T *object, MemberSignature member, P1 p1)
virtual ~TessCallback1()
_ConstTessMemberResultCallback_0_1(const T *object, MemberSignature member)
R(T::* MemberSignature)(P1, A1, A2, A3, A4, A5)
virtual R Run(A1)=0
_TessMemberResultCallback_6_1(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
_TessMemberResultCallback_4_2(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
TessResultCallback5< R, A1, A2, A3, A4, A5 > base
_TessMemberResultCallback_0_0(T *object, MemberSignature member)
Definition: tesscallback.h:166
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
_TessFunctionResultCallback_6_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
TessResultCallback< R > base
Definition: tesscallback.h:658
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
_TessMemberResultCallback_5_1(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
_ConstTessMemberResultCallback_3_5(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3)
TessResultCallback1< R, A1 > base
virtual R Run(A1 a1, A2 a2)
TessResultCallback5< R, A1, A2, A3, A4, A5 > base
_TessMemberResultCallback_0_3(T *object, MemberSignature member)
_TessFunctionResultCallback_2_1(FunctionSignature function, P1 p1, P2 p2)
_ConstTessMemberResultCallback_2_1(const T *object, MemberSignature member, P1 p1, P2 p2)
TessResultCallback3< R, A1, A2, A3 > base
R(* FunctionSignature)(P1, P2, P3, P4, A1, A2, A3, A4)
virtual ~TessCallback5()
R(* FunctionSignature)(P1, P2, P3, P4, A1, A2, A3, A4, A5)
_TessMemberResultCallback_0_4(T *object, MemberSignature member)
_TessMemberResultCallback_2_2(T *object, MemberSignature member, P1 p1, P2 p2)
TessResultCallback5< R, A1, A2, A3, A4, A5 > base
TessResultCallback5< R, A1, A2, A3, A4, A5 > base
TessResultCallback4< R, A1, A2, A3, A4 > base
_ConstTessMemberResultCallback_5_3(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
_ConstTessMemberResultCallback_3_4(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3)
R(T::* MemberSignature)(A1, A2, A3, A4) const
R(T::* MemberSignature)(P1, P2, P3, P4, P5, P6, A1, A2, A3) const
R(T::* MemberSignature)(P1, P2)
Definition: tesscallback.h:582
virtual R Run(A1 a1, A2 a2)
virtual ~TessResultCallback3()
_ConstTessMemberResultCallback_1_4(const T *object, MemberSignature member, P1 p1)
TessResultCallback2< R, A1, A2 > base
TessResultCallback1< R, A1 > base
_TessFunctionResultCallback_6_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
TessResultCallback2< R, A1, A2 > base
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4)
_TessFunctionResultCallback_2_5(FunctionSignature function, P1 p1, P2 p2)
R(T::* MemberSignature)(P1, P2, P3, P4, P5, A1)
_ConstTessMemberResultCallback_0_0< true, R, T1 >::base * NewTessCallback(const T1 *obj, R(T2::*member)() const)
Definition: tesscallback.h:106
_ConstTessMemberResultCallback_3_0(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3)
Definition: tesscallback.h:771
virtual R Run(A1 a1, A2 a2, A3 a3)
virtual void Run()=0
TessResultCallback2< R, A1, A2 > base
TessResultCallback3< R, A1, A2, A3 > base
_TessMemberResultCallback_5_1(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
R(* FunctionSignature)(P1, P2, P3, P4, P5, A1, A2)
TessResultCallback1< R, A1 > base
R(T::* MemberSignature)(P1, P2, A1, A2, A3)
TessResultCallback4< R, A1, A2, A3, A4 > base
_ConstTessMemberResultCallback_2_2(const T *object, MemberSignature member, P1 p1, P2 p2)
_ConstTessMemberResultCallback_4_0(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
Definition: tesscallback.h:966
_TessMemberResultCallback_1_1(T *object, MemberSignature member, P1 p1)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4)
_TessMemberResultCallback_0_1(T *object, MemberSignature member)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
_TessMemberResultCallback_6_2(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
_TessFunctionResultCallback_5_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
R(* FunctionSignature)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5)
virtual R Run(A1 a1, A2 a2)
_TessFunctionResultCallback_3_1(FunctionSignature function, P1 p1, P2 p2, P3 p3)
virtual R Run(A1 a1, A2 a2, A3 a3)
TessResultCallback1< R, A1 > base
_ConstTessMemberResultCallback_4_2(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
_TessFunctionResultCallback_6_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
TessResultCallback2< R, A1, A2 > base
virtual R Run(A1 a1, A2 a2)
_TessMemberResultCallback_3_1(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3)
TessResultCallback4< R, A1, A2, A3, A4 > base
virtual R Run(A1 a1, A2 a2, A3 a3)
virtual void Run(A1, A2, A3, A4)=0
_TessFunctionResultCallback_0_0(FunctionSignature function)
Definition: tesscallback.h:244
_ConstTessMemberResultCallback_1_2(const T *object, MemberSignature member, P1 p1)
virtual R Run(A1 a1, A2 a2, A3 a3)
R(* FunctionSignature)(A1, A2, A3, A4, A5)
_TessFunctionResultCallback_4_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
_TessFunctionResultCallback_3_4(FunctionSignature function, P1 p1, P2 p2, P3 p3)
_TessFunctionResultCallback_1_3(FunctionSignature function, P1 p1)
_TessFunctionResultCallback_4_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4)
_ConstTessMemberResultCallback_4_5(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
TessResultCallback1< R, A1 > base
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
_TessFunctionResultCallback_3_2(FunctionSignature function, P1 p1, P2 p2, P3 p3)
_TessFunctionResultCallback_2_0(FunctionSignature function, P1 p1, P2 p2)
Definition: tesscallback.h:667
virtual R Run(A1 a1, A2 a2, A3 a3)
_TessFunctionResultCallback_3_1(FunctionSignature function, P1 p1, P2 p2, P3 p3)
R(* FunctionSignature)(P1, P2, P3, P4)
R(T::* MemberSignature)(P1, P2, P3, P4, P5, P6, A1, A2, A3)
TessResultCallback4< R, A1, A2, A3, A4 > base
TessResultCallback4< R, A1, A2, A3, A4 > base
_TessMemberResultCallback_1_3(T *object, MemberSignature member, P1 p1)
virtual R Run(A1 a1, A2 a2)
R(T::* MemberSignature)(P1, P2, P3, A1, A2, A3) const
_TessFunctionResultCallback_4_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
_TessMemberResultCallback_1_0(T *object, MemberSignature member, P1 p1)
Definition: tesscallback.h:373
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
TessResultCallback2< R, A1, A2 > base
R(T::* MemberSignature)(P1, A1, A2, A3)
_ConstTessMemberResultCallback_0_3(const T *object, MemberSignature member)
TessResultCallback3< R, A1, A2, A3 > base
R(T::* MemberSignature)(P1, P2, A1, A2, A3) const
TessResultCallback2< R, A1, A2 > base
_TessMemberResultCallback_3_0(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3)
Definition: tesscallback.h:849
virtual R Run(A1, A2, A3)=0
_ConstTessMemberResultCallback_1_1(const T *object, MemberSignature member, P1 p1)
_TessFunctionResultCallback_3_4(FunctionSignature function, P1 p1, P2 p2, P3 p3)
_TessFunctionResultCallback_3_0(FunctionSignature function, P1 p1, P2 p2, P3 p3)
Definition: tesscallback.h:894
virtual R Run(A1 a1, A2 a2, A3 a3)
R(T::* MemberSignature)(P1, P2, P3, P4, P5) const
R(* FunctionSignature)(P1, P2, P3, P4, P5, P6, A1, A2, A3)
_TessFunctionResultCallback_6_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
_TessMemberResultCallback_2_5(T *object, MemberSignature member, P1 p1, P2 p2)
_TessMemberResultCallback_2_1(T *object, MemberSignature member, P1 p1, P2 p2)
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
_ConstTessMemberResultCallback_1_4(const T *object, MemberSignature member, P1 p1)
_TessMemberResultCallback_5_4(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
_ConstTessMemberResultCallback_2_4(const T *object, MemberSignature member, P1 p1, P2 p2)
_TessFunctionResultCallback_2_4(FunctionSignature function, P1 p1, P2 p2)
TessResultCallback< R > base
_TessMemberResultCallback_6_0(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
_TessFunctionResultCallback_6_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
_TessFunctionResultCallback_3_0(FunctionSignature function, P1 p1, P2 p2, P3 p3)
Definition: tesscallback.h:924
_ConstTessMemberResultCallback_2_2(const T *object, MemberSignature member, P1 p1, P2 p2)
virtual R Run(A1 a1, A2 a2)
TessResultCallback5< R, A1, A2, A3, A4, A5 > base
virtual ~TessResultCallback()
Definition: tesscallback.h:38
TessResultCallback5< R, A1, A2, A3, A4, A5 > base
R(T::* MemberSignature)(P1, P2, P3, P4, P5, A1, A2)
TessResultCallback2< R, A1, A2 > base
virtual R Run(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
virtual R Run(A1 a1, A2 a2)
_TessMemberResultCallback_5_4(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
_TessMemberResultCallback_5_5(T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
TessResultCallback5< R, A1, A2, A3, A4, A5 > base
R(* FunctionSignature)(P1, A1, A2, A3, A4, A5)
TessResultCallback4< R, A1, A2, A3, A4 > base
_ConstTessMemberResultCallback_2_1(const T *object, MemberSignature member, P1 p1, P2 p2)
TessResultCallback1< R, A1 > base
_ConstTessMemberResultCallback_4_0(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
Definition: tesscallback.h:999
TessResultCallback4< R, A1, A2, A3, A4 > base
virtual R Run(A1 a1, A2 a2, A3 a3)
R(T::* MemberSignature)(P1, P2, P3, P4, P5, A1, A2, A3, A4, A5) const
_ConstTessMemberResultCallback_5_2(const T *object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)