tesseract  3.03
/usr/local/google/home/jbreiden/tesseract-ocr-read-only/ccutil/tesscallback.h
Go to the documentation of this file.
00001 
00002 // File:        tesscallback.h
00003 // Description: classes and functions to replace pointer-to-functions
00004 // Author:      Samuel Charron
00005 //
00006 // (C) Copyright 2006, Google Inc.
00007 // Licensed under the Apache License, Version 2.0 (the "License");
00008 // you may not use this file except in compliance with the License.
00009 // You may obtain a copy of the License at
00010 // http://www.apache.org/licenses/LICENSE-2.0
00011 // Unless required by applicable law or agreed to in writing, software
00012 // distributed under the License is distributed on an "AS IS" BASIS,
00013 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00014 // See the License for the specific language governing permissions and
00015 // limitations under the License.
00016 //
00018 
00019 #ifndef _TESS_CALLBACK_SPECIALIZATIONS_H
00020 #define _TESS_CALLBACK_SPECIALIZATIONS_H
00021 
00022 #include "host.h"  // For NULL.
00023 
00024 struct TessCallbackUtils_ {
00025   static void FailIsRepeatable(const char* name);
00026 };
00027 
00028 
00029 class TessClosure {
00030  public:
00031   virtual ~TessClosure() { }
00032   virtual void Run() = 0;
00033 };
00034 
00035 template <class R>
00036 class TessResultCallback {
00037  public:
00038   virtual ~TessResultCallback() { }
00039   virtual R Run() = 0;
00040 };
00041 
00042 template <bool del, class R, class T>
00043 class _ConstTessMemberResultCallback_0_0 : public TessResultCallback<R> {
00044  public:
00045   typedef TessResultCallback<R> base;
00046   typedef R (T::*MemberSignature)() const;
00047 
00048  private:
00049   const T* object_;
00050   MemberSignature member_;
00051 
00052  public:
00053   inline _ConstTessMemberResultCallback_0_0(
00054      const T* object, MemberSignature member)
00055     : object_(object),
00056       member_(member) {
00057   }
00058 
00059   virtual R Run() {
00060     if (!del) {
00061       R result = (object_->*member_)();
00062       return result;
00063     } else {
00064       R result = (object_->*member_)();
00065       //  zero out the pointer to ensure segfault if used again
00066       member_ = NULL;
00067       delete this;
00068       return result;
00069     }
00070   }
00071 };
00072 
00073 template <bool del, class T>
00074 class _ConstTessMemberResultCallback_0_0<del, void, T>
00075   : public TessClosure {
00076  public:
00077   typedef TessClosure base;
00078   typedef void (T::*MemberSignature)() const;
00079 
00080  private:
00081   const T* object_;
00082   MemberSignature member_;
00083 
00084  public:
00085   inline _ConstTessMemberResultCallback_0_0(
00086       const T* object, MemberSignature member)
00087     : object_(object),
00088       member_(member) {
00089   }
00090 
00091   virtual void Run() {
00092     if (!del) {
00093       (object_->*member_)();
00094     } else {
00095       (object_->*member_)();
00096       //  zero out the pointer to ensure segfault if used again
00097       member_ = NULL;
00098       delete this;
00099     }
00100   }
00101 };
00102 
00103 #ifndef SWIG
00104 template <class T1, class T2, class R>
00105 inline typename _ConstTessMemberResultCallback_0_0<true,R,T1>::base*
00106 NewTessCallback(
00107     const T1* obj, R (T2::*member)() const) {
00108   return new _ConstTessMemberResultCallback_0_0<true,R,T1>(
00109       obj, member);
00110 }
00111 #endif
00112 
00113 #ifndef SWIG
00114 template <class T1, class T2, class R>
00115 inline typename _ConstTessMemberResultCallback_0_0<false,R,T1>::base*
00116 NewPermanentTessCallback(
00117     const T1* obj, R (T2::*member)() const) {
00118   return new _ConstTessMemberResultCallback_0_0<false,R,T1>(
00119       obj, member);
00120 }
00121 #endif
00122 
00123 template <bool del, class R, class T>
00124 class _TessMemberResultCallback_0_0 : public TessResultCallback<R> {
00125  public:
00126   typedef TessResultCallback<R> base;
00127   typedef R (T::*MemberSignature)() ;
00128 
00129  private:
00130   T* object_;
00131   MemberSignature member_;
00132 
00133  public:
00134   inline _TessMemberResultCallback_0_0(
00135       T* object, MemberSignature member)
00136     : object_(object),
00137       member_(member) {
00138   }
00139 
00140   virtual R Run() {
00141     if (!del) {
00142       R result = (object_->*member_)();
00143       return result;
00144     } else {
00145       R result = (object_->*member_)();
00146       //  zero out the pointer to ensure segfault if used again
00147       member_ = NULL;
00148       delete this;
00149       return result;
00150     }
00151   }
00152 };
00153 
00154 template <bool del, class T>
00155 class _TessMemberResultCallback_0_0<del, void, T>
00156   : public TessClosure {
00157  public:
00158   typedef TessClosure base;
00159   typedef void (T::*MemberSignature)() ;
00160 
00161  private:
00162   T* object_;
00163   MemberSignature member_;
00164 
00165  public:
00166   inline _TessMemberResultCallback_0_0(
00167        T* object, MemberSignature member)
00168     : object_(object),
00169       member_(member) {
00170   }
00171 
00172   virtual void Run() {
00173     if (!del) {
00174       (object_->*member_)();
00175     } else {
00176       (object_->*member_)();
00177       //  zero out the pointer to ensure segfault if used again
00178       member_ = NULL;
00179       delete this;
00180     }
00181   }
00182 };
00183 
00184 #ifndef SWIG
00185 template <class T1, class T2, class R>
00186 inline typename _TessMemberResultCallback_0_0<true,R,T1>::base*
00187 NewTessCallback(
00188      T1* obj, R (T2::*member)() ) {
00189   return new _TessMemberResultCallback_0_0<true,R,T1>(
00190       obj, member);
00191 }
00192 #endif
00193 
00194 #ifndef SWIG
00195 template <class T1, class T2, class R>
00196 inline typename _TessMemberResultCallback_0_0<false,R,T1>::base*
00197 NewPermanentTessCallback(
00198      T1* obj, R (T2::*member)() ) {
00199   return new _TessMemberResultCallback_0_0<false,R,T1>(
00200       obj, member);
00201 }
00202 #endif
00203 
00204 template <bool del, class R>
00205 class _TessFunctionResultCallback_0_0 : public TessResultCallback<R> {
00206  public:
00207   typedef TessResultCallback<R> base;
00208   typedef R (*FunctionSignature)();
00209 
00210  private:
00211   FunctionSignature function_;
00212 
00213  public:
00214   inline _TessFunctionResultCallback_0_0(
00215       FunctionSignature function)
00216     : function_(function) {
00217   }
00218 
00219   virtual R Run() {
00220     if (!del) {
00221       R result = (*function_)();
00222       return result;
00223     } else {
00224       R result = (*function_)();
00225       //  zero out the pointer to ensure segfault if used again
00226       function_ = NULL;
00227       delete this;
00228       return result;
00229     }
00230   }
00231 };
00232 
00233 template <bool del>
00234 class _TessFunctionResultCallback_0_0<del, void>
00235   : public TessClosure {
00236  public:
00237   typedef TessClosure base;
00238   typedef void (*FunctionSignature)();
00239 
00240  private:
00241   FunctionSignature function_;
00242 
00243  public:
00244   inline _TessFunctionResultCallback_0_0(
00245       FunctionSignature function)
00246     : function_(function) {
00247   }
00248 
00249   virtual void Run() {
00250     if (!del) {
00251       (*function_)();
00252     } else {
00253       (*function_)();
00254       //  zero out the pointer to ensure segfault if used again
00255       function_ = NULL;
00256       delete this;
00257     }
00258   }
00259 };
00260 
00261 template <class R>
00262 inline typename _TessFunctionResultCallback_0_0<true,R>::base*
00263 NewTessCallback(R (*function)()) {
00264   return new _TessFunctionResultCallback_0_0<true,R>(function);
00265 }
00266 
00267 template <class R>
00268 inline typename _TessFunctionResultCallback_0_0<false,R>::base*
00269 NewPermanentTessCallback(R (*function)()) {
00270   return new _TessFunctionResultCallback_0_0<false,R>(function);
00271 }
00272 
00273 
00274 
00275 // Specified by TR1 [4.7.2] Reference modifications.
00276 template <class T> struct remove_reference;
00277 template<typename T> struct remove_reference { typedef T type; };
00278 template<typename T> struct remove_reference<T&> { typedef T type; };
00279 
00280 // Identity<T>::type is a typedef of T. Useful for preventing the
00281 // compiler from inferring the type of an argument in templates.
00282 template <typename T>
00283 struct Identity {
00284   typedef T type;
00285 };
00286 
00287 template <bool del, class R, class T, class P1>
00288 class _ConstTessMemberResultCallback_1_0 : public TessResultCallback<R> {
00289  public:
00290   typedef TessResultCallback<R> base;
00291   typedef R (T::*MemberSignature)(P1) const;
00292 
00293  private:
00294   const T* object_;
00295   MemberSignature member_;
00296   typename remove_reference<P1>::type p1_;
00297 
00298  public:
00299   inline _ConstTessMemberResultCallback_1_0(const T* object, MemberSignature member, P1 p1)
00300     : object_(object),
00301       member_(member),      p1_(p1) { }
00302 
00303   virtual R Run() {
00304     if (!del) {
00305       R result = (object_->*member_)(p1_);
00306       return result;
00307     } else {
00308       R result = (object_->*member_)(p1_);
00309       //  zero out the pointer to ensure segfault if used again
00310       member_ = NULL;
00311       delete this;
00312       return result;
00313     }
00314   }
00315 };
00316 
00317 template <bool del, class T, class P1>
00318 class _ConstTessMemberResultCallback_1_0<del, void, T, P1> : public TessClosure {
00319  public:
00320   typedef TessClosure base;
00321   typedef void (T::*MemberSignature)(P1) const;
00322 
00323  private:
00324   const T* object_;
00325   MemberSignature member_;
00326   typename remove_reference<P1>::type p1_;
00327 
00328  public:
00329   inline _ConstTessMemberResultCallback_1_0(const T* object, MemberSignature member, P1 p1)
00330     : object_(object),
00331       member_(member),      p1_(p1) { }
00332 
00333   virtual void Run() {
00334     if (!del) {
00335       (object_->*member_)(p1_);
00336     } else {
00337       (object_->*member_)(p1_);
00338       //  zero out the pointer to ensure segfault if used again
00339       member_ = NULL;
00340       delete this;
00341     }
00342   }
00343 };
00344 
00345 #ifndef SWIG
00346 template <class T1, class T2, class R, class P1>
00347 inline typename _ConstTessMemberResultCallback_1_0<true,R,T1,P1>::base*
00348 NewTessCallback(const T1* obj, R (T2::*member)(P1) const, typename Identity<P1>::type p1) {
00349   return new _ConstTessMemberResultCallback_1_0<true,R,T1,P1>(obj, member, p1);
00350 }
00351 #endif
00352 
00353 #ifndef SWIG
00354 template <class T1, class T2, class R, class P1>
00355 inline typename _ConstTessMemberResultCallback_1_0<false,R,T1,P1>::base*
00356 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1) const, typename Identity<P1>::type p1) {
00357   return new _ConstTessMemberResultCallback_1_0<false,R,T1,P1>(obj, member, p1);
00358 }
00359 #endif
00360 
00361 template <bool del, class R, class T, class P1>
00362 class _TessMemberResultCallback_1_0 : public TessResultCallback<R> {
00363  public:
00364   typedef TessResultCallback<R> base;
00365   typedef R (T::*MemberSignature)(P1) ;
00366 
00367  private:
00368    T* object_;
00369   MemberSignature member_;
00370   typename remove_reference<P1>::type p1_;
00371 
00372  public:
00373   inline _TessMemberResultCallback_1_0( T* object, MemberSignature member, P1 p1)
00374     : object_(object),
00375       member_(member),      p1_(p1) { }
00376 
00377   virtual R Run() {
00378     if (!del) {
00379       R result = (object_->*member_)(p1_);
00380       return result;
00381     } else {
00382       R result = (object_->*member_)(p1_);
00383       //  zero out the pointer to ensure segfault if used again
00384       member_ = NULL;
00385       delete this;
00386       return result;
00387     }
00388   }
00389 };
00390 
00391 template <bool del, class T, class P1>
00392 class _TessMemberResultCallback_1_0<del, void, T, P1> : public TessClosure {
00393  public:
00394   typedef TessClosure base;
00395   typedef void (T::*MemberSignature)(P1) ;
00396 
00397  private:
00398    T* object_;
00399   MemberSignature member_;
00400   typename remove_reference<P1>::type p1_;
00401 
00402  public:
00403   inline _TessMemberResultCallback_1_0( T* object, MemberSignature member, P1 p1)
00404     : object_(object),
00405       member_(member),      p1_(p1) { }
00406 
00407   virtual void Run() {
00408     if (!del) {
00409       (object_->*member_)(p1_);
00410     } else {
00411       (object_->*member_)(p1_);
00412       //  zero out the pointer to ensure segfault if used again
00413       member_ = NULL;
00414       delete this;
00415     }
00416   }
00417 };
00418 
00419 #ifndef SWIG
00420 template <class T1, class T2, class R, class P1>
00421 inline typename _TessMemberResultCallback_1_0<true,R,T1,P1>::base*
00422 NewTessCallback( T1* obj, R (T2::*member)(P1) , typename Identity<P1>::type p1) {
00423   return new _TessMemberResultCallback_1_0<true,R,T1,P1>(obj, member, p1);
00424 }
00425 #endif
00426 
00427 #ifndef SWIG
00428 template <class T1, class T2, class R, class P1>
00429 inline typename _TessMemberResultCallback_1_0<false,R,T1,P1>::base*
00430 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1) , typename Identity<P1>::type p1) {
00431   return new _TessMemberResultCallback_1_0<false,R,T1,P1>(obj, member, p1);
00432 }
00433 #endif
00434 
00435 template <bool del, class R, class P1>
00436 class _TessFunctionResultCallback_1_0 : public TessResultCallback<R> {
00437  public:
00438   typedef TessResultCallback<R> base;
00439   typedef R (*FunctionSignature)(P1);
00440 
00441  private:
00442   FunctionSignature function_;
00443   typename remove_reference<P1>::type p1_;
00444 
00445  public:
00446   inline _TessFunctionResultCallback_1_0(FunctionSignature function, P1 p1)
00447     : function_(function),      p1_(p1) { }
00448 
00449   virtual R Run() {
00450     if (!del) {
00451       R result = (*function_)(p1_);
00452       return result;
00453     } else {
00454       R result = (*function_)(p1_);
00455       //  zero out the pointer to ensure segfault if used again
00456       function_ = NULL;
00457       delete this;
00458       return result;
00459     }
00460   }
00461 };
00462 
00463 template <bool del, class P1>
00464 class _TessFunctionResultCallback_1_0<del, void, P1> : public TessClosure {
00465  public:
00466   typedef TessClosure base;
00467   typedef void (*FunctionSignature)(P1);
00468 
00469  private:
00470   FunctionSignature function_;
00471   typename remove_reference<P1>::type p1_;
00472 
00473  public:
00474   inline _TessFunctionResultCallback_1_0(FunctionSignature function, P1 p1)
00475     : function_(function),      p1_(p1) { }
00476 
00477   virtual void Run() {
00478     if (!del) {
00479       (*function_)(p1_);
00480     } else {
00481       (*function_)(p1_);
00482       //  zero out the pointer to ensure segfault if used again
00483       function_ = NULL;
00484       delete this;
00485     }
00486   }
00487 };
00488 
00489 template <class R, class P1>
00490 inline typename _TessFunctionResultCallback_1_0<true,R,P1>::base*
00491 NewTessCallback(R (*function)(P1), typename Identity<P1>::type p1) {
00492   return new _TessFunctionResultCallback_1_0<true,R,P1>(function, p1);
00493 }
00494 
00495 template <class R, class P1>
00496 inline typename _TessFunctionResultCallback_1_0<false,R,P1>::base*
00497 NewPermanentTessCallback(R (*function)(P1), typename Identity<P1>::type p1) {
00498   return new _TessFunctionResultCallback_1_0<false,R,P1>(function, p1);
00499 }
00500 
00501 template <bool del, class R, class T, class P1, class P2>
00502 class _ConstTessMemberResultCallback_2_0 : public TessResultCallback<R> {
00503  public:
00504   typedef TessResultCallback<R> base;
00505   typedef R (T::*MemberSignature)(P1,P2) const;
00506 
00507  private:
00508   const T* object_;
00509   MemberSignature member_;
00510   typename remove_reference<P1>::type p1_;
00511   typename remove_reference<P2>::type p2_;
00512 
00513  public:
00514   inline _ConstTessMemberResultCallback_2_0(const T* object, MemberSignature member, P1 p1, P2 p2)
00515     : object_(object),
00516       member_(member),      p1_(p1),      p2_(p2) { }
00517 
00518   virtual R Run() {
00519     if (!del) {
00520       R result = (object_->*member_)(p1_,p2_);
00521       return result;
00522     } else {
00523       R result = (object_->*member_)(p1_,p2_);
00524       //  zero out the pointer to ensure segfault if used again
00525       member_ = NULL;
00526       delete this;
00527       return result;
00528     }
00529   }
00530 };
00531 
00532 template <bool del, class T, class P1, class P2>
00533 class _ConstTessMemberResultCallback_2_0<del, void, T, P1, P2> : public TessClosure {
00534  public:
00535   typedef TessClosure base;
00536   typedef void (T::*MemberSignature)(P1,P2) const;
00537 
00538  private:
00539   const T* object_;
00540   MemberSignature member_;
00541   typename remove_reference<P1>::type p1_;
00542   typename remove_reference<P2>::type p2_;
00543 
00544  public:
00545   inline _ConstTessMemberResultCallback_2_0(const T* object, MemberSignature member, P1 p1, P2 p2)
00546     :
00547       object_(object),
00548       member_(member),      p1_(p1),      p2_(p2) { }
00549 
00550   virtual void Run() {
00551     if (!del) {
00552       (object_->*member_)(p1_,p2_);
00553     } else {
00554       (object_->*member_)(p1_,p2_);
00555       //  zero out the pointer to ensure segfault if used again
00556       member_ = NULL;
00557       delete this;
00558     }
00559   }
00560 };
00561 
00562 #ifndef SWIG
00563 template <class T1, class T2, class R, class P1, class P2>
00564 inline typename _ConstTessMemberResultCallback_2_0<true,R,T1,P1,P2>::base*
00565 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
00566   return new _ConstTessMemberResultCallback_2_0<true,R,T1,P1,P2>(obj, member, p1, p2);
00567 }
00568 #endif
00569 
00570 #ifndef SWIG
00571 template <class T1, class T2, class R, class P1, class P2>
00572 inline typename _ConstTessMemberResultCallback_2_0<false,R,T1,P1,P2>::base*
00573 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
00574   return new _ConstTessMemberResultCallback_2_0<false,R,T1,P1,P2>(obj, member, p1, p2);
00575 }
00576 #endif
00577 
00578 template <bool del, class R, class T, class P1, class P2>
00579 class _TessMemberResultCallback_2_0 : public TessResultCallback<R> {
00580  public:
00581   typedef TessResultCallback<R> base;
00582   typedef R (T::*MemberSignature)(P1,P2) ;
00583 
00584  private:
00585    T* object_;
00586   MemberSignature member_;
00587   typename remove_reference<P1>::type p1_;
00588   typename remove_reference<P2>::type p2_;
00589 
00590  public:
00591   inline _TessMemberResultCallback_2_0( T* object, MemberSignature member, P1 p1, P2 p2)
00592     : object_(object),
00593       member_(member),      p1_(p1),      p2_(p2) { }
00594 
00595   virtual R Run() {
00596     if (!del) {
00597       R result = (object_->*member_)(p1_,p2_);
00598       return result;
00599     } else {
00600       R result = (object_->*member_)(p1_,p2_);
00601       //  zero out the pointer to ensure segfault if used again
00602       member_ = NULL;
00603       delete this;
00604       return result;
00605     }
00606   }
00607 };
00608 
00609 template <bool del, class T, class P1, class P2>
00610 class _TessMemberResultCallback_2_0<del, void, T, P1, P2> : public TessClosure {
00611  public:
00612   typedef TessClosure base;
00613   typedef void (T::*MemberSignature)(P1,P2) ;
00614 
00615  private:
00616    T* object_;
00617   MemberSignature member_;
00618   typename remove_reference<P1>::type p1_;
00619   typename remove_reference<P2>::type p2_;
00620 
00621  public:
00622   inline _TessMemberResultCallback_2_0( T* object, MemberSignature member, P1 p1, P2 p2)
00623     :
00624       object_(object),
00625       member_(member),      p1_(p1),      p2_(p2) { }
00626 
00627   virtual void Run() {
00628     if (!del) {
00629       (object_->*member_)(p1_,p2_);
00630     } else {
00631       (object_->*member_)(p1_,p2_);
00632       //  zero out the pointer to ensure segfault if used again
00633       member_ = NULL;
00634       delete this;
00635     }
00636   }
00637 };
00638 
00639 #ifndef SWIG
00640 template <class T1, class T2, class R, class P1, class P2>
00641 inline typename _TessMemberResultCallback_2_0<true,R,T1,P1,P2>::base*
00642 NewTessCallback( T1* obj, R (T2::*member)(P1,P2) , typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
00643   return new _TessMemberResultCallback_2_0<true,R,T1,P1,P2>(obj, member, p1, p2);
00644 }
00645 #endif
00646 
00647 #ifndef SWIG
00648 template <class T1, class T2, class R, class P1, class P2>
00649 inline typename _TessMemberResultCallback_2_0<false,R,T1,P1,P2>::base*
00650 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2) , typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
00651   return new _TessMemberResultCallback_2_0<false,R,T1,P1,P2>(obj, member, p1, p2);
00652 }
00653 #endif
00654 
00655 template <bool del, class R, class P1, class P2>
00656 class _TessFunctionResultCallback_2_0 : public TessResultCallback<R> {
00657  public:
00658   typedef TessResultCallback<R> base;
00659   typedef R (*FunctionSignature)(P1,P2);
00660 
00661  private:
00662   FunctionSignature function_;
00663   typename remove_reference<P1>::type p1_;
00664   typename remove_reference<P2>::type p2_;
00665 
00666  public:
00667   inline _TessFunctionResultCallback_2_0(FunctionSignature function, P1 p1, P2 p2)
00668     : function_(function),      p1_(p1),      p2_(p2) { }
00669 
00670   virtual R Run() {
00671     if (!del) {
00672       R result = (*function_)(p1_,p2_);
00673       return result;
00674     } else {
00675       R result = (*function_)(p1_,p2_);
00676       //  zero out the pointer to ensure segfault if used again
00677       function_ = NULL;
00678       delete this;
00679       return result;
00680     }
00681   }
00682 };
00683 
00684 template <bool del, class P1, class P2>
00685 class _TessFunctionResultCallback_2_0<del, void, P1, P2> : public TessClosure {
00686  public:
00687   typedef TessClosure base;
00688   typedef void (*FunctionSignature)(P1,P2);
00689 
00690  private:
00691   FunctionSignature function_;
00692   typename remove_reference<P1>::type p1_;
00693   typename remove_reference<P2>::type p2_;
00694 
00695  public:
00696   inline _TessFunctionResultCallback_2_0(FunctionSignature function, P1 p1, P2 p2)
00697     :
00698       function_(function),      p1_(p1),      p2_(p2) { }
00699 
00700   virtual void Run() {
00701     if (!del) {
00702       (*function_)(p1_,p2_);
00703     } else {
00704       (*function_)(p1_,p2_);
00705       //  zero out the pointer to ensure segfault if used again
00706       function_ = NULL;
00707       delete this;
00708     }
00709   }
00710 };
00711 
00712 template <class R, class P1, class P2>
00713 inline typename _TessFunctionResultCallback_2_0<true,R,P1,P2>::base*
00714 NewTessCallback(R (*function)(P1,P2), typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
00715   return new _TessFunctionResultCallback_2_0<true,R,P1,P2>(function, p1, p2);
00716 }
00717 
00718 template <class R, class P1, class P2>
00719 inline typename _TessFunctionResultCallback_2_0<false,R,P1,P2>::base*
00720 NewPermanentTessCallback(R (*function)(P1,P2), typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
00721   return new _TessFunctionResultCallback_2_0<false,R,P1,P2>(function, p1, p2);
00722 }
00723 
00724 template <bool del, class R, class T, class P1, class P2, class P3>
00725 class _ConstTessMemberResultCallback_3_0 : public TessResultCallback<R> {
00726  public:
00727   typedef TessResultCallback<R> base;
00728   typedef R (T::*MemberSignature)(P1,P2,P3) const;
00729 
00730  private:
00731   const T* object_;
00732   MemberSignature member_;
00733   typename remove_reference<P1>::type p1_;
00734   typename remove_reference<P2>::type p2_;
00735   typename remove_reference<P3>::type p3_;
00736 
00737  public:
00738   inline _ConstTessMemberResultCallback_3_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
00739     :
00740       object_(object),
00741       member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }
00742 
00743   virtual R Run() {
00744     if (!del) {
00745       R result = (object_->*member_)(p1_,p2_,p3_);
00746       return result;
00747     } else {
00748       R result = (object_->*member_)(p1_,p2_,p3_);
00749       //  zero out the pointer to ensure segfault if used again
00750       member_ = NULL;
00751       delete this;
00752       return result;
00753     }
00754   }
00755 };
00756 
00757 template <bool del, class T, class P1, class P2, class P3>
00758 class _ConstTessMemberResultCallback_3_0<del, void, T, P1, P2, P3> : public TessClosure {
00759  public:
00760   typedef TessClosure base;
00761   typedef void (T::*MemberSignature)(P1,P2,P3) const;
00762 
00763  private:
00764   const T* object_;
00765   MemberSignature member_;
00766   typename remove_reference<P1>::type p1_;
00767   typename remove_reference<P2>::type p2_;
00768   typename remove_reference<P3>::type p3_;
00769 
00770  public:
00771   inline _ConstTessMemberResultCallback_3_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
00772     : object_(object),
00773       member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }
00774 
00775   virtual void Run() {
00776     if (!del) {
00777       (object_->*member_)(p1_,p2_,p3_);
00778     } else {
00779       (object_->*member_)(p1_,p2_,p3_);
00780       //  zero out the pointer to ensure segfault if used again
00781       member_ = NULL;
00782       delete this;
00783     }
00784   }
00785 };
00786 
00787 #ifndef SWIG
00788 template <class T1, class T2, class R, class P1, class P2, class P3>
00789 inline typename _ConstTessMemberResultCallback_3_0<true,R,T1,P1,P2,P3>::base*
00790 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) {
00791   return new _ConstTessMemberResultCallback_3_0<true,R,T1,P1,P2,P3>(obj, member, p1, p2, p3);
00792 }
00793 #endif
00794 
00795 #ifndef SWIG
00796 template <class T1, class T2, class R, class P1, class P2, class P3>
00797 inline typename _ConstTessMemberResultCallback_3_0<false,R,T1,P1,P2,P3>::base*
00798 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) {
00799   return new _ConstTessMemberResultCallback_3_0<false,R,T1,P1,P2,P3>(obj, member, p1, p2, p3);
00800 }
00801 #endif
00802 
00803 template <bool del, class R, class T, class P1, class P2, class P3>
00804 class _TessMemberResultCallback_3_0 : public TessResultCallback<R> {
00805  public:
00806   typedef TessResultCallback<R> base;
00807   typedef R (T::*MemberSignature)(P1,P2,P3) ;
00808 
00809  private:
00810    T* object_;
00811   MemberSignature member_;
00812   typename remove_reference<P1>::type p1_;
00813   typename remove_reference<P2>::type p2_;
00814   typename remove_reference<P3>::type p3_;
00815 
00816  public:
00817   inline _TessMemberResultCallback_3_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
00818     : object_(object),
00819       member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }
00820 
00821   virtual R Run() {
00822     if (!del) {
00823       R result = (object_->*member_)(p1_,p2_,p3_);
00824       return result;
00825     } else {
00826       R result = (object_->*member_)(p1_,p2_,p3_);
00827       //  zero out the pointer to ensure segfault if used again
00828       member_ = NULL;
00829       delete this;
00830       return result;
00831     }
00832   }
00833 };
00834 
00835 template <bool del, class T, class P1, class P2, class P3>
00836 class _TessMemberResultCallback_3_0<del, void, T, P1, P2, P3> : public TessClosure {
00837  public:
00838   typedef TessClosure base;
00839   typedef void (T::*MemberSignature)(P1,P2,P3) ;
00840 
00841  private:
00842    T* object_;
00843   MemberSignature member_;
00844   typename remove_reference<P1>::type p1_;
00845   typename remove_reference<P2>::type p2_;
00846   typename remove_reference<P3>::type p3_;
00847 
00848  public:
00849   inline _TessMemberResultCallback_3_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
00850     : object_(object),
00851       member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }
00852 
00853   virtual void Run() {
00854     if (!del) {
00855       (object_->*member_)(p1_,p2_,p3_);
00856     } else {
00857       (object_->*member_)(p1_,p2_,p3_);
00858       //  zero out the pointer to ensure segfault if used again
00859       member_ = NULL;
00860       delete this;
00861     }
00862   }
00863 };
00864 
00865 #ifndef SWIG
00866 template <class T1, class T2, class R, class P1, class P2, class P3>
00867 inline typename _TessMemberResultCallback_3_0<true,R,T1,P1,P2,P3>::base*
00868 NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
00869   return new _TessMemberResultCallback_3_0<true,R,T1,P1,P2,P3>(obj, member, p1, p2, p3);
00870 }
00871 #endif
00872 
00873 #ifndef SWIG
00874 template <class T1, class T2, class R, class P1, class P2, class P3>
00875 inline typename _TessMemberResultCallback_3_0<false,R,T1,P1,P2,P3>::base*
00876 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
00877   return new _TessMemberResultCallback_3_0<false,R,T1,P1,P2,P3>(obj, member, p1, p2, p3);
00878 }
00879 #endif
00880 
00881 template <bool del, class R, class P1, class P2, class P3>
00882 class _TessFunctionResultCallback_3_0 : public TessResultCallback<R> {
00883  public:
00884   typedef TessResultCallback<R> base;
00885   typedef R (*FunctionSignature)(P1,P2,P3);
00886 
00887  private:
00888   FunctionSignature function_;
00889   typename remove_reference<P1>::type p1_;
00890   typename remove_reference<P2>::type p2_;
00891   typename remove_reference<P3>::type p3_;
00892 
00893  public:
00894   inline _TessFunctionResultCallback_3_0(FunctionSignature function, P1 p1, P2 p2, P3 p3)
00895     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3) { }
00896 
00897   virtual R Run() {
00898     if (!del) {
00899       R result = (*function_)(p1_,p2_,p3_);
00900       return result;
00901     } else {
00902       R result = (*function_)(p1_,p2_,p3_);
00903       //  zero out the pointer to ensure segfault if used again
00904       function_ = NULL;
00905       delete this;
00906       return result;
00907     }
00908   }
00909 };
00910 
00911 template <bool del, class P1, class P2, class P3>
00912 class _TessFunctionResultCallback_3_0<del, void, P1, P2, P3> : public TessClosure {
00913  public:
00914   typedef TessClosure base;
00915   typedef void (*FunctionSignature)(P1,P2,P3);
00916 
00917  private:
00918   FunctionSignature function_;
00919   typename remove_reference<P1>::type p1_;
00920   typename remove_reference<P2>::type p2_;
00921   typename remove_reference<P3>::type p3_;
00922 
00923  public:
00924   inline _TessFunctionResultCallback_3_0(FunctionSignature function, P1 p1, P2 p2, P3 p3)
00925     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3) { }
00926 
00927   virtual void Run() {
00928     if (!del) {
00929       (*function_)(p1_,p2_,p3_);
00930     } else {
00931       (*function_)(p1_,p2_,p3_);
00932       //  zero out the pointer to ensure segfault if used again
00933       function_ = NULL;
00934       delete this;
00935     }
00936   }
00937 };
00938 
00939 template <class R, class P1, class P2, class P3>
00940 inline typename _TessFunctionResultCallback_3_0<true,R,P1,P2,P3>::base*
00941 NewTessCallback(R (*function)(P1,P2,P3), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
00942   return new _TessFunctionResultCallback_3_0<true,R,P1,P2,P3>(function, p1, p2, p3);
00943 }
00944 
00945 template <class R, class P1, class P2, class P3>
00946 inline typename _TessFunctionResultCallback_3_0<false,R,P1,P2,P3>::base*
00947 NewPermanentTessCallback(R (*function)(P1,P2,P3), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
00948   return new _TessFunctionResultCallback_3_0<false,R,P1,P2,P3>(function, p1, p2, p3);
00949 }
00950 
00951 template <bool del, class R, class T, class P1, class P2, class P3, class P4>
00952 class _ConstTessMemberResultCallback_4_0 : public TessResultCallback<R> {
00953  public:
00954   typedef TessResultCallback<R> base;
00955   typedef R (T::*MemberSignature)(P1,P2,P3,P4) const;
00956 
00957  private:
00958   const T* object_;
00959   MemberSignature member_;
00960   typename remove_reference<P1>::type p1_;
00961   typename remove_reference<P2>::type p2_;
00962   typename remove_reference<P3>::type p3_;
00963   typename remove_reference<P4>::type p4_;
00964 
00965  public:
00966   inline _ConstTessMemberResultCallback_4_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
00967     : object_(object),
00968       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
00969 
00970   virtual R Run() {
00971     if (!del) {
00972       R result = (object_->*member_)(p1_,p2_,p3_,p4_);
00973       return result;
00974     } else {
00975       R result = (object_->*member_)(p1_,p2_,p3_,p4_);
00976       //  zero out the pointer to ensure segfault if used again
00977       member_ = NULL;
00978       delete this;
00979       return result;
00980     }
00981   }
00982 };
00983 
00984 template <bool del, class T, class P1, class P2, class P3, class P4>
00985 class _ConstTessMemberResultCallback_4_0<del, void, T, P1, P2, P3, P4> : public TessClosure {
00986  public:
00987   typedef TessClosure base;
00988   typedef void (T::*MemberSignature)(P1,P2,P3,P4) const;
00989 
00990  private:
00991   const T* object_;
00992   MemberSignature member_;
00993   typename remove_reference<P1>::type p1_;
00994   typename remove_reference<P2>::type p2_;
00995   typename remove_reference<P3>::type p3_;
00996   typename remove_reference<P4>::type p4_;
00997 
00998  public:
00999   inline _ConstTessMemberResultCallback_4_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
01000     : object_(object),
01001       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
01002 
01003   virtual void Run() {
01004     if (!del) {
01005       (object_->*member_)(p1_,p2_,p3_,p4_);
01006     } else {
01007       (object_->*member_)(p1_,p2_,p3_,p4_);
01008       //  zero out the pointer to ensure segfault if used again
01009       member_ = NULL;
01010       delete this;
01011     }
01012   }
01013 };
01014 
01015 #ifndef SWIG
01016 template <class T1, class T2, class R, class P1, class P2, class P3, class P4>
01017 inline typename _ConstTessMemberResultCallback_4_0<true,R,T1,P1,P2,P3,P4>::base*
01018 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) {
01019   return new _ConstTessMemberResultCallback_4_0<true,R,T1,P1,P2,P3,P4>(obj, member, p1, p2, p3, p4);
01020 }
01021 #endif
01022 
01023 #ifndef SWIG
01024 template <class T1, class T2, class R, class P1, class P2, class P3, class P4>
01025 inline typename _ConstTessMemberResultCallback_4_0<false,R,T1,P1,P2,P3,P4>::base*
01026 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) {
01027   return new _ConstTessMemberResultCallback_4_0<false,R,T1,P1,P2,P3,P4>(obj, member, p1, p2, p3, p4);
01028 }
01029 #endif
01030 
01031 template <bool del, class R, class T, class P1, class P2, class P3, class P4>
01032 class _TessMemberResultCallback_4_0 : public TessResultCallback<R> {
01033  public:
01034   typedef TessResultCallback<R> base;
01035   typedef R (T::*MemberSignature)(P1,P2,P3,P4) ;
01036 
01037  private:
01038    T* object_;
01039   MemberSignature member_;
01040   typename remove_reference<P1>::type p1_;
01041   typename remove_reference<P2>::type p2_;
01042   typename remove_reference<P3>::type p3_;
01043   typename remove_reference<P4>::type p4_;
01044 
01045  public:
01046   inline _TessMemberResultCallback_4_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
01047     : object_(object),
01048       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
01049 
01050   virtual R Run() {
01051     if (!del) {
01052       R result = (object_->*member_)(p1_,p2_,p3_,p4_);
01053       return result;
01054     } else {
01055       R result = (object_->*member_)(p1_,p2_,p3_,p4_);
01056       //  zero out the pointer to ensure segfault if used again
01057       member_ = NULL;
01058       delete this;
01059       return result;
01060     }
01061   }
01062 };
01063 
01064 template <bool del, class T, class P1, class P2, class P3, class P4>
01065 class _TessMemberResultCallback_4_0<del, void, T, P1, P2, P3, P4> : public TessClosure {
01066  public:
01067   typedef TessClosure base;
01068   typedef void (T::*MemberSignature)(P1,P2,P3,P4) ;
01069 
01070  private:
01071    T* object_;
01072   MemberSignature member_;
01073   typename remove_reference<P1>::type p1_;
01074   typename remove_reference<P2>::type p2_;
01075   typename remove_reference<P3>::type p3_;
01076   typename remove_reference<P4>::type p4_;
01077 
01078  public:
01079   inline _TessMemberResultCallback_4_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
01080     : object_(object),
01081       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
01082 
01083   virtual void Run() {
01084     if (!del) {
01085       (object_->*member_)(p1_,p2_,p3_,p4_);
01086     } else {
01087       (object_->*member_)(p1_,p2_,p3_,p4_);
01088       //  zero out the pointer to ensure segfault if used again
01089       member_ = NULL;
01090       delete this;
01091     }
01092   }
01093 };
01094 
01095 #ifndef SWIG
01096 template <class T1, class T2, class R, class P1, class P2, class P3, class P4>
01097 inline typename _TessMemberResultCallback_4_0<true,R,T1,P1,P2,P3,P4>::base*
01098 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) {
01099   return new _TessMemberResultCallback_4_0<true,R,T1,P1,P2,P3,P4>(obj, member, p1, p2, p3, p4);
01100 }
01101 #endif
01102 
01103 #ifndef SWIG
01104 template <class T1, class T2, class R, class P1, class P2, class P3, class P4>
01105 inline typename _TessMemberResultCallback_4_0<false,R,T1,P1,P2,P3,P4>::base*
01106 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) {
01107   return new _TessMemberResultCallback_4_0<false,R,T1,P1,P2,P3,P4>(obj, member, p1, p2, p3, p4);
01108 }
01109 #endif
01110 
01111 template <bool del, class R, class P1, class P2, class P3, class P4>
01112 class _TessFunctionResultCallback_4_0 : public TessResultCallback<R> {
01113  public:
01114   typedef TessResultCallback<R> base;
01115   typedef R (*FunctionSignature)(P1,P2,P3,P4);
01116 
01117  private:
01118   FunctionSignature function_;
01119   typename remove_reference<P1>::type p1_;
01120   typename remove_reference<P2>::type p2_;
01121   typename remove_reference<P3>::type p3_;
01122   typename remove_reference<P4>::type p4_;
01123 
01124  public:
01125   inline _TessFunctionResultCallback_4_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
01126     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
01127 
01128   virtual R Run() {
01129     if (!del) {
01130       R result = (*function_)(p1_,p2_,p3_,p4_);
01131       return result;
01132     } else {
01133       R result = (*function_)(p1_,p2_,p3_,p4_);
01134       //  zero out the pointer to ensure segfault if used again
01135       function_ = NULL;
01136       delete this;
01137       return result;
01138     }
01139   }
01140 };
01141 
01142 template <bool del, class P1, class P2, class P3, class P4>
01143 class _TessFunctionResultCallback_4_0<del, void, P1, P2, P3, P4> : public TessClosure {
01144  public:
01145   typedef TessClosure base;
01146   typedef void (*FunctionSignature)(P1,P2,P3,P4);
01147 
01148  private:
01149   FunctionSignature function_;
01150   typename remove_reference<P1>::type p1_;
01151   typename remove_reference<P2>::type p2_;
01152   typename remove_reference<P3>::type p3_;
01153   typename remove_reference<P4>::type p4_;
01154 
01155  public:
01156   inline _TessFunctionResultCallback_4_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
01157     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
01158 
01159   virtual void Run() {
01160     if (!del) {
01161       (*function_)(p1_,p2_,p3_,p4_);
01162     } else {
01163       (*function_)(p1_,p2_,p3_,p4_);
01164       //  zero out the pointer to ensure segfault if used again
01165       function_ = NULL;
01166       delete this;
01167     }
01168   }
01169 };
01170 
01171 template <class R, class P1, class P2, class P3, class P4>
01172 inline typename _TessFunctionResultCallback_4_0<true,R,P1,P2,P3,P4>::base*
01173 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) {
01174   return new _TessFunctionResultCallback_4_0<true,R,P1,P2,P3,P4>(function, p1, p2, p3, p4);
01175 }
01176 
01177 template <class R, class P1, class P2, class P3, class P4>
01178 inline typename _TessFunctionResultCallback_4_0<false,R,P1,P2,P3,P4>::base*
01179 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) {
01180   return new _TessFunctionResultCallback_4_0<false,R,P1,P2,P3,P4>(function, p1, p2, p3, p4);
01181 }
01182 
01183 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5>
01184 class _ConstTessMemberResultCallback_5_0 : public TessResultCallback<R> {
01185  public:
01186   typedef TessResultCallback<R> base;
01187   typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5) const;
01188 
01189  private:
01190   const T* object_;
01191   MemberSignature member_;
01192   typename remove_reference<P1>::type p1_;
01193   typename remove_reference<P2>::type p2_;
01194   typename remove_reference<P3>::type p3_;
01195   typename remove_reference<P4>::type p4_;
01196   typename remove_reference<P5>::type p5_;
01197 
01198  public:
01199   inline _ConstTessMemberResultCallback_5_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
01200     : object_(object),
01201       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
01202 
01203   virtual R Run() {
01204     if (!del) {
01205       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_);
01206       return result;
01207     } else {
01208       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_);
01209       //  zero out the pointer to ensure segfault if used again
01210       member_ = NULL;
01211       delete this;
01212       return result;
01213     }
01214   }
01215 };
01216 
01217 template <bool del, class T, class P1, class P2, class P3, class P4, class P5>
01218 class _ConstTessMemberResultCallback_5_0<del, void, T, P1, P2, P3, P4, P5> : public TessClosure {
01219  public:
01220   typedef TessClosure base;
01221   typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5) const;
01222 
01223  private:
01224   const T* object_;
01225   MemberSignature member_;
01226   typename remove_reference<P1>::type p1_;
01227   typename remove_reference<P2>::type p2_;
01228   typename remove_reference<P3>::type p3_;
01229   typename remove_reference<P4>::type p4_;
01230   typename remove_reference<P5>::type p5_;
01231 
01232  public:
01233   inline _ConstTessMemberResultCallback_5_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
01234     : object_(object),
01235       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
01236 
01237   virtual void Run() {
01238     if (!del) {
01239       (object_->*member_)(p1_,p2_,p3_,p4_,p5_);
01240     } else {
01241       (object_->*member_)(p1_,p2_,p3_,p4_,p5_);
01242       //  zero out the pointer to ensure segfault if used again
01243       member_ = NULL;
01244       delete this;
01245     }
01246   }
01247 };
01248 
01249 #ifndef SWIG
01250 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5>
01251 inline typename _ConstTessMemberResultCallback_5_0<true,R,T1,P1,P2,P3,P4,P5>::base*
01252 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) {
01253   return new _ConstTessMemberResultCallback_5_0<true,R,T1,P1,P2,P3,P4,P5>(obj, member, p1, p2, p3, p4, p5);
01254 }
01255 #endif
01256 
01257 #ifndef SWIG
01258 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5>
01259 inline typename _ConstTessMemberResultCallback_5_0<false,R,T1,P1,P2,P3,P4,P5>::base*
01260 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) {
01261   return new _ConstTessMemberResultCallback_5_0<false,R,T1,P1,P2,P3,P4,P5>(obj, member, p1, p2, p3, p4, p5);
01262 }
01263 #endif
01264 
01265 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5>
01266 class _TessMemberResultCallback_5_0 : public TessResultCallback<R> {
01267  public:
01268   typedef TessResultCallback<R> base;
01269   typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5) ;
01270 
01271  private:
01272    T* object_;
01273   MemberSignature member_;
01274   typename remove_reference<P1>::type p1_;
01275   typename remove_reference<P2>::type p2_;
01276   typename remove_reference<P3>::type p3_;
01277   typename remove_reference<P4>::type p4_;
01278   typename remove_reference<P5>::type p5_;
01279 
01280  public:
01281   inline _TessMemberResultCallback_5_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
01282     : object_(object),
01283       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
01284 
01285   virtual R Run() {
01286     if (!del) {
01287       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_);
01288       return result;
01289     } else {
01290       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_);
01291       //  zero out the pointer to ensure segfault if used again
01292       member_ = NULL;
01293       delete this;
01294       return result;
01295     }
01296   }
01297 };
01298 
01299 template <bool del, class T, class P1, class P2, class P3, class P4, class P5>
01300 class _TessMemberResultCallback_5_0<del, void, T, P1, P2, P3, P4, P5> : public TessClosure {
01301  public:
01302   typedef TessClosure base;
01303   typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5) ;
01304 
01305  private:
01306    T* object_;
01307   MemberSignature member_;
01308   typename remove_reference<P1>::type p1_;
01309   typename remove_reference<P2>::type p2_;
01310   typename remove_reference<P3>::type p3_;
01311   typename remove_reference<P4>::type p4_;
01312   typename remove_reference<P5>::type p5_;
01313 
01314  public:
01315   inline _TessMemberResultCallback_5_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
01316     : object_(object),
01317       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
01318 
01319   virtual void Run() {
01320     if (!del) {
01321       (object_->*member_)(p1_,p2_,p3_,p4_,p5_);
01322     } else {
01323       (object_->*member_)(p1_,p2_,p3_,p4_,p5_);
01324       //  zero out the pointer to ensure segfault if used again
01325       member_ = NULL;
01326       delete this;
01327     }
01328   }
01329 };
01330 
01331 #ifndef SWIG
01332 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5>
01333 inline typename _TessMemberResultCallback_5_0<true,R,T1,P1,P2,P3,P4,P5>::base*
01334 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) {
01335   return new _TessMemberResultCallback_5_0<true,R,T1,P1,P2,P3,P4,P5>(obj, member, p1, p2, p3, p4, p5);
01336 }
01337 #endif
01338 
01339 #ifndef SWIG
01340 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5>
01341 inline typename _TessMemberResultCallback_5_0<false,R,T1,P1,P2,P3,P4,P5>::base*
01342 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) {
01343   return new _TessMemberResultCallback_5_0<false,R,T1,P1,P2,P3,P4,P5>(obj, member, p1, p2, p3, p4, p5);
01344 }
01345 #endif
01346 
01347 template <bool del, class R, class P1, class P2, class P3, class P4, class P5>
01348 class _TessFunctionResultCallback_5_0 : public TessResultCallback<R> {
01349  public:
01350   typedef TessResultCallback<R> base;
01351   typedef R (*FunctionSignature)(P1,P2,P3,P4,P5);
01352 
01353  private:
01354   FunctionSignature function_;
01355   typename remove_reference<P1>::type p1_;
01356   typename remove_reference<P2>::type p2_;
01357   typename remove_reference<P3>::type p3_;
01358   typename remove_reference<P4>::type p4_;
01359   typename remove_reference<P5>::type p5_;
01360 
01361  public:
01362   inline _TessFunctionResultCallback_5_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
01363     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
01364 
01365   virtual R Run() {
01366     if (!del) {
01367       R result = (*function_)(p1_,p2_,p3_,p4_,p5_);
01368       return result;
01369     } else {
01370       R result = (*function_)(p1_,p2_,p3_,p4_,p5_);
01371       //  zero out the pointer to ensure segfault if used again
01372       function_ = NULL;
01373       delete this;
01374       return result;
01375     }
01376   }
01377 };
01378 
01379 template <bool del, class P1, class P2, class P3, class P4, class P5>
01380 class _TessFunctionResultCallback_5_0<del, void, P1, P2, P3, P4, P5> : public TessClosure {
01381  public:
01382   typedef TessClosure base;
01383   typedef void (*FunctionSignature)(P1,P2,P3,P4,P5);
01384 
01385  private:
01386   FunctionSignature function_;
01387   typename remove_reference<P1>::type p1_;
01388   typename remove_reference<P2>::type p2_;
01389   typename remove_reference<P3>::type p3_;
01390   typename remove_reference<P4>::type p4_;
01391   typename remove_reference<P5>::type p5_;
01392 
01393  public:
01394   inline _TessFunctionResultCallback_5_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
01395     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
01396 
01397   virtual void Run() {
01398     if (!del) {
01399       (*function_)(p1_,p2_,p3_,p4_,p5_);
01400     } else {
01401       (*function_)(p1_,p2_,p3_,p4_,p5_);
01402       //  zero out the pointer to ensure segfault if used again
01403       function_ = NULL;
01404       delete this;
01405     }
01406   }
01407 };
01408 
01409 template <class R, class P1, class P2, class P3, class P4, class P5>
01410 inline typename _TessFunctionResultCallback_5_0<true,R,P1,P2,P3,P4,P5>::base*
01411 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) {
01412   return new _TessFunctionResultCallback_5_0<true,R,P1,P2,P3,P4,P5>(function, p1, p2, p3, p4, p5);
01413 }
01414 
01415 template <class R, class P1, class P2, class P3, class P4, class P5>
01416 inline typename _TessFunctionResultCallback_5_0<false,R,P1,P2,P3,P4,P5>::base*
01417 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) {
01418   return new _TessFunctionResultCallback_5_0<false,R,P1,P2,P3,P4,P5>(function, p1, p2, p3, p4, p5);
01419 }
01420 
01421 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class P6>
01422 class _ConstTessMemberResultCallback_6_0 : public TessResultCallback<R> {
01423  public:
01424   typedef TessResultCallback<R> base;
01425   typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6) const;
01426 
01427  private:
01428   const T* object_;
01429   MemberSignature member_;
01430   typename remove_reference<P1>::type p1_;
01431   typename remove_reference<P2>::type p2_;
01432   typename remove_reference<P3>::type p3_;
01433   typename remove_reference<P4>::type p4_;
01434   typename remove_reference<P5>::type p5_;
01435   typename remove_reference<P6>::type p6_;
01436 
01437  public:
01438   inline _ConstTessMemberResultCallback_6_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
01439     : object_(object),
01440       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
01441 
01442   virtual R Run() {
01443     if (!del) {
01444       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_);
01445       return result;
01446     } else {
01447       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_);
01448       //  zero out the pointer to ensure segfault if used again
01449       member_ = NULL;
01450       delete this;
01451       return result;
01452     }
01453   }
01454 };
01455 
01456 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class P6>
01457 class _ConstTessMemberResultCallback_6_0<del, void, T, P1, P2, P3, P4, P5, P6> : public TessClosure {
01458  public:
01459   typedef TessClosure base;
01460   typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6) const;
01461 
01462  private:
01463   const T* object_;
01464   MemberSignature member_;
01465   typename remove_reference<P1>::type p1_;
01466   typename remove_reference<P2>::type p2_;
01467   typename remove_reference<P3>::type p3_;
01468   typename remove_reference<P4>::type p4_;
01469   typename remove_reference<P5>::type p5_;
01470   typename remove_reference<P6>::type p6_;
01471 
01472  public:
01473   inline _ConstTessMemberResultCallback_6_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
01474     : object_(object),
01475       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
01476 
01477   virtual void Run() {
01478     if (!del) {
01479       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_);
01480     } else {
01481       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_);
01482       //  zero out the pointer to ensure segfault if used again
01483       member_ = NULL;
01484       delete this;
01485     }
01486   }
01487 };
01488 
01489 #ifndef SWIG
01490 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6>
01491 inline typename _ConstTessMemberResultCallback_6_0<true,R,T1,P1,P2,P3,P4,P5,P6>::base*
01492 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) {
01493   return new _ConstTessMemberResultCallback_6_0<true,R,T1,P1,P2,P3,P4,P5,P6>(obj, member, p1, p2, p3, p4, p5, p6);
01494 }
01495 #endif
01496 
01497 #ifndef SWIG
01498 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6>
01499 inline typename _ConstTessMemberResultCallback_6_0<false,R,T1,P1,P2,P3,P4,P5,P6>::base*
01500 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) {
01501   return new _ConstTessMemberResultCallback_6_0<false,R,T1,P1,P2,P3,P4,P5,P6>(obj, member, p1, p2, p3, p4, p5, p6);
01502 }
01503 #endif
01504 
01505 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class P6>
01506 class _TessMemberResultCallback_6_0 : public TessResultCallback<R> {
01507  public:
01508   typedef TessResultCallback<R> base;
01509   typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6) ;
01510 
01511  private:
01512    T* object_;
01513   MemberSignature member_;
01514   typename remove_reference<P1>::type p1_;
01515   typename remove_reference<P2>::type p2_;
01516   typename remove_reference<P3>::type p3_;
01517   typename remove_reference<P4>::type p4_;
01518   typename remove_reference<P5>::type p5_;
01519   typename remove_reference<P6>::type p6_;
01520 
01521  public:
01522   inline _TessMemberResultCallback_6_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
01523     : object_(object),
01524       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
01525 
01526   virtual R Run() {
01527     if (!del) {
01528       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_);
01529       return result;
01530     } else {
01531       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_);
01532       //  zero out the pointer to ensure segfault if used again
01533       member_ = NULL;
01534       delete this;
01535       return result;
01536     }
01537   }
01538 };
01539 
01540 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class P6>
01541 class _TessMemberResultCallback_6_0<del, void, T, P1, P2, P3, P4, P5, P6> : public TessClosure {
01542  public:
01543   typedef TessClosure base;
01544   typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6) ;
01545 
01546  private:
01547    T* object_;
01548   MemberSignature member_;
01549   typename remove_reference<P1>::type p1_;
01550   typename remove_reference<P2>::type p2_;
01551   typename remove_reference<P3>::type p3_;
01552   typename remove_reference<P4>::type p4_;
01553   typename remove_reference<P5>::type p5_;
01554   typename remove_reference<P6>::type p6_;
01555 
01556  public:
01557   inline _TessMemberResultCallback_6_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
01558     : object_(object),
01559       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
01560 
01561   virtual void Run() {
01562     if (!del) {
01563       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_);
01564     } else {
01565       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_);
01566       //  zero out the pointer to ensure segfault if used again
01567       member_ = NULL;
01568       delete this;
01569     }
01570   }
01571 };
01572 
01573 #ifndef SWIG
01574 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6>
01575 inline typename _TessMemberResultCallback_6_0<true,R,T1,P1,P2,P3,P4,P5,P6>::base*
01576 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) {
01577   return new _TessMemberResultCallback_6_0<true,R,T1,P1,P2,P3,P4,P5,P6>(obj, member, p1, p2, p3, p4, p5, p6);
01578 }
01579 #endif
01580 
01581 #ifndef SWIG
01582 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6>
01583 inline typename _TessMemberResultCallback_6_0<false,R,T1,P1,P2,P3,P4,P5,P6>::base*
01584 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) {
01585   return new _TessMemberResultCallback_6_0<false,R,T1,P1,P2,P3,P4,P5,P6>(obj, member, p1, p2, p3, p4, p5, p6);
01586 }
01587 #endif
01588 
01589 template <bool del, class R, class P1, class P2, class P3, class P4, class P5, class P6>
01590 class _TessFunctionResultCallback_6_0 : public TessResultCallback<R> {
01591  public:
01592   typedef TessResultCallback<R> base;
01593   typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,P6);
01594 
01595  private:
01596   FunctionSignature function_;
01597   typename remove_reference<P1>::type p1_;
01598   typename remove_reference<P2>::type p2_;
01599   typename remove_reference<P3>::type p3_;
01600   typename remove_reference<P4>::type p4_;
01601   typename remove_reference<P5>::type p5_;
01602   typename remove_reference<P6>::type p6_;
01603 
01604  public:
01605   inline _TessFunctionResultCallback_6_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
01606     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
01607 
01608   virtual R Run() {
01609     if (!del) {
01610       R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_);
01611       return result;
01612     } else {
01613       R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_);
01614       //  zero out the pointer to ensure segfault if used again
01615       function_ = NULL;
01616       delete this;
01617       return result;
01618     }
01619   }
01620 };
01621 
01622 template <bool del, class P1, class P2, class P3, class P4, class P5, class P6>
01623 class _TessFunctionResultCallback_6_0<del, void, P1, P2, P3, P4, P5, P6> : public TessClosure {
01624  public:
01625   typedef TessClosure base;
01626   typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,P6);
01627 
01628  private:
01629   FunctionSignature function_;
01630   typename remove_reference<P1>::type p1_;
01631   typename remove_reference<P2>::type p2_;
01632   typename remove_reference<P3>::type p3_;
01633   typename remove_reference<P4>::type p4_;
01634   typename remove_reference<P5>::type p5_;
01635   typename remove_reference<P6>::type p6_;
01636 
01637  public:
01638   inline _TessFunctionResultCallback_6_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
01639     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
01640 
01641   virtual void Run() {
01642     if (!del) {
01643       (*function_)(p1_,p2_,p3_,p4_,p5_,p6_);
01644     } else {
01645       (*function_)(p1_,p2_,p3_,p4_,p5_,p6_);
01646       //  zero out the pointer to ensure segfault if used again
01647       function_ = NULL;
01648       delete this;
01649     }
01650   }
01651 };
01652 
01653 template <class R, class P1, class P2, class P3, class P4, class P5, class P6>
01654 inline typename _TessFunctionResultCallback_6_0<true,R,P1,P2,P3,P4,P5,P6>::base*
01655 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) {
01656   return new _TessFunctionResultCallback_6_0<true,R,P1,P2,P3,P4,P5,P6>(function, p1, p2, p3, p4, p5, p6);
01657 }
01658 
01659 template <class R, class P1, class P2, class P3, class P4, class P5, class P6>
01660 inline typename _TessFunctionResultCallback_6_0<false,R,P1,P2,P3,P4,P5,P6>::base*
01661 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) {
01662   return new _TessFunctionResultCallback_6_0<false,R,P1,P2,P3,P4,P5,P6>(function, p1, p2, p3, p4, p5, p6);
01663 }
01664 
01665 template <class A1>
01666 class TessCallback1 {
01667  public:
01668   virtual ~TessCallback1() { }
01669   virtual void Run(A1) = 0;
01670 };
01671 
01672 template <class R, class A1>
01673 class TessResultCallback1 {
01674  public:
01675   virtual ~TessResultCallback1() { }
01676   virtual R Run(A1) = 0;
01677 };
01678 
01679 
01680 template <class A1,class A2>
01681 class TessCallback2 {
01682  public:
01683   virtual ~TessCallback2() { }
01684   virtual void Run(A1,A2) = 0;
01685 };
01686 
01687 template <class R, class A1,class A2>
01688 class TessResultCallback2 {
01689  public:
01690   virtual ~TessResultCallback2() { }
01691   virtual R Run(A1,A2) = 0;
01692 };
01693 
01694 template <class A1,class A2,class A3>
01695 class TessCallback3 {
01696  public:
01697   virtual ~TessCallback3() { }
01698   virtual void Run(A1,A2,A3) = 0;
01699 };
01700 
01701 template <class R, class A1,class A2,class A3>
01702 class TessResultCallback3 {
01703  public:
01704   virtual ~TessResultCallback3() { }
01705   virtual R Run(A1,A2,A3) = 0;
01706 };
01707 
01708 template <class A1,class A2,class A3,class A4>
01709 class TessCallback4 {
01710  public:
01711   virtual ~TessCallback4() { }
01712   virtual void Run(A1,A2,A3,A4) = 0;
01713 };
01714 
01715 template <class R, class A1,class A2,class A3,class A4>
01716 class TessResultCallback4 {
01717  public:
01718   virtual ~TessResultCallback4() { }
01719   virtual R Run(A1,A2,A3,A4) = 0;
01720 };
01721 
01722 template <bool del, class R, class T, class A1>
01723 class _ConstTessMemberResultCallback_0_1 : public TessResultCallback1<R,A1> {
01724  public:
01725   typedef TessResultCallback1<R,A1> base;
01726   typedef R (T::*MemberSignature)(A1) const;
01727 
01728  private:
01729   const T* object_;
01730   MemberSignature member_;
01731 
01732  public:
01733   inline _ConstTessMemberResultCallback_0_1(
01734      const T* object, MemberSignature member)
01735     : object_(object),
01736       member_(member) {
01737   }
01738 
01739   virtual R Run(A1 a1) {
01740     if (!del) {
01741       R result = (object_->*member_)(a1);
01742       return result;
01743     } else {
01744       R result = (object_->*member_)(a1);
01745       //  zero out the pointer to ensure segfault if used again
01746       member_ = NULL;
01747       delete this;
01748       return result;
01749     }
01750   }
01751 };
01752 
01753 template <bool del, class T, class A1>
01754 class _ConstTessMemberResultCallback_0_1<del, void, T, A1>
01755   : public TessCallback1<A1> {
01756  public:
01757   typedef TessCallback1<A1> base;
01758   typedef void (T::*MemberSignature)(A1) const;
01759 
01760  private:
01761   const T* object_;
01762   MemberSignature member_;
01763 
01764  public:
01765   inline _ConstTessMemberResultCallback_0_1(
01766       const T* object, MemberSignature member)
01767     : object_(object),
01768       member_(member) {
01769   }
01770 
01771   virtual void Run(A1 a1) {
01772     if (!del) {
01773       (object_->*member_)(a1);
01774     } else {
01775       (object_->*member_)(a1);
01776       //  zero out the pointer to ensure segfault if used again
01777       member_ = NULL;
01778       delete this;
01779     }
01780   }
01781 };
01782 
01783 #ifndef SWIG
01784 template <class T1, class T2, class R, class A1>
01785 inline typename _ConstTessMemberResultCallback_0_1<true,R,T1,A1>::base*
01786 NewTessCallback(
01787     const T1* obj, R (T2::*member)(A1) const) {
01788   return new _ConstTessMemberResultCallback_0_1<true,R,T1,A1>(
01789       obj, member);
01790 }
01791 #endif
01792 
01793 #ifndef SWIG
01794 template <class T1, class T2, class R, class A1>
01795 inline typename _ConstTessMemberResultCallback_0_1<false,R,T1,A1>::base*
01796 NewPermanentTessCallback(
01797     const T1* obj, R (T2::*member)(A1) const) {
01798   return new _ConstTessMemberResultCallback_0_1<false,R,T1,A1>(
01799       obj, member);
01800 }
01801 #endif
01802 
01803 template <bool del, class R, class T, class A1>
01804 class _TessMemberResultCallback_0_1 : public TessResultCallback1<R,A1> {
01805  public:
01806   typedef TessResultCallback1<R,A1> base;
01807   typedef R (T::*MemberSignature)(A1) ;
01808 
01809  private:
01810    T* object_;
01811   MemberSignature member_;
01812 
01813  public:
01814   inline _TessMemberResultCallback_0_1(
01815       T* object, MemberSignature member)
01816     : object_(object),
01817       member_(member) {
01818   }
01819 
01820   virtual R Run(A1 a1) {
01821     if (!del) {
01822       R result = (object_->*member_)(a1);
01823       return result;
01824     } else {
01825       R result = (object_->*member_)(a1);
01826       //  zero out the pointer to ensure segfault if used again
01827       member_ = NULL;
01828       delete this;
01829       return result;
01830     }
01831   }
01832 };
01833 
01834 template <bool del, class T, class A1>
01835 class _TessMemberResultCallback_0_1<del, void, T, A1>
01836   : public TessCallback1<A1> {
01837  public:
01838   typedef TessCallback1<A1> base;
01839   typedef void (T::*MemberSignature)(A1) ;
01840 
01841  private:
01842    T* object_;
01843   MemberSignature member_;
01844 
01845  public:
01846   inline _TessMemberResultCallback_0_1(
01847        T* object, MemberSignature member)
01848     : object_(object),
01849       member_(member) {
01850   }
01851 
01852   virtual void Run(A1 a1) {
01853     if (!del) {
01854       (object_->*member_)(a1);
01855     } else {
01856       (object_->*member_)(a1);
01857       //  zero out the pointer to ensure segfault if used again
01858       member_ = NULL;
01859       delete this;
01860     }
01861   }
01862 };
01863 
01864 #ifndef SWIG
01865 template <class T1, class T2, class R, class A1>
01866 inline typename _TessMemberResultCallback_0_1<true,R,T1,A1>::base*
01867 NewTessCallback(
01868      T1* obj, R (T2::*member)(A1) ) {
01869   return new _TessMemberResultCallback_0_1<true,R,T1,A1>(
01870       obj, member);
01871 }
01872 #endif
01873 
01874 #ifndef SWIG
01875 template <class T1, class T2, class R, class A1>
01876 inline typename _TessMemberResultCallback_0_1<false,R,T1,A1>::base*
01877 NewPermanentTessCallback(
01878      T1* obj, R (T2::*member)(A1) ) {
01879   return new _TessMemberResultCallback_0_1<false,R,T1,A1>(
01880       obj, member);
01881 }
01882 #endif
01883 
01884 template <bool del, class R, class A1>
01885 class _TessFunctionResultCallback_0_1 : public TessResultCallback1<R,A1> {
01886  public:
01887   typedef TessResultCallback1<R,A1> base;
01888   typedef R (*FunctionSignature)(A1);
01889 
01890  private:
01891   FunctionSignature function_;
01892 
01893  public:
01894   inline _TessFunctionResultCallback_0_1(
01895       FunctionSignature function)
01896     : function_(function) {
01897   }
01898 
01899   virtual R Run(A1 a1) {
01900     if (!del) {
01901       R result = (*function_)(a1);
01902       return result;
01903     } else {
01904       R result = (*function_)(a1);
01905       //  zero out the pointer to ensure segfault if used again
01906       function_ = NULL;
01907       delete this;
01908       return result;
01909     }
01910   }
01911 };
01912 
01913 template <bool del, class A1>
01914 class _TessFunctionResultCallback_0_1<del, void, A1>
01915   : public TessCallback1<A1> {
01916  public:
01917   typedef TessCallback1<A1> base;
01918   typedef void (*FunctionSignature)(A1);
01919 
01920  private:
01921   FunctionSignature function_;
01922 
01923  public:
01924   inline _TessFunctionResultCallback_0_1(
01925       FunctionSignature function)
01926     : function_(function) {
01927   }
01928 
01929   virtual void Run(A1 a1) {
01930     if (!del) {
01931       (*function_)(a1);
01932     } else {
01933       (*function_)(a1);
01934       //  zero out the pointer to ensure segfault if used again
01935       function_ = NULL;
01936       delete this;
01937     }
01938   }
01939 };
01940 
01941 template <class R, class A1>
01942 inline typename _TessFunctionResultCallback_0_1<true,R,A1>::base*
01943 NewTessCallback(R (*function)(A1)) {
01944   return new _TessFunctionResultCallback_0_1<true,R,A1>(function);
01945 }
01946 
01947 template <class R, class A1>
01948 inline typename _TessFunctionResultCallback_0_1<false,R,A1>::base*
01949 NewPermanentTessCallback(R (*function)(A1)) {
01950   return new _TessFunctionResultCallback_0_1<false,R,A1>(function);
01951 }
01952 
01953 template <bool del, class R, class T, class P1, class A1>
01954 class _ConstTessMemberResultCallback_1_1 : public TessResultCallback1<R,A1> {
01955  public:
01956   typedef TessResultCallback1<R,A1> base;
01957   typedef R (T::*MemberSignature)(P1,A1) const;
01958 
01959  private:
01960   const T* object_;
01961   MemberSignature member_;
01962   typename remove_reference<P1>::type p1_;
01963 
01964  public:
01965   inline _ConstTessMemberResultCallback_1_1(const T* object, MemberSignature member, P1 p1)
01966     : object_(object),
01967       member_(member),      p1_(p1) { }
01968 
01969   virtual R Run(A1 a1) {
01970     if (!del) {
01971       R result = (object_->*member_)(p1_,a1);
01972       return result;
01973     } else {
01974       R result = (object_->*member_)(p1_,a1);
01975       //  zero out the pointer to ensure segfault if used again
01976       member_ = NULL;
01977       delete this;
01978       return result;
01979     }
01980   }
01981 };
01982 
01983 template <bool del, class T, class P1, class A1>
01984 class _ConstTessMemberResultCallback_1_1<del, void, T, P1, A1> : public TessCallback1<A1> {
01985  public:
01986   typedef TessCallback1<A1> base;
01987   typedef void (T::*MemberSignature)(P1,A1) const;
01988 
01989  private:
01990   const T* object_;
01991   MemberSignature member_;
01992   typename remove_reference<P1>::type p1_;
01993 
01994  public:
01995   inline _ConstTessMemberResultCallback_1_1(const T* object, MemberSignature member, P1 p1)
01996     : object_(object),
01997       member_(member),      p1_(p1) { }
01998 
01999   virtual void Run(A1 a1) {
02000     if (!del) {
02001       (object_->*member_)(p1_,a1);
02002     } else {
02003       (object_->*member_)(p1_,a1);
02004       //  zero out the pointer to ensure segfault if used again
02005       member_ = NULL;
02006       delete this;
02007     }
02008   }
02009 };
02010 
02011 #ifndef SWIG
02012 template <class T1, class T2, class R, class P1, class A1>
02013 inline typename _ConstTessMemberResultCallback_1_1<true,R,T1,P1,A1>::base*
02014 NewTessCallback(const T1* obj, R (T2::*member)(P1,A1) const, typename Identity<P1>::type p1) {
02015   return new _ConstTessMemberResultCallback_1_1<true,R,T1,P1,A1>(obj, member, p1);
02016 }
02017 #endif
02018 
02019 #ifndef SWIG
02020 template <class T1, class T2, class R, class P1, class A1>
02021 inline typename _ConstTessMemberResultCallback_1_1<false,R,T1,P1,A1>::base*
02022 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,A1) const, typename Identity<P1>::type p1) {
02023   return new _ConstTessMemberResultCallback_1_1<false,R,T1,P1,A1>(obj, member, p1);
02024 }
02025 #endif
02026 
02027 template <bool del, class R, class T, class P1, class A1>
02028 class _TessMemberResultCallback_1_1 : public TessResultCallback1<R,A1> {
02029  public:
02030   typedef TessResultCallback1<R,A1> base;
02031   typedef R (T::*MemberSignature)(P1,A1) ;
02032 
02033  private:
02034    T* object_;
02035   MemberSignature member_;
02036   typename remove_reference<P1>::type p1_;
02037 
02038  public:
02039   inline _TessMemberResultCallback_1_1( T* object, MemberSignature member, P1 p1)
02040     : object_(object),
02041       member_(member),      p1_(p1) { }
02042 
02043   virtual R Run(A1 a1) {
02044     if (!del) {
02045       R result = (object_->*member_)(p1_,a1);
02046       return result;
02047     } else {
02048       R result = (object_->*member_)(p1_,a1);
02049       //  zero out the pointer to ensure segfault if used again
02050       member_ = NULL;
02051       delete this;
02052       return result;
02053     }
02054   }
02055 };
02056 
02057 template <bool del, class T, class P1, class A1>
02058 class _TessMemberResultCallback_1_1<del, void, T, P1, A1> : public TessCallback1<A1> {
02059  public:
02060   typedef TessCallback1<A1> base;
02061   typedef void (T::*MemberSignature)(P1,A1) ;
02062 
02063  private:
02064    T* object_;
02065   MemberSignature member_;
02066   typename remove_reference<P1>::type p1_;
02067 
02068  public:
02069   inline _TessMemberResultCallback_1_1( T* object, MemberSignature member, P1 p1)
02070     : object_(object),
02071       member_(member),      p1_(p1) { }
02072 
02073   virtual void Run(A1 a1) {
02074     if (!del) {
02075       (object_->*member_)(p1_,a1);
02076     } else {
02077       (object_->*member_)(p1_,a1);
02078       //  zero out the pointer to ensure segfault if used again
02079       member_ = NULL;
02080       delete this;
02081     }
02082   }
02083 };
02084 
02085 #ifndef SWIG
02086 template <class T1, class T2, class R, class P1, class A1>
02087 inline typename _TessMemberResultCallback_1_1<true,R,T1,P1,A1>::base*
02088 NewTessCallback( T1* obj, R (T2::*member)(P1,A1) , typename Identity<P1>::type p1) {
02089   return new _TessMemberResultCallback_1_1<true,R,T1,P1,A1>(obj, member, p1);
02090 }
02091 #endif
02092 
02093 #ifndef SWIG
02094 template <class T1, class T2, class R, class P1, class A1>
02095 inline typename _TessMemberResultCallback_1_1<false,R,T1,P1,A1>::base*
02096 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,A1) , typename Identity<P1>::type p1) {
02097   return new _TessMemberResultCallback_1_1<false,R,T1,P1,A1>(obj, member, p1);
02098 }
02099 #endif
02100 
02101 template <bool del, class R, class P1, class A1>
02102 class _TessFunctionResultCallback_1_1 : public TessResultCallback1<R,A1> {
02103  public:
02104   typedef TessResultCallback1<R,A1> base;
02105   typedef R (*FunctionSignature)(P1,A1);
02106 
02107  private:
02108   FunctionSignature function_;
02109   typename remove_reference<P1>::type p1_;
02110 
02111  public:
02112   inline _TessFunctionResultCallback_1_1(FunctionSignature function, P1 p1)
02113     : function_(function),      p1_(p1) { }
02114 
02115   virtual R Run(A1 a1) {
02116     if (!del) {
02117       R result = (*function_)(p1_,a1);
02118       return result;
02119     } else {
02120       R result = (*function_)(p1_,a1);
02121       //  zero out the pointer to ensure segfault if used again
02122       function_ = NULL;
02123       delete this;
02124       return result;
02125     }
02126   }
02127 };
02128 
02129 template <bool del, class P1, class A1>
02130 class _TessFunctionResultCallback_1_1<del, void, P1, A1> : public TessCallback1<A1> {
02131  public:
02132   typedef TessCallback1<A1> base;
02133   typedef void (*FunctionSignature)(P1,A1);
02134 
02135  private:
02136   FunctionSignature function_;
02137   typename remove_reference<P1>::type p1_;
02138 
02139  public:
02140   inline _TessFunctionResultCallback_1_1(FunctionSignature function, P1 p1)
02141     : function_(function),      p1_(p1) { }
02142 
02143   virtual void Run(A1 a1) {
02144     if (!del) {
02145       (*function_)(p1_,a1);
02146     } else {
02147       (*function_)(p1_,a1);
02148       //  zero out the pointer to ensure segfault if used again
02149       function_ = NULL;
02150       delete this;
02151     }
02152   }
02153 };
02154 
02155 template <class R, class P1, class A1>
02156 inline typename _TessFunctionResultCallback_1_1<true,R,P1,A1>::base*
02157 NewTessCallback(R (*function)(P1,A1), typename Identity<P1>::type p1) {
02158   return new _TessFunctionResultCallback_1_1<true,R,P1,A1>(function, p1);
02159 }
02160 
02161 template <class R, class P1, class A1>
02162 inline typename _TessFunctionResultCallback_1_1<false,R,P1,A1>::base*
02163 NewPermanentTessCallback(R (*function)(P1,A1), typename Identity<P1>::type p1) {
02164   return new _TessFunctionResultCallback_1_1<false,R,P1,A1>(function, p1);
02165 }
02166 
02167 template <bool del, class R, class T, class P1, class P2, class A1>
02168 class _ConstTessMemberResultCallback_2_1 : public TessResultCallback1<R,A1> {
02169  public:
02170   typedef TessResultCallback1<R,A1> base;
02171   typedef R (T::*MemberSignature)(P1,P2,A1) const;
02172 
02173  private:
02174   const T* object_;
02175   MemberSignature member_;
02176   typename remove_reference<P1>::type p1_;
02177   typename remove_reference<P2>::type p2_;
02178 
02179  public:
02180   inline _ConstTessMemberResultCallback_2_1(const T* object, MemberSignature member, P1 p1, P2 p2)
02181     : object_(object),
02182       member_(member),      p1_(p1),      p2_(p2) { }
02183 
02184   virtual R Run(A1 a1) {
02185     if (!del) {
02186       R result = (object_->*member_)(p1_,p2_,a1);
02187       return result;
02188     } else {
02189       R result = (object_->*member_)(p1_,p2_,a1);
02190       //  zero out the pointer to ensure segfault if used again
02191       member_ = NULL;
02192       delete this;
02193       return result;
02194     }
02195   }
02196 };
02197 
02198 template <bool del, class T, class P1, class P2, class A1>
02199 class _ConstTessMemberResultCallback_2_1<del, void, T, P1, P2, A1> : public TessCallback1<A1> {
02200  public:
02201   typedef TessCallback1<A1> base;
02202   typedef void (T::*MemberSignature)(P1,P2,A1) const;
02203 
02204  private:
02205   const T* object_;
02206   MemberSignature member_;
02207   typename remove_reference<P1>::type p1_;
02208   typename remove_reference<P2>::type p2_;
02209 
02210  public:
02211   inline _ConstTessMemberResultCallback_2_1(const T* object, MemberSignature member, P1 p1, P2 p2)
02212     : object_(object),
02213       member_(member),      p1_(p1),      p2_(p2) { }
02214 
02215   virtual void Run(A1 a1) {
02216     if (!del) {
02217       (object_->*member_)(p1_,p2_,a1);
02218     } else {
02219       (object_->*member_)(p1_,p2_,a1);
02220       //  zero out the pointer to ensure segfault if used again
02221       member_ = NULL;
02222       delete this;
02223     }
02224   }
02225 };
02226 
02227 #ifndef SWIG
02228 template <class T1, class T2, class R, class P1, class P2, class A1>
02229 inline typename _ConstTessMemberResultCallback_2_1<true,R,T1,P1,P2,A1>::base*
02230 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
02231   return new _ConstTessMemberResultCallback_2_1<true,R,T1,P1,P2,A1>(obj, member, p1, p2);
02232 }
02233 #endif
02234 
02235 #ifndef SWIG
02236 template <class T1, class T2, class R, class P1, class P2, class A1>
02237 inline typename _ConstTessMemberResultCallback_2_1<false,R,T1,P1,P2,A1>::base*
02238 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
02239   return new _ConstTessMemberResultCallback_2_1<false,R,T1,P1,P2,A1>(obj, member, p1, p2);
02240 }
02241 #endif
02242 
02243 template <bool del, class R, class T, class P1, class P2, class A1>
02244 class _TessMemberResultCallback_2_1 : public TessResultCallback1<R,A1> {
02245  public:
02246   typedef TessResultCallback1<R,A1> base;
02247   typedef R (T::*MemberSignature)(P1,P2,A1) ;
02248 
02249  private:
02250    T* object_;
02251   MemberSignature member_;
02252   typename remove_reference<P1>::type p1_;
02253   typename remove_reference<P2>::type p2_;
02254 
02255  public:
02256   inline _TessMemberResultCallback_2_1( T* object, MemberSignature member, P1 p1, P2 p2)
02257     : object_(object),
02258       member_(member),      p1_(p1),      p2_(p2) { }
02259 
02260   virtual R Run(A1 a1) {
02261     if (!del) {
02262       R result = (object_->*member_)(p1_,p2_,a1);
02263       return result;
02264     } else {
02265       R result = (object_->*member_)(p1_,p2_,a1);
02266       //  zero out the pointer to ensure segfault if used again
02267       member_ = NULL;
02268       delete this;
02269       return result;
02270     }
02271   }
02272 };
02273 
02274 template <bool del, class T, class P1, class P2, class A1>
02275 class _TessMemberResultCallback_2_1<del, void, T, P1, P2, A1> : public TessCallback1<A1> {
02276  public:
02277   typedef TessCallback1<A1> base;
02278   typedef void (T::*MemberSignature)(P1,P2,A1) ;
02279 
02280  private:
02281    T* object_;
02282   MemberSignature member_;
02283   typename remove_reference<P1>::type p1_;
02284   typename remove_reference<P2>::type p2_;
02285 
02286  public:
02287   inline _TessMemberResultCallback_2_1( T* object, MemberSignature member, P1 p1, P2 p2)
02288     : object_(object),
02289       member_(member),      p1_(p1),      p2_(p2) { }
02290 
02291   virtual void Run(A1 a1) {
02292     if (!del) {
02293       (object_->*member_)(p1_,p2_,a1);
02294     } else {
02295       (object_->*member_)(p1_,p2_,a1);
02296       //  zero out the pointer to ensure segfault if used again
02297       member_ = NULL;
02298       delete this;
02299     }
02300   }
02301 };
02302 
02303 #ifndef SWIG
02304 template <class T1, class T2, class R, class P1, class P2, class A1>
02305 inline typename _TessMemberResultCallback_2_1<true,R,T1,P1,P2,A1>::base*
02306 NewTessCallback( T1* obj, R (T2::*member)(P1,P2,A1) , typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
02307   return new _TessMemberResultCallback_2_1<true,R,T1,P1,P2,A1>(obj, member, p1, p2);
02308 }
02309 #endif
02310 
02311 #ifndef SWIG
02312 template <class T1, class T2, class R, class P1, class P2, class A1>
02313 inline typename _TessMemberResultCallback_2_1<false,R,T1,P1,P2,A1>::base*
02314 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,A1) , typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
02315   return new _TessMemberResultCallback_2_1<false,R,T1,P1,P2,A1>(obj, member, p1, p2);
02316 }
02317 #endif
02318 
02319 template <bool del, class R, class P1, class P2, class A1>
02320 class _TessFunctionResultCallback_2_1 : public TessResultCallback1<R,A1> {
02321  public:
02322   typedef TessResultCallback1<R,A1> base;
02323   typedef R (*FunctionSignature)(P1,P2,A1);
02324 
02325  private:
02326   FunctionSignature function_;
02327   typename remove_reference<P1>::type p1_;
02328   typename remove_reference<P2>::type p2_;
02329 
02330  public:
02331   inline _TessFunctionResultCallback_2_1(FunctionSignature function, P1 p1, P2 p2)
02332     : function_(function),      p1_(p1),      p2_(p2) { }
02333 
02334   virtual R Run(A1 a1) {
02335     if (!del) {
02336       R result = (*function_)(p1_,p2_,a1);
02337       return result;
02338     } else {
02339       R result = (*function_)(p1_,p2_,a1);
02340       //  zero out the pointer to ensure segfault if used again
02341       function_ = NULL;
02342       delete this;
02343       return result;
02344     }
02345   }
02346 };
02347 
02348 template <bool del, class P1, class P2, class A1>
02349 class _TessFunctionResultCallback_2_1<del, void, P1, P2, A1> : public TessCallback1<A1> {
02350  public:
02351   typedef TessCallback1<A1> base;
02352   typedef void (*FunctionSignature)(P1,P2,A1);
02353 
02354  private:
02355   FunctionSignature function_;
02356   typename remove_reference<P1>::type p1_;
02357   typename remove_reference<P2>::type p2_;
02358 
02359  public:
02360   inline _TessFunctionResultCallback_2_1(FunctionSignature function, P1 p1, P2 p2)
02361     : function_(function),      p1_(p1),      p2_(p2) { }
02362 
02363   virtual void Run(A1 a1) {
02364     if (!del) {
02365       (*function_)(p1_,p2_,a1);
02366     } else {
02367       (*function_)(p1_,p2_,a1);
02368       //  zero out the pointer to ensure segfault if used again
02369       function_ = NULL;
02370       delete this;
02371     }
02372   }
02373 };
02374 
02375 template <class R, class P1, class P2, class A1>
02376 inline typename _TessFunctionResultCallback_2_1<true,R,P1,P2,A1>::base*
02377 NewTessCallback(R (*function)(P1,P2,A1), typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
02378   return new _TessFunctionResultCallback_2_1<true,R,P1,P2,A1>(function, p1, p2);
02379 }
02380 
02381 template <class R, class P1, class P2, class A1>
02382 inline typename _TessFunctionResultCallback_2_1<false,R,P1,P2,A1>::base*
02383 NewPermanentTessCallback(R (*function)(P1,P2,A1), typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
02384   return new _TessFunctionResultCallback_2_1<false,R,P1,P2,A1>(function, p1, p2);
02385 }
02386 
02387 template <bool del, class R, class T, class P1, class P2, class P3, class A1>
02388 class _ConstTessMemberResultCallback_3_1 : public TessResultCallback1<R,A1> {
02389  public:
02390   typedef TessResultCallback1<R,A1> base;
02391   typedef R (T::*MemberSignature)(P1,P2,P3,A1) const;
02392 
02393  private:
02394   const T* object_;
02395   MemberSignature member_;
02396   typename remove_reference<P1>::type p1_;
02397   typename remove_reference<P2>::type p2_;
02398   typename remove_reference<P3>::type p3_;
02399 
02400  public:
02401   inline _ConstTessMemberResultCallback_3_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
02402     : object_(object),
02403       member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }
02404 
02405   virtual R Run(A1 a1) {
02406     if (!del) {
02407       R result = (object_->*member_)(p1_,p2_,p3_,a1);
02408       return result;
02409     } else {
02410       R result = (object_->*member_)(p1_,p2_,p3_,a1);
02411       //  zero out the pointer to ensure segfault if used again
02412       member_ = NULL;
02413       delete this;
02414       return result;
02415     }
02416   }
02417 };
02418 
02419 template <bool del, class T, class P1, class P2, class P3, class A1>
02420 class _ConstTessMemberResultCallback_3_1<del, void, T, P1, P2, P3, A1> : public TessCallback1<A1> {
02421  public:
02422   typedef TessCallback1<A1> base;
02423   typedef void (T::*MemberSignature)(P1,P2,P3,A1) const;
02424 
02425  private:
02426   const T* object_;
02427   MemberSignature member_;
02428   typename remove_reference<P1>::type p1_;
02429   typename remove_reference<P2>::type p2_;
02430   typename remove_reference<P3>::type p3_;
02431 
02432  public:
02433   inline _ConstTessMemberResultCallback_3_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
02434     : object_(object),
02435       member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }
02436 
02437   virtual void Run(A1 a1) {
02438     if (!del) {
02439       (object_->*member_)(p1_,p2_,p3_,a1);
02440     } else {
02441       (object_->*member_)(p1_,p2_,p3_,a1);
02442       //  zero out the pointer to ensure segfault if used again
02443       member_ = NULL;
02444       delete this;
02445     }
02446   }
02447 };
02448 
02449 #ifndef SWIG
02450 template <class T1, class T2, class R, class P1, class P2, class P3, class A1>
02451 inline typename _ConstTessMemberResultCallback_3_1<true,R,T1,P1,P2,P3,A1>::base*
02452 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) {
02453   return new _ConstTessMemberResultCallback_3_1<true,R,T1,P1,P2,P3,A1>(obj, member, p1, p2, p3);
02454 }
02455 #endif
02456 
02457 #ifndef SWIG
02458 template <class T1, class T2, class R, class P1, class P2, class P3, class A1>
02459 inline typename _ConstTessMemberResultCallback_3_1<false,R,T1,P1,P2,P3,A1>::base*
02460 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) {
02461   return new _ConstTessMemberResultCallback_3_1<false,R,T1,P1,P2,P3,A1>(obj, member, p1, p2, p3);
02462 }
02463 #endif
02464 
02465 template <bool del, class R, class T, class P1, class P2, class P3, class A1>
02466 class _TessMemberResultCallback_3_1 : public TessResultCallback1<R,A1> {
02467  public:
02468   typedef TessResultCallback1<R,A1> base;
02469   typedef R (T::*MemberSignature)(P1,P2,P3,A1) ;
02470 
02471  private:
02472    T* object_;
02473   MemberSignature member_;
02474   typename remove_reference<P1>::type p1_;
02475   typename remove_reference<P2>::type p2_;
02476   typename remove_reference<P3>::type p3_;
02477 
02478  public:
02479   inline _TessMemberResultCallback_3_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
02480     : object_(object),
02481       member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }
02482 
02483   virtual R Run(A1 a1) {
02484     if (!del) {
02485       R result = (object_->*member_)(p1_,p2_,p3_,a1);
02486       return result;
02487     } else {
02488       R result = (object_->*member_)(p1_,p2_,p3_,a1);
02489       //  zero out the pointer to ensure segfault if used again
02490       member_ = NULL;
02491       delete this;
02492       return result;
02493     }
02494   }
02495 };
02496 
02497 template <bool del, class T, class P1, class P2, class P3, class A1>
02498 class _TessMemberResultCallback_3_1<del, void, T, P1, P2, P3, A1> : public TessCallback1<A1> {
02499  public:
02500   typedef TessCallback1<A1> base;
02501   typedef void (T::*MemberSignature)(P1,P2,P3,A1) ;
02502 
02503  private:
02504    T* object_;
02505   MemberSignature member_;
02506   typename remove_reference<P1>::type p1_;
02507   typename remove_reference<P2>::type p2_;
02508   typename remove_reference<P3>::type p3_;
02509 
02510  public:
02511   inline _TessMemberResultCallback_3_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
02512     : object_(object),
02513       member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }
02514 
02515   virtual void Run(A1 a1) {
02516     if (!del) {
02517       (object_->*member_)(p1_,p2_,p3_,a1);
02518     } else {
02519       (object_->*member_)(p1_,p2_,p3_,a1);
02520       //  zero out the pointer to ensure segfault if used again
02521       member_ = NULL;
02522       delete this;
02523     }
02524   }
02525 };
02526 
02527 #ifndef SWIG
02528 template <class T1, class T2, class R, class P1, class P2, class P3, class A1>
02529 inline typename _TessMemberResultCallback_3_1<true,R,T1,P1,P2,P3,A1>::base*
02530 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) {
02531   return new _TessMemberResultCallback_3_1<true,R,T1,P1,P2,P3,A1>(obj, member, p1, p2, p3);
02532 }
02533 #endif
02534 
02535 #ifndef SWIG
02536 template <class T1, class T2, class R, class P1, class P2, class P3, class A1>
02537 inline typename _TessMemberResultCallback_3_1<false,R,T1,P1,P2,P3,A1>::base*
02538 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) {
02539   return new _TessMemberResultCallback_3_1<false,R,T1,P1,P2,P3,A1>(obj, member, p1, p2, p3);
02540 }
02541 #endif
02542 
02543 template <bool del, class R, class P1, class P2, class P3, class A1>
02544 class _TessFunctionResultCallback_3_1 : public TessResultCallback1<R,A1> {
02545  public:
02546   typedef TessResultCallback1<R,A1> base;
02547   typedef R (*FunctionSignature)(P1,P2,P3,A1);
02548 
02549  private:
02550   FunctionSignature function_;
02551   typename remove_reference<P1>::type p1_;
02552   typename remove_reference<P2>::type p2_;
02553   typename remove_reference<P3>::type p3_;
02554 
02555  public:
02556   inline _TessFunctionResultCallback_3_1(FunctionSignature function, P1 p1, P2 p2, P3 p3)
02557     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3) { }
02558 
02559   virtual R Run(A1 a1) {
02560     if (!del) {
02561       R result = (*function_)(p1_,p2_,p3_,a1);
02562       return result;
02563     } else {
02564       R result = (*function_)(p1_,p2_,p3_,a1);
02565       //  zero out the pointer to ensure segfault if used again
02566       function_ = NULL;
02567       delete this;
02568       return result;
02569     }
02570   }
02571 };
02572 
02573 template <bool del, class P1, class P2, class P3, class A1>
02574 class _TessFunctionResultCallback_3_1<del, void, P1, P2, P3, A1> : public TessCallback1<A1> {
02575  public:
02576   typedef TessCallback1<A1> base;
02577   typedef void (*FunctionSignature)(P1,P2,P3,A1);
02578 
02579  private:
02580   FunctionSignature function_;
02581   typename remove_reference<P1>::type p1_;
02582   typename remove_reference<P2>::type p2_;
02583   typename remove_reference<P3>::type p3_;
02584 
02585  public:
02586   inline _TessFunctionResultCallback_3_1(FunctionSignature function, P1 p1, P2 p2, P3 p3)
02587     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3) { }
02588 
02589   virtual void Run(A1 a1) {
02590     if (!del) {
02591       (*function_)(p1_,p2_,p3_,a1);
02592     } else {
02593       (*function_)(p1_,p2_,p3_,a1);
02594       //  zero out the pointer to ensure segfault if used again
02595       function_ = NULL;
02596       delete this;
02597     }
02598   }
02599 };
02600 
02601 template <class R, class P1, class P2, class P3, class A1>
02602 inline typename _TessFunctionResultCallback_3_1<true,R,P1,P2,P3,A1>::base*
02603 NewTessCallback(R (*function)(P1,P2,P3,A1), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
02604   return new _TessFunctionResultCallback_3_1<true,R,P1,P2,P3,A1>(function, p1, p2, p3);
02605 }
02606 
02607 template <class R, class P1, class P2, class P3, class A1>
02608 inline typename _TessFunctionResultCallback_3_1<false,R,P1,P2,P3,A1>::base*
02609 NewPermanentTessCallback(R (*function)(P1,P2,P3,A1), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
02610   return new _TessFunctionResultCallback_3_1<false,R,P1,P2,P3,A1>(function, p1, p2, p3);
02611 }
02612 
02613 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class A1>
02614 class _ConstTessMemberResultCallback_4_1 : public TessResultCallback1<R,A1> {
02615  public:
02616   typedef TessResultCallback1<R,A1> base;
02617   typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1) const;
02618 
02619  private:
02620   const T* object_;
02621   MemberSignature member_;
02622   typename remove_reference<P1>::type p1_;
02623   typename remove_reference<P2>::type p2_;
02624   typename remove_reference<P3>::type p3_;
02625   typename remove_reference<P4>::type p4_;
02626 
02627  public:
02628   inline _ConstTessMemberResultCallback_4_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
02629     : object_(object),
02630       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
02631 
02632   virtual R Run(A1 a1) {
02633     if (!del) {
02634       R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1);
02635       return result;
02636     } else {
02637       R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1);
02638       //  zero out the pointer to ensure segfault if used again
02639       member_ = NULL;
02640       delete this;
02641       return result;
02642     }
02643   }
02644 };
02645 
02646 template <bool del, class T, class P1, class P2, class P3, class P4, class A1>
02647 class _ConstTessMemberResultCallback_4_1<del, void, T, P1, P2, P3, P4, A1> : public TessCallback1<A1> {
02648  public:
02649   typedef TessCallback1<A1> base;
02650   typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1) const;
02651 
02652  private:
02653   const T* object_;
02654   MemberSignature member_;
02655   typename remove_reference<P1>::type p1_;
02656   typename remove_reference<P2>::type p2_;
02657   typename remove_reference<P3>::type p3_;
02658   typename remove_reference<P4>::type p4_;
02659 
02660  public:
02661   inline _ConstTessMemberResultCallback_4_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
02662     : object_(object),
02663       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
02664 
02665   virtual void Run(A1 a1) {
02666     if (!del) {
02667       (object_->*member_)(p1_,p2_,p3_,p4_,a1);
02668     } else {
02669       (object_->*member_)(p1_,p2_,p3_,p4_,a1);
02670       //  zero out the pointer to ensure segfault if used again
02671       member_ = NULL;
02672       delete this;
02673     }
02674   }
02675 };
02676 
02677 #ifndef SWIG
02678 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1>
02679 inline typename _ConstTessMemberResultCallback_4_1<true,R,T1,P1,P2,P3,P4,A1>::base*
02680 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) {
02681   return new _ConstTessMemberResultCallback_4_1<true,R,T1,P1,P2,P3,P4,A1>(obj, member, p1, p2, p3, p4);
02682 }
02683 #endif
02684 
02685 #ifndef SWIG
02686 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1>
02687 inline typename _ConstTessMemberResultCallback_4_1<false,R,T1,P1,P2,P3,P4,A1>::base*
02688 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) {
02689   return new _ConstTessMemberResultCallback_4_1<false,R,T1,P1,P2,P3,P4,A1>(obj, member, p1, p2, p3, p4);
02690 }
02691 #endif
02692 
02693 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class A1>
02694 class _TessMemberResultCallback_4_1 : public TessResultCallback1<R,A1> {
02695  public:
02696   typedef TessResultCallback1<R,A1> base;
02697   typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1) ;
02698 
02699  private:
02700    T* object_;
02701   MemberSignature member_;
02702   typename remove_reference<P1>::type p1_;
02703   typename remove_reference<P2>::type p2_;
02704   typename remove_reference<P3>::type p3_;
02705   typename remove_reference<P4>::type p4_;
02706 
02707  public:
02708   inline _TessMemberResultCallback_4_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
02709     : object_(object),
02710       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
02711 
02712   virtual R Run(A1 a1) {
02713     if (!del) {
02714       R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1);
02715       return result;
02716     } else {
02717       R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1);
02718       //  zero out the pointer to ensure segfault if used again
02719       member_ = NULL;
02720       delete this;
02721       return result;
02722     }
02723   }
02724 };
02725 
02726 template <bool del, class T, class P1, class P2, class P3, class P4, class A1>
02727 class _TessMemberResultCallback_4_1<del, void, T, P1, P2, P3, P4, A1> : public TessCallback1<A1> {
02728  public:
02729   typedef TessCallback1<A1> base;
02730   typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1) ;
02731 
02732  private:
02733    T* object_;
02734   MemberSignature member_;
02735   typename remove_reference<P1>::type p1_;
02736   typename remove_reference<P2>::type p2_;
02737   typename remove_reference<P3>::type p3_;
02738   typename remove_reference<P4>::type p4_;
02739 
02740  public:
02741   inline _TessMemberResultCallback_4_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
02742     : object_(object),
02743       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
02744 
02745   virtual void Run(A1 a1) {
02746     if (!del) {
02747       (object_->*member_)(p1_,p2_,p3_,p4_,a1);
02748     } else {
02749       (object_->*member_)(p1_,p2_,p3_,p4_,a1);
02750       //  zero out the pointer to ensure segfault if used again
02751       member_ = NULL;
02752       delete this;
02753     }
02754   }
02755 };
02756 
02757 #ifndef SWIG
02758 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1>
02759 inline typename _TessMemberResultCallback_4_1<true,R,T1,P1,P2,P3,P4,A1>::base*
02760 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) {
02761   return new _TessMemberResultCallback_4_1<true,R,T1,P1,P2,P3,P4,A1>(obj, member, p1, p2, p3, p4);
02762 }
02763 #endif
02764 
02765 #ifndef SWIG
02766 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1>
02767 inline typename _TessMemberResultCallback_4_1<false,R,T1,P1,P2,P3,P4,A1>::base*
02768 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) {
02769   return new _TessMemberResultCallback_4_1<false,R,T1,P1,P2,P3,P4,A1>(obj, member, p1, p2, p3, p4);
02770 }
02771 #endif
02772 
02773 template <bool del, class R, class P1, class P2, class P3, class P4, class A1>
02774 class _TessFunctionResultCallback_4_1 : public TessResultCallback1<R,A1> {
02775  public:
02776   typedef TessResultCallback1<R,A1> base;
02777   typedef R (*FunctionSignature)(P1,P2,P3,P4,A1);
02778 
02779  private:
02780   FunctionSignature function_;
02781   typename remove_reference<P1>::type p1_;
02782   typename remove_reference<P2>::type p2_;
02783   typename remove_reference<P3>::type p3_;
02784   typename remove_reference<P4>::type p4_;
02785 
02786  public:
02787   inline _TessFunctionResultCallback_4_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
02788     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
02789 
02790   virtual R Run(A1 a1) {
02791     if (!del) {
02792       R result = (*function_)(p1_,p2_,p3_,p4_,a1);
02793       return result;
02794     } else {
02795       R result = (*function_)(p1_,p2_,p3_,p4_,a1);
02796       //  zero out the pointer to ensure segfault if used again
02797       function_ = NULL;
02798       delete this;
02799       return result;
02800     }
02801   }
02802 };
02803 
02804 template <bool del, class P1, class P2, class P3, class P4, class A1>
02805 class _TessFunctionResultCallback_4_1<del, void, P1, P2, P3, P4, A1> : public TessCallback1<A1> {
02806  public:
02807   typedef TessCallback1<A1> base;
02808   typedef void (*FunctionSignature)(P1,P2,P3,P4,A1);
02809 
02810  private:
02811   FunctionSignature function_;
02812   typename remove_reference<P1>::type p1_;
02813   typename remove_reference<P2>::type p2_;
02814   typename remove_reference<P3>::type p3_;
02815   typename remove_reference<P4>::type p4_;
02816 
02817  public:
02818   inline _TessFunctionResultCallback_4_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
02819     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
02820 
02821   virtual void Run(A1 a1) {
02822     if (!del) {
02823       (*function_)(p1_,p2_,p3_,p4_,a1);
02824     } else {
02825       (*function_)(p1_,p2_,p3_,p4_,a1);
02826       //  zero out the pointer to ensure segfault if used again
02827       function_ = NULL;
02828       delete this;
02829     }
02830   }
02831 };
02832 
02833 template <class R, class P1, class P2, class P3, class P4, class A1>
02834 inline typename _TessFunctionResultCallback_4_1<true,R,P1,P2,P3,P4,A1>::base*
02835 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) {
02836   return new _TessFunctionResultCallback_4_1<true,R,P1,P2,P3,P4,A1>(function, p1, p2, p3, p4);
02837 }
02838 
02839 template <class R, class P1, class P2, class P3, class P4, class A1>
02840 inline typename _TessFunctionResultCallback_4_1<false,R,P1,P2,P3,P4,A1>::base*
02841 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) {
02842   return new _TessFunctionResultCallback_4_1<false,R,P1,P2,P3,P4,A1>(function, p1, p2, p3, p4);
02843 }
02844 
02845 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class A1>
02846 class _ConstTessMemberResultCallback_5_1 : public TessResultCallback1<R,A1> {
02847  public:
02848   typedef TessResultCallback1<R,A1> base;
02849   typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1) const;
02850 
02851  private:
02852   const T* object_;
02853   MemberSignature member_;
02854   typename remove_reference<P1>::type p1_;
02855   typename remove_reference<P2>::type p2_;
02856   typename remove_reference<P3>::type p3_;
02857   typename remove_reference<P4>::type p4_;
02858   typename remove_reference<P5>::type p5_;
02859 
02860  public:
02861   inline _ConstTessMemberResultCallback_5_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
02862     : object_(object),
02863       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
02864 
02865   virtual R Run(A1 a1) {
02866     if (!del) {
02867       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1);
02868       return result;
02869     } else {
02870       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1);
02871       //  zero out the pointer to ensure segfault if used again
02872       member_ = NULL;
02873       delete this;
02874       return result;
02875     }
02876   }
02877 };
02878 
02879 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class A1>
02880 class _ConstTessMemberResultCallback_5_1<del, void, T, P1, P2, P3, P4, P5, A1> : public TessCallback1<A1> {
02881  public:
02882   typedef TessCallback1<A1> base;
02883   typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1) const;
02884 
02885  private:
02886   const T* object_;
02887   MemberSignature member_;
02888   typename remove_reference<P1>::type p1_;
02889   typename remove_reference<P2>::type p2_;
02890   typename remove_reference<P3>::type p3_;
02891   typename remove_reference<P4>::type p4_;
02892   typename remove_reference<P5>::type p5_;
02893 
02894  public:
02895   inline _ConstTessMemberResultCallback_5_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
02896     : object_(object),
02897       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
02898 
02899   virtual void Run(A1 a1) {
02900     if (!del) {
02901       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1);
02902     } else {
02903       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1);
02904       //  zero out the pointer to ensure segfault if used again
02905       member_ = NULL;
02906       delete this;
02907     }
02908   }
02909 };
02910 
02911 #ifndef SWIG
02912 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1>
02913 inline typename _ConstTessMemberResultCallback_5_1<true,R,T1,P1,P2,P3,P4,P5,A1>::base*
02914 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) {
02915   return new _ConstTessMemberResultCallback_5_1<true,R,T1,P1,P2,P3,P4,P5,A1>(obj, member, p1, p2, p3, p4, p5);
02916 }
02917 #endif
02918 
02919 #ifndef SWIG
02920 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1>
02921 inline typename _ConstTessMemberResultCallback_5_1<false,R,T1,P1,P2,P3,P4,P5,A1>::base*
02922 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) {
02923   return new _ConstTessMemberResultCallback_5_1<false,R,T1,P1,P2,P3,P4,P5,A1>(obj, member, p1, p2, p3, p4, p5);
02924 }
02925 #endif
02926 
02927 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class A1>
02928 class _TessMemberResultCallback_5_1 : public TessResultCallback1<R,A1> {
02929  public:
02930   typedef TessResultCallback1<R,A1> base;
02931   typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1) ;
02932 
02933  private:
02934    T* object_;
02935   MemberSignature member_;
02936   typename remove_reference<P1>::type p1_;
02937   typename remove_reference<P2>::type p2_;
02938   typename remove_reference<P3>::type p3_;
02939   typename remove_reference<P4>::type p4_;
02940   typename remove_reference<P5>::type p5_;
02941 
02942  public:
02943   inline _TessMemberResultCallback_5_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
02944     : object_(object),
02945       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
02946 
02947   virtual R Run(A1 a1) {
02948     if (!del) {
02949       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1);
02950       return result;
02951     } else {
02952       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1);
02953       //  zero out the pointer to ensure segfault if used again
02954       member_ = NULL;
02955       delete this;
02956       return result;
02957     }
02958   }
02959 };
02960 
02961 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class A1>
02962 class _TessMemberResultCallback_5_1<del, void, T, P1, P2, P3, P4, P5, A1> : public TessCallback1<A1> {
02963  public:
02964   typedef TessCallback1<A1> base;
02965   typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1) ;
02966 
02967  private:
02968    T* object_;
02969   MemberSignature member_;
02970   typename remove_reference<P1>::type p1_;
02971   typename remove_reference<P2>::type p2_;
02972   typename remove_reference<P3>::type p3_;
02973   typename remove_reference<P4>::type p4_;
02974   typename remove_reference<P5>::type p5_;
02975 
02976  public:
02977   inline _TessMemberResultCallback_5_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
02978     : object_(object),
02979       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
02980 
02981   virtual void Run(A1 a1) {
02982     if (!del) {
02983       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1);
02984     } else {
02985       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1);
02986       //  zero out the pointer to ensure segfault if used again
02987       member_ = NULL;
02988       delete this;
02989     }
02990   }
02991 };
02992 
02993 #ifndef SWIG
02994 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1>
02995 inline typename _TessMemberResultCallback_5_1<true,R,T1,P1,P2,P3,P4,P5,A1>::base*
02996 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) {
02997   return new _TessMemberResultCallback_5_1<true,R,T1,P1,P2,P3,P4,P5,A1>(obj, member, p1, p2, p3, p4, p5);
02998 }
02999 #endif
03000 
03001 #ifndef SWIG
03002 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1>
03003 inline typename _TessMemberResultCallback_5_1<false,R,T1,P1,P2,P3,P4,P5,A1>::base*
03004 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) {
03005   return new _TessMemberResultCallback_5_1<false,R,T1,P1,P2,P3,P4,P5,A1>(obj, member, p1, p2, p3, p4, p5);
03006 }
03007 #endif
03008 
03009 template <bool del, class R, class P1, class P2, class P3, class P4, class P5, class A1>
03010 class _TessFunctionResultCallback_5_1 : public TessResultCallback1<R,A1> {
03011  public:
03012   typedef TessResultCallback1<R,A1> base;
03013   typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,A1);
03014 
03015  private:
03016   FunctionSignature function_;
03017   typename remove_reference<P1>::type p1_;
03018   typename remove_reference<P2>::type p2_;
03019   typename remove_reference<P3>::type p3_;
03020   typename remove_reference<P4>::type p4_;
03021   typename remove_reference<P5>::type p5_;
03022 
03023  public:
03024   inline _TessFunctionResultCallback_5_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
03025     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
03026 
03027   virtual R Run(A1 a1) {
03028     if (!del) {
03029       R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1);
03030       return result;
03031     } else {
03032       R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1);
03033       //  zero out the pointer to ensure segfault if used again
03034       function_ = NULL;
03035       delete this;
03036       return result;
03037     }
03038   }
03039 };
03040 
03041 template <bool del, class P1, class P2, class P3, class P4, class P5, class A1>
03042 class _TessFunctionResultCallback_5_1<del, void, P1, P2, P3, P4, P5, A1> : public TessCallback1<A1> {
03043  public:
03044   typedef TessCallback1<A1> base;
03045   typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,A1);
03046 
03047  private:
03048   FunctionSignature function_;
03049   typename remove_reference<P1>::type p1_;
03050   typename remove_reference<P2>::type p2_;
03051   typename remove_reference<P3>::type p3_;
03052   typename remove_reference<P4>::type p4_;
03053   typename remove_reference<P5>::type p5_;
03054 
03055  public:
03056   inline _TessFunctionResultCallback_5_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
03057     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
03058 
03059   virtual void Run(A1 a1) {
03060     if (!del) {
03061       (*function_)(p1_,p2_,p3_,p4_,p5_,a1);
03062     } else {
03063       (*function_)(p1_,p2_,p3_,p4_,p5_,a1);
03064       //  zero out the pointer to ensure segfault if used again
03065       function_ = NULL;
03066       delete this;
03067     }
03068   }
03069 };
03070 
03071 template <class R, class P1, class P2, class P3, class P4, class P5, class A1>
03072 inline typename _TessFunctionResultCallback_5_1<true,R,P1,P2,P3,P4,P5,A1>::base*
03073 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) {
03074   return new _TessFunctionResultCallback_5_1<true,R,P1,P2,P3,P4,P5,A1>(function, p1, p2, p3, p4, p5);
03075 }
03076 
03077 template <class R, class P1, class P2, class P3, class P4, class P5, class A1>
03078 inline typename _TessFunctionResultCallback_5_1<false,R,P1,P2,P3,P4,P5,A1>::base*
03079 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) {
03080   return new _TessFunctionResultCallback_5_1<false,R,P1,P2,P3,P4,P5,A1>(function, p1, p2, p3, p4, p5);
03081 }
03082 
03083 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
03084 class _ConstTessMemberResultCallback_6_1 : public TessResultCallback1<R,A1> {
03085  public:
03086   typedef TessResultCallback1<R,A1> base;
03087   typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1) const;
03088 
03089  private:
03090   const T* object_;
03091   MemberSignature member_;
03092   typename remove_reference<P1>::type p1_;
03093   typename remove_reference<P2>::type p2_;
03094   typename remove_reference<P3>::type p3_;
03095   typename remove_reference<P4>::type p4_;
03096   typename remove_reference<P5>::type p5_;
03097   typename remove_reference<P6>::type p6_;
03098 
03099  public:
03100   inline _ConstTessMemberResultCallback_6_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
03101     : object_(object),
03102       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
03103 
03104   virtual R Run(A1 a1) {
03105     if (!del) {
03106       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
03107       return result;
03108     } else {
03109       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
03110       //  zero out the pointer to ensure segfault if used again
03111       member_ = NULL;
03112       delete this;
03113       return result;
03114     }
03115   }
03116 };
03117 
03118 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
03119 class _ConstTessMemberResultCallback_6_1<del, void, T, P1, P2, P3, P4, P5, P6, A1> : public TessCallback1<A1> {
03120  public:
03121   typedef TessCallback1<A1> base;
03122   typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1) const;
03123 
03124  private:
03125   const T* object_;
03126   MemberSignature member_;
03127   typename remove_reference<P1>::type p1_;
03128   typename remove_reference<P2>::type p2_;
03129   typename remove_reference<P3>::type p3_;
03130   typename remove_reference<P4>::type p4_;
03131   typename remove_reference<P5>::type p5_;
03132   typename remove_reference<P6>::type p6_;
03133 
03134  public:
03135   inline _ConstTessMemberResultCallback_6_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
03136     : object_(object),
03137       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
03138 
03139   virtual void Run(A1 a1) {
03140     if (!del) {
03141       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
03142     } else {
03143       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
03144       //  zero out the pointer to ensure segfault if used again
03145       member_ = NULL;
03146       delete this;
03147     }
03148   }
03149 };
03150 
03151 #ifndef SWIG
03152 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
03153 inline typename _ConstTessMemberResultCallback_6_1<true,R,T1,P1,P2,P3,P4,P5,P6,A1>::base*
03154 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) {
03155   return new _ConstTessMemberResultCallback_6_1<true,R,T1,P1,P2,P3,P4,P5,P6,A1>(obj, member, p1, p2, p3, p4, p5, p6);
03156 }
03157 #endif
03158 
03159 #ifndef SWIG
03160 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
03161 inline typename _ConstTessMemberResultCallback_6_1<false,R,T1,P1,P2,P3,P4,P5,P6,A1>::base*
03162 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) {
03163   return new _ConstTessMemberResultCallback_6_1<false,R,T1,P1,P2,P3,P4,P5,P6,A1>(obj, member, p1, p2, p3, p4, p5, p6);
03164 }
03165 #endif
03166 
03167 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
03168 class _TessMemberResultCallback_6_1 : public TessResultCallback1<R,A1> {
03169  public:
03170   typedef TessResultCallback1<R,A1> base;
03171   typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1) ;
03172 
03173  private:
03174    T* object_;
03175   MemberSignature member_;
03176   typename remove_reference<P1>::type p1_;
03177   typename remove_reference<P2>::type p2_;
03178   typename remove_reference<P3>::type p3_;
03179   typename remove_reference<P4>::type p4_;
03180   typename remove_reference<P5>::type p5_;
03181   typename remove_reference<P6>::type p6_;
03182 
03183  public:
03184   inline _TessMemberResultCallback_6_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
03185     : object_(object),
03186       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
03187 
03188   virtual R Run(A1 a1) {
03189     if (!del) {
03190       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
03191       return result;
03192     } else {
03193       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
03194       //  zero out the pointer to ensure segfault if used again
03195       member_ = NULL;
03196       delete this;
03197       return result;
03198     }
03199   }
03200 };
03201 
03202 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
03203 class _TessMemberResultCallback_6_1<del, void, T, P1, P2, P3, P4, P5, P6, A1> : public TessCallback1<A1> {
03204  public:
03205   typedef TessCallback1<A1> base;
03206   typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1) ;
03207 
03208  private:
03209    T* object_;
03210   MemberSignature member_;
03211   typename remove_reference<P1>::type p1_;
03212   typename remove_reference<P2>::type p2_;
03213   typename remove_reference<P3>::type p3_;
03214   typename remove_reference<P4>::type p4_;
03215   typename remove_reference<P5>::type p5_;
03216   typename remove_reference<P6>::type p6_;
03217 
03218  public:
03219   inline _TessMemberResultCallback_6_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
03220     : object_(object),
03221       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
03222 
03223   virtual void Run(A1 a1) {
03224     if (!del) {
03225       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
03226     } else {
03227       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
03228       //  zero out the pointer to ensure segfault if used again
03229       member_ = NULL;
03230       delete this;
03231     }
03232   }
03233 };
03234 
03235 #ifndef SWIG
03236 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
03237 inline typename _TessMemberResultCallback_6_1<true,R,T1,P1,P2,P3,P4,P5,P6,A1>::base*
03238 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) {
03239   return new _TessMemberResultCallback_6_1<true,R,T1,P1,P2,P3,P4,P5,P6,A1>(obj, member, p1, p2, p3, p4, p5, p6);
03240 }
03241 #endif
03242 
03243 #ifndef SWIG
03244 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
03245 inline typename _TessMemberResultCallback_6_1<false,R,T1,P1,P2,P3,P4,P5,P6,A1>::base*
03246 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) {
03247   return new _TessMemberResultCallback_6_1<false,R,T1,P1,P2,P3,P4,P5,P6,A1>(obj, member, p1, p2, p3, p4, p5, p6);
03248 }
03249 #endif
03250 
03251 template <bool del, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
03252 class _TessFunctionResultCallback_6_1 : public TessResultCallback1<R,A1> {
03253  public:
03254   typedef TessResultCallback1<R,A1> base;
03255   typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1);
03256 
03257  private:
03258   FunctionSignature function_;
03259   typename remove_reference<P1>::type p1_;
03260   typename remove_reference<P2>::type p2_;
03261   typename remove_reference<P3>::type p3_;
03262   typename remove_reference<P4>::type p4_;
03263   typename remove_reference<P5>::type p5_;
03264   typename remove_reference<P6>::type p6_;
03265 
03266  public:
03267   inline _TessFunctionResultCallback_6_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
03268     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
03269 
03270   virtual R Run(A1 a1) {
03271     if (!del) {
03272       R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
03273       return result;
03274     } else {
03275       R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
03276       //  zero out the pointer to ensure segfault if used again
03277       function_ = NULL;
03278       delete this;
03279       return result;
03280     }
03281   }
03282 };
03283 
03284 template <bool del, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
03285 class _TessFunctionResultCallback_6_1<del, void, P1, P2, P3, P4, P5, P6, A1> : public TessCallback1<A1> {
03286  public:
03287   typedef TessCallback1<A1> base;
03288   typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1);
03289 
03290  private:
03291   FunctionSignature function_;
03292   typename remove_reference<P1>::type p1_;
03293   typename remove_reference<P2>::type p2_;
03294   typename remove_reference<P3>::type p3_;
03295   typename remove_reference<P4>::type p4_;
03296   typename remove_reference<P5>::type p5_;
03297   typename remove_reference<P6>::type p6_;
03298 
03299  public:
03300   inline _TessFunctionResultCallback_6_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
03301     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
03302 
03303   virtual void Run(A1 a1) {
03304     if (!del) {
03305       (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
03306     } else {
03307       (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
03308       //  zero out the pointer to ensure segfault if used again
03309       function_ = NULL;
03310       delete this;
03311     }
03312   }
03313 };
03314 
03315 template <class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
03316 inline typename _TessFunctionResultCallback_6_1<true,R,P1,P2,P3,P4,P5,P6,A1>::base*
03317 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) {
03318   return new _TessFunctionResultCallback_6_1<true,R,P1,P2,P3,P4,P5,P6,A1>(function, p1, p2, p3, p4, p5, p6);
03319 }
03320 
03321 template <class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
03322 inline typename _TessFunctionResultCallback_6_1<false,R,P1,P2,P3,P4,P5,P6,A1>::base*
03323 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) {
03324   return new _TessFunctionResultCallback_6_1<false,R,P1,P2,P3,P4,P5,P6,A1>(function, p1, p2, p3, p4, p5, p6);
03325 }
03326 
03327 template <bool del, class R, class T, class A1, class A2>
03328 class _ConstTessMemberResultCallback_0_2 : public TessResultCallback2<R,A1,A2> {
03329  public:
03330   typedef TessResultCallback2<R,A1,A2> base;
03331   typedef R (T::*MemberSignature)(A1,A2) const;
03332 
03333  private:
03334   const T* object_;
03335   MemberSignature member_;
03336 
03337  public:
03338   inline _ConstTessMemberResultCallback_0_2(
03339      const T* object, MemberSignature member)
03340     : object_(object),
03341       member_(member) {
03342   }
03343 
03344   virtual R Run(A1 a1,A2 a2) {
03345     if (!del) {
03346       R result = (object_->*member_)(a1,a2);
03347       return result;
03348     } else {
03349       R result = (object_->*member_)(a1,a2);
03350       //  zero out the pointer to ensure segfault if used again
03351       member_ = NULL;
03352       delete this;
03353       return result;
03354     }
03355   }
03356 };
03357 
03358 template <bool del, class T, class A1, class A2>
03359 class _ConstTessMemberResultCallback_0_2<del, void, T, A1, A2>
03360   : public TessCallback2<A1,A2> {
03361  public:
03362   typedef TessCallback2<A1,A2> base;
03363   typedef void (T::*MemberSignature)(A1,A2) const;
03364 
03365  private:
03366   const T* object_;
03367   MemberSignature member_;
03368 
03369  public:
03370   inline _ConstTessMemberResultCallback_0_2(
03371       const T* object, MemberSignature member)
03372     : object_(object),
03373       member_(member) {
03374   }
03375 
03376   virtual void Run(A1 a1,A2 a2) {
03377     if (!del) {
03378       (object_->*member_)(a1,a2);
03379     } else {
03380       (object_->*member_)(a1,a2);
03381       //  zero out the pointer to ensure segfault if used again
03382       member_ = NULL;
03383       delete this;
03384     }
03385   }
03386 };
03387 
03388 #ifndef SWIG
03389 template <class T1, class T2, class R, class A1, class A2>
03390 inline typename _ConstTessMemberResultCallback_0_2<true,R,T1,A1,A2>::base*
03391 NewTessCallback(
03392     const T1* obj, R (T2::*member)(A1,A2) const) {
03393   return new _ConstTessMemberResultCallback_0_2<true,R,T1,A1,A2>(
03394       obj, member);
03395 }
03396 #endif
03397 
03398 #ifndef SWIG
03399 template <class T1, class T2, class R, class A1, class A2>
03400 inline typename _ConstTessMemberResultCallback_0_2<false,R,T1,A1,A2>::base*
03401 NewPermanentTessCallback(
03402     const T1* obj, R (T2::*member)(A1,A2) const) {
03403   return new _ConstTessMemberResultCallback_0_2<false,R,T1,A1,A2>(
03404       obj, member);
03405 }
03406 #endif
03407 
03408 template <bool del, class R, class T, class A1, class A2>
03409 class _TessMemberResultCallback_0_2 : public TessResultCallback2<R,A1,A2> {
03410  public:
03411   typedef TessResultCallback2<R,A1,A2> base;
03412   typedef R (T::*MemberSignature)(A1,A2) ;
03413 
03414  private:
03415    T* object_;
03416   MemberSignature member_;
03417 
03418  public:
03419   inline _TessMemberResultCallback_0_2(
03420       T* object, MemberSignature member)
03421     : object_(object),
03422       member_(member) {
03423   }
03424 
03425   virtual R Run(A1 a1,A2 a2) {
03426     if (!del) {
03427       R result = (object_->*member_)(a1,a2);
03428       return result;
03429     } else {
03430       R result = (object_->*member_)(a1,a2);
03431       //  zero out the pointer to ensure segfault if used again
03432       member_ = NULL;
03433       delete this;
03434       return result;
03435     }
03436   }
03437 };
03438 
03439 template <bool del, class T, class A1, class A2>
03440 class _TessMemberResultCallback_0_2<del, void, T, A1, A2>
03441   : public TessCallback2<A1,A2> {
03442  public:
03443   typedef TessCallback2<A1,A2> base;
03444   typedef void (T::*MemberSignature)(A1,A2) ;
03445 
03446  private:
03447    T* object_;
03448   MemberSignature member_;
03449 
03450  public:
03451   inline _TessMemberResultCallback_0_2(
03452        T* object, MemberSignature member)
03453     : object_(object),
03454       member_(member) {
03455   }
03456 
03457   virtual void Run(A1 a1,A2 a2) {
03458     if (!del) {
03459       (object_->*member_)(a1,a2);
03460     } else {
03461       (object_->*member_)(a1,a2);
03462       //  zero out the pointer to ensure segfault if used again
03463       member_ = NULL;
03464       delete this;
03465     }
03466   }
03467 };
03468 
03469 #ifndef SWIG
03470 template <class T1, class T2, class R, class A1, class A2>
03471 inline typename _TessMemberResultCallback_0_2<true,R,T1,A1,A2>::base*
03472 NewTessCallback(
03473      T1* obj, R (T2::*member)(A1,A2) ) {
03474   return new _TessMemberResultCallback_0_2<true,R,T1,A1,A2>(
03475       obj, member);
03476 }
03477 #endif
03478 
03479 #ifndef SWIG
03480 template <class T1, class T2, class R, class A1, class A2>
03481 inline typename _TessMemberResultCallback_0_2<false,R,T1,A1,A2>::base*
03482 NewPermanentTessCallback(
03483      T1* obj, R (T2::*member)(A1,A2) ) {
03484   return new _TessMemberResultCallback_0_2<false,R,T1,A1,A2>(
03485       obj, member);
03486 }
03487 #endif
03488 
03489 template <bool del, class R, class A1, class A2>
03490 class _TessFunctionResultCallback_0_2 : public TessResultCallback2<R,A1,A2> {
03491  public:
03492   typedef TessResultCallback2<R,A1,A2> base;
03493   typedef R (*FunctionSignature)(A1,A2);
03494 
03495  private:
03496   FunctionSignature function_;
03497 
03498  public:
03499   inline _TessFunctionResultCallback_0_2(
03500       FunctionSignature function)
03501     : function_(function) {
03502   }
03503 
03504   virtual R Run(A1 a1,A2 a2) {
03505     if (!del) {
03506       R result = (*function_)(a1,a2);
03507       return result;
03508     } else {
03509       R result = (*function_)(a1,a2);
03510       //  zero out the pointer to ensure segfault if used again
03511       function_ = NULL;
03512       delete this;
03513       return result;
03514     }
03515   }
03516 };
03517 
03518 template <bool del, class A1, class A2>
03519 class _TessFunctionResultCallback_0_2<del, void, A1, A2>
03520   : public TessCallback2<A1,A2> {
03521  public:
03522   typedef TessCallback2<A1,A2> base;
03523   typedef void (*FunctionSignature)(A1,A2);
03524 
03525  private:
03526   FunctionSignature function_;
03527 
03528  public:
03529   inline _TessFunctionResultCallback_0_2(
03530       FunctionSignature function)
03531     : function_(function) {
03532   }
03533 
03534   virtual void Run(A1 a1,A2 a2) {
03535     if (!del) {
03536       (*function_)(a1,a2);
03537     } else {
03538       (*function_)(a1,a2);
03539       //  zero out the pointer to ensure segfault if used again
03540       function_ = NULL;
03541       delete this;
03542     }
03543   }
03544 };
03545 
03546 template <class R, class A1, class A2>
03547 inline typename _TessFunctionResultCallback_0_2<true,R,A1,A2>::base*
03548 NewTessCallback(R (*function)(A1,A2)) {
03549   return new _TessFunctionResultCallback_0_2<true,R,A1,A2>(function);
03550 }
03551 
03552 template <class R, class A1, class A2>
03553 inline typename _TessFunctionResultCallback_0_2<false,R,A1,A2>::base*
03554 NewPermanentTessCallback(R (*function)(A1,A2)) {
03555   return new _TessFunctionResultCallback_0_2<false,R,A1,A2>(function);
03556 }
03557 
03558 template <bool del, class R, class T, class P1, class A1, class A2>
03559 class _ConstTessMemberResultCallback_1_2 : public TessResultCallback2<R,A1,A2> {
03560  public:
03561   typedef TessResultCallback2<R,A1,A2> base;
03562   typedef R (T::*MemberSignature)(P1,A1,A2) const;
03563 
03564  private:
03565   const T* object_;
03566   MemberSignature member_;
03567   typename remove_reference<P1>::type p1_;
03568 
03569  public:
03570   inline _ConstTessMemberResultCallback_1_2(const T* object, MemberSignature member, P1 p1)
03571     : object_(object),
03572       member_(member),      p1_(p1) { }
03573 
03574   virtual R Run(A1 a1,A2 a2) {
03575     if (!del) {
03576       R result = (object_->*member_)(p1_,a1,a2);
03577       return result;
03578     } else {
03579       R result = (object_->*member_)(p1_,a1,a2);
03580       //  zero out the pointer to ensure segfault if used again
03581       member_ = NULL;
03582       delete this;
03583       return result;
03584     }
03585   }
03586 };
03587 
03588 template <bool del, class T, class P1, class A1, class A2>
03589 class _ConstTessMemberResultCallback_1_2<del, void, T, P1, A1, A2> : public TessCallback2<A1,A2> {
03590  public:
03591   typedef TessCallback2<A1,A2> base;
03592   typedef void (T::*MemberSignature)(P1,A1,A2) const;
03593 
03594  private:
03595   const T* object_;
03596   MemberSignature member_;
03597   typename remove_reference<P1>::type p1_;
03598 
03599  public:
03600   inline _ConstTessMemberResultCallback_1_2(const T* object, MemberSignature member, P1 p1)
03601     : object_(object),
03602       member_(member),      p1_(p1) { }
03603 
03604   virtual void Run(A1 a1,A2 a2) {
03605     if (!del) {
03606       (object_->*member_)(p1_,a1,a2);
03607     } else {
03608       (object_->*member_)(p1_,a1,a2);
03609       //  zero out the pointer to ensure segfault if used again
03610       member_ = NULL;
03611       delete this;
03612     }
03613   }
03614 };
03615 
03616 #ifndef SWIG
03617 template <class T1, class T2, class R, class P1, class A1, class A2>
03618 inline typename _ConstTessMemberResultCallback_1_2<true,R,T1,P1,A1,A2>::base*
03619 NewTessCallback(const T1* obj, R (T2::*member)(P1,A1,A2) const, typename Identity<P1>::type p1) {
03620   return new _ConstTessMemberResultCallback_1_2<true,R,T1,P1,A1,A2>(obj, member, p1);
03621 }
03622 #endif
03623 
03624 #ifndef SWIG
03625 template <class T1, class T2, class R, class P1, class A1, class A2>
03626 inline typename _ConstTessMemberResultCallback_1_2<false,R,T1,P1,A1,A2>::base*
03627 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,A1,A2) const, typename Identity<P1>::type p1) {
03628   return new _ConstTessMemberResultCallback_1_2<false,R,T1,P1,A1,A2>(obj, member, p1);
03629 }
03630 #endif
03631 
03632 template <bool del, class R, class T, class P1, class A1, class A2>
03633 class _TessMemberResultCallback_1_2 : public TessResultCallback2<R,A1,A2> {
03634  public:
03635   typedef TessResultCallback2<R,A1,A2> base;
03636   typedef R (T::*MemberSignature)(P1,A1,A2) ;
03637 
03638  private:
03639    T* object_;
03640   MemberSignature member_;
03641   typename remove_reference<P1>::type p1_;
03642 
03643  public:
03644   inline _TessMemberResultCallback_1_2( T* object, MemberSignature member, P1 p1)
03645     : object_(object),
03646       member_(member),      p1_(p1) { }
03647 
03648   virtual R Run(A1 a1,A2 a2) {
03649     if (!del) {
03650       R result = (object_->*member_)(p1_,a1,a2);
03651       return result;
03652     } else {
03653       R result = (object_->*member_)(p1_,a1,a2);
03654       //  zero out the pointer to ensure segfault if used again
03655       member_ = NULL;
03656       delete this;
03657       return result;
03658     }
03659   }
03660 };
03661 
03662 template <bool del, class T, class P1, class A1, class A2>
03663 class _TessMemberResultCallback_1_2<del, void, T, P1, A1, A2> : public TessCallback2<A1,A2> {
03664  public:
03665   typedef TessCallback2<A1,A2> base;
03666   typedef void (T::*MemberSignature)(P1,A1,A2) ;
03667 
03668  private:
03669    T* object_;
03670   MemberSignature member_;
03671   typename remove_reference<P1>::type p1_;
03672 
03673  public:
03674   inline _TessMemberResultCallback_1_2( T* object, MemberSignature member, P1 p1)
03675     : object_(object),
03676       member_(member),      p1_(p1) { }
03677 
03678   virtual void Run(A1 a1,A2 a2) {
03679     if (!del) {
03680       (object_->*member_)(p1_,a1,a2);
03681     } else {
03682       (object_->*member_)(p1_,a1,a2);
03683       //  zero out the pointer to ensure segfault if used again
03684       member_ = NULL;
03685       delete this;
03686     }
03687   }
03688 };
03689 
03690 #ifndef SWIG
03691 template <class T1, class T2, class R, class P1, class A1, class A2>
03692 inline typename _TessMemberResultCallback_1_2<true,R,T1,P1,A1,A2>::base*
03693 NewTessCallback( T1* obj, R (T2::*member)(P1,A1,A2) , typename Identity<P1>::type p1) {
03694   return new _TessMemberResultCallback_1_2<true,R,T1,P1,A1,A2>(obj, member, p1);
03695 }
03696 #endif
03697 
03698 #ifndef SWIG
03699 template <class T1, class T2, class R, class P1, class A1, class A2>
03700 inline typename _TessMemberResultCallback_1_2<false,R,T1,P1,A1,A2>::base*
03701 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,A1,A2) , typename Identity<P1>::type p1) {
03702   return new _TessMemberResultCallback_1_2<false,R,T1,P1,A1,A2>(obj, member, p1);
03703 }
03704 #endif
03705 
03706 template <bool del, class R, class P1, class A1, class A2>
03707 class _TessFunctionResultCallback_1_2 : public TessResultCallback2<R,A1,A2> {
03708  public:
03709   typedef TessResultCallback2<R,A1,A2> base;
03710   typedef R (*FunctionSignature)(P1,A1,A2);
03711 
03712  private:
03713   FunctionSignature function_;
03714   typename remove_reference<P1>::type p1_;
03715 
03716  public:
03717   inline _TessFunctionResultCallback_1_2(FunctionSignature function, P1 p1)
03718     : function_(function),      p1_(p1) { }
03719 
03720   virtual R Run(A1 a1,A2 a2) {
03721     if (!del) {
03722       R result = (*function_)(p1_,a1,a2);
03723       return result;
03724     } else {
03725       R result = (*function_)(p1_,a1,a2);
03726       //  zero out the pointer to ensure segfault if used again
03727       function_ = NULL;
03728       delete this;
03729       return result;
03730     }
03731   }
03732 };
03733 
03734 template <bool del, class P1, class A1, class A2>
03735 class _TessFunctionResultCallback_1_2<del, void, P1, A1, A2> : public TessCallback2<A1,A2> {
03736  public:
03737   typedef TessCallback2<A1,A2> base;
03738   typedef void (*FunctionSignature)(P1,A1,A2);
03739 
03740  private:
03741   FunctionSignature function_;
03742   typename remove_reference<P1>::type p1_;
03743 
03744  public:
03745   inline _TessFunctionResultCallback_1_2(FunctionSignature function, P1 p1)
03746     : function_(function),      p1_(p1) { }
03747 
03748   virtual void Run(A1 a1,A2 a2) {
03749     if (!del) {
03750       (*function_)(p1_,a1,a2);
03751     } else {
03752       (*function_)(p1_,a1,a2);
03753       //  zero out the pointer to ensure segfault if used again
03754       function_ = NULL;
03755       delete this;
03756     }
03757   }
03758 };
03759 
03760 template <class R, class P1, class A1, class A2>
03761 inline typename _TessFunctionResultCallback_1_2<true,R,P1,A1,A2>::base*
03762 NewTessCallback(R (*function)(P1,A1,A2), typename Identity<P1>::type p1) {
03763   return new _TessFunctionResultCallback_1_2<true,R,P1,A1,A2>(function, p1);
03764 }
03765 
03766 template <class R, class P1, class A1, class A2>
03767 inline typename _TessFunctionResultCallback_1_2<false,R,P1,A1,A2>::base*
03768 NewPermanentTessCallback(R (*function)(P1,A1,A2), typename Identity<P1>::type p1) {
03769   return new _TessFunctionResultCallback_1_2<false,R,P1,A1,A2>(function, p1);
03770 }
03771 
03772 template <bool del, class R, class T, class P1, class P2, class A1, class A2>
03773 class _ConstTessMemberResultCallback_2_2 : public TessResultCallback2<R,A1,A2> {
03774  public:
03775   typedef TessResultCallback2<R,A1,A2> base;
03776   typedef R (T::*MemberSignature)(P1,P2,A1,A2) const;
03777 
03778  private:
03779   const T* object_;
03780   MemberSignature member_;
03781   typename remove_reference<P1>::type p1_;
03782   typename remove_reference<P2>::type p2_;
03783 
03784  public:
03785   inline _ConstTessMemberResultCallback_2_2(const T* object, MemberSignature member, P1 p1, P2 p2)
03786     : object_(object),
03787       member_(member),      p1_(p1),      p2_(p2) { }
03788 
03789   virtual R Run(A1 a1,A2 a2) {
03790     if (!del) {
03791       R result = (object_->*member_)(p1_,p2_,a1,a2);
03792       return result;
03793     } else {
03794       R result = (object_->*member_)(p1_,p2_,a1,a2);
03795       //  zero out the pointer to ensure segfault if used again
03796       member_ = NULL;
03797       delete this;
03798       return result;
03799     }
03800   }
03801 };
03802 
03803 template <bool del, class T, class P1, class P2, class A1, class A2>
03804 class _ConstTessMemberResultCallback_2_2<del, void, T, P1, P2, A1, A2> : public TessCallback2<A1,A2> {
03805  public:
03806   typedef TessCallback2<A1,A2> base;
03807   typedef void (T::*MemberSignature)(P1,P2,A1,A2) const;
03808 
03809  private:
03810   const T* object_;
03811   MemberSignature member_;
03812   typename remove_reference<P1>::type p1_;
03813   typename remove_reference<P2>::type p2_;
03814 
03815  public:
03816   inline _ConstTessMemberResultCallback_2_2(const T* object, MemberSignature member, P1 p1, P2 p2)
03817     : object_(object),
03818       member_(member),      p1_(p1),      p2_(p2) { }
03819 
03820   virtual void Run(A1 a1,A2 a2) {
03821     if (!del) {
03822       (object_->*member_)(p1_,p2_,a1,a2);
03823     } else {
03824       (object_->*member_)(p1_,p2_,a1,a2);
03825       //  zero out the pointer to ensure segfault if used again
03826       member_ = NULL;
03827       delete this;
03828     }
03829   }
03830 };
03831 
03832 #ifndef SWIG
03833 template <class T1, class T2, class R, class P1, class P2, class A1, class A2>
03834 inline typename _ConstTessMemberResultCallback_2_2<true,R,T1,P1,P2,A1,A2>::base*
03835 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
03836   return new _ConstTessMemberResultCallback_2_2<true,R,T1,P1,P2,A1,A2>(obj, member, p1, p2);
03837 }
03838 #endif
03839 
03840 #ifndef SWIG
03841 template <class T1, class T2, class R, class P1, class P2, class A1, class A2>
03842 inline typename _ConstTessMemberResultCallback_2_2<false,R,T1,P1,P2,A1,A2>::base*
03843 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
03844   return new _ConstTessMemberResultCallback_2_2<false,R,T1,P1,P2,A1,A2>(obj, member, p1, p2);
03845 }
03846 #endif
03847 
03848 template <bool del, class R, class T, class P1, class P2, class A1, class A2>
03849 class _TessMemberResultCallback_2_2 : public TessResultCallback2<R,A1,A2> {
03850  public:
03851   typedef TessResultCallback2<R,A1,A2> base;
03852   typedef R (T::*MemberSignature)(P1,P2,A1,A2) ;
03853 
03854  private:
03855    T* object_;
03856   MemberSignature member_;
03857   typename remove_reference<P1>::type p1_;
03858   typename remove_reference<P2>::type p2_;
03859 
03860  public:
03861   inline _TessMemberResultCallback_2_2( T* object, MemberSignature member, P1 p1, P2 p2)
03862     : object_(object),
03863       member_(member),      p1_(p1),      p2_(p2) { }
03864 
03865   virtual R Run(A1 a1,A2 a2) {
03866     if (!del) {
03867       R result = (object_->*member_)(p1_,p2_,a1,a2);
03868       return result;
03869     } else {
03870       R result = (object_->*member_)(p1_,p2_,a1,a2);
03871       //  zero out the pointer to ensure segfault if used again
03872       member_ = NULL;
03873       delete this;
03874       return result;
03875     }
03876   }
03877 };
03878 
03879 template <bool del, class T, class P1, class P2, class A1, class A2>
03880 class _TessMemberResultCallback_2_2<del, void, T, P1, P2, A1, A2> : public TessCallback2<A1,A2> {
03881  public:
03882   typedef TessCallback2<A1,A2> base;
03883   typedef void (T::*MemberSignature)(P1,P2,A1,A2) ;
03884 
03885  private:
03886    T* object_;
03887   MemberSignature member_;
03888   typename remove_reference<P1>::type p1_;
03889   typename remove_reference<P2>::type p2_;
03890 
03891  public:
03892   inline _TessMemberResultCallback_2_2( T* object, MemberSignature member, P1 p1, P2 p2)
03893     : object_(object),
03894       member_(member),      p1_(p1),      p2_(p2) { }
03895 
03896   virtual void Run(A1 a1,A2 a2) {
03897     if (!del) {
03898       (object_->*member_)(p1_,p2_,a1,a2);
03899     } else {
03900       (object_->*member_)(p1_,p2_,a1,a2);
03901       //  zero out the pointer to ensure segfault if used again
03902       member_ = NULL;
03903       delete this;
03904     }
03905   }
03906 };
03907 
03908 #ifndef SWIG
03909 template <class T1, class T2, class R, class P1, class P2, class A1, class A2>
03910 inline typename _TessMemberResultCallback_2_2<true,R,T1,P1,P2,A1,A2>::base*
03911 NewTessCallback( T1* obj, R (T2::*member)(P1,P2,A1,A2) , typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
03912   return new _TessMemberResultCallback_2_2<true,R,T1,P1,P2,A1,A2>(obj, member, p1, p2);
03913 }
03914 #endif
03915 
03916 #ifndef SWIG
03917 template <class T1, class T2, class R, class P1, class P2, class A1, class A2>
03918 inline typename _TessMemberResultCallback_2_2<false,R,T1,P1,P2,A1,A2>::base*
03919 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,A1,A2) , typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
03920   return new _TessMemberResultCallback_2_2<false,R,T1,P1,P2,A1,A2>(obj, member, p1, p2);
03921 }
03922 #endif
03923 
03924 template <bool del, class R, class P1, class P2, class A1, class A2>
03925 class _TessFunctionResultCallback_2_2 : public TessResultCallback2<R,A1,A2> {
03926  public:
03927   typedef TessResultCallback2<R,A1,A2> base;
03928   typedef R (*FunctionSignature)(P1,P2,A1,A2);
03929 
03930  private:
03931   FunctionSignature function_;
03932   typename remove_reference<P1>::type p1_;
03933   typename remove_reference<P2>::type p2_;
03934 
03935  public:
03936   inline _TessFunctionResultCallback_2_2(FunctionSignature function, P1 p1, P2 p2)
03937     : function_(function),      p1_(p1),      p2_(p2) { }
03938 
03939   virtual R Run(A1 a1,A2 a2) {
03940     if (!del) {
03941       R result = (*function_)(p1_,p2_,a1,a2);
03942       return result;
03943     } else {
03944       R result = (*function_)(p1_,p2_,a1,a2);
03945       //  zero out the pointer to ensure segfault if used again
03946       function_ = NULL;
03947       delete this;
03948       return result;
03949     }
03950   }
03951 };
03952 
03953 template <bool del, class P1, class P2, class A1, class A2>
03954 class _TessFunctionResultCallback_2_2<del, void, P1, P2, A1, A2> : public TessCallback2<A1,A2> {
03955  public:
03956   typedef TessCallback2<A1,A2> base;
03957   typedef void (*FunctionSignature)(P1,P2,A1,A2);
03958 
03959  private:
03960   FunctionSignature function_;
03961   typename remove_reference<P1>::type p1_;
03962   typename remove_reference<P2>::type p2_;
03963 
03964  public:
03965   inline _TessFunctionResultCallback_2_2(FunctionSignature function, P1 p1, P2 p2)
03966     : function_(function),      p1_(p1),      p2_(p2) { }
03967 
03968   virtual void Run(A1 a1,A2 a2) {
03969     if (!del) {
03970       (*function_)(p1_,p2_,a1,a2);
03971     } else {
03972       (*function_)(p1_,p2_,a1,a2);
03973       //  zero out the pointer to ensure segfault if used again
03974       function_ = NULL;
03975       delete this;
03976     }
03977   }
03978 };
03979 
03980 template <class R, class P1, class P2, class A1, class A2>
03981 inline typename _TessFunctionResultCallback_2_2<true,R,P1,P2,A1,A2>::base*
03982 NewTessCallback(R (*function)(P1,P2,A1,A2), typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
03983   return new _TessFunctionResultCallback_2_2<true,R,P1,P2,A1,A2>(function, p1, p2);
03984 }
03985 
03986 template <class R, class P1, class P2, class A1, class A2>
03987 inline typename _TessFunctionResultCallback_2_2<false,R,P1,P2,A1,A2>::base*
03988 NewPermanentTessCallback(R (*function)(P1,P2,A1,A2), typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
03989   return new _TessFunctionResultCallback_2_2<false,R,P1,P2,A1,A2>(function, p1, p2);
03990 }
03991 
03992 template <bool del, class R, class T, class P1, class P2, class P3, class A1, class A2>
03993 class _ConstTessMemberResultCallback_3_2 : public TessResultCallback2<R,A1,A2> {
03994  public:
03995   typedef TessResultCallback2<R,A1,A2> base;
03996   typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2) const;
03997 
03998  private:
03999   const T* object_;
04000   MemberSignature member_;
04001   typename remove_reference<P1>::type p1_;
04002   typename remove_reference<P2>::type p2_;
04003   typename remove_reference<P3>::type p3_;
04004 
04005  public:
04006   inline _ConstTessMemberResultCallback_3_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
04007     : object_(object),
04008       member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }
04009 
04010   virtual R Run(A1 a1,A2 a2) {
04011     if (!del) {
04012       R result = (object_->*member_)(p1_,p2_,p3_,a1,a2);
04013       return result;
04014     } else {
04015       R result = (object_->*member_)(p1_,p2_,p3_,a1,a2);
04016       //  zero out the pointer to ensure segfault if used again
04017       member_ = NULL;
04018       delete this;
04019       return result;
04020     }
04021   }
04022 };
04023 
04024 template <bool del, class T, class P1, class P2, class P3, class A1, class A2>
04025 class _ConstTessMemberResultCallback_3_2<del, void, T, P1, P2, P3, A1, A2> : public TessCallback2<A1,A2> {
04026  public:
04027   typedef TessCallback2<A1,A2> base;
04028   typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2) const;
04029 
04030  private:
04031   const T* object_;
04032   MemberSignature member_;
04033   typename remove_reference<P1>::type p1_;
04034   typename remove_reference<P2>::type p2_;
04035   typename remove_reference<P3>::type p3_;
04036 
04037  public:
04038   inline _ConstTessMemberResultCallback_3_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
04039     : object_(object),
04040       member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }
04041 
04042   virtual void Run(A1 a1,A2 a2) {
04043     if (!del) {
04044       (object_->*member_)(p1_,p2_,p3_,a1,a2);
04045     } else {
04046       (object_->*member_)(p1_,p2_,p3_,a1,a2);
04047       //  zero out the pointer to ensure segfault if used again
04048       member_ = NULL;
04049       delete this;
04050     }
04051   }
04052 };
04053 
04054 #ifndef SWIG
04055 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2>
04056 inline typename _ConstTessMemberResultCallback_3_2<true,R,T1,P1,P2,P3,A1,A2>::base*
04057 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) {
04058   return new _ConstTessMemberResultCallback_3_2<true,R,T1,P1,P2,P3,A1,A2>(obj, member, p1, p2, p3);
04059 }
04060 #endif
04061 
04062 #ifndef SWIG
04063 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2>
04064 inline typename _ConstTessMemberResultCallback_3_2<false,R,T1,P1,P2,P3,A1,A2>::base*
04065 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) {
04066   return new _ConstTessMemberResultCallback_3_2<false,R,T1,P1,P2,P3,A1,A2>(obj, member, p1, p2, p3);
04067 }
04068 #endif
04069 
04070 template <bool del, class R, class T, class P1, class P2, class P3, class A1, class A2>
04071 class _TessMemberResultCallback_3_2 : public TessResultCallback2<R,A1,A2> {
04072  public:
04073   typedef TessResultCallback2<R,A1,A2> base;
04074   typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2) ;
04075 
04076  private:
04077    T* object_;
04078   MemberSignature member_;
04079   typename remove_reference<P1>::type p1_;
04080   typename remove_reference<P2>::type p2_;
04081   typename remove_reference<P3>::type p3_;
04082 
04083  public:
04084   inline _TessMemberResultCallback_3_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
04085     : object_(object),
04086       member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }
04087 
04088   virtual R Run(A1 a1,A2 a2) {
04089     if (!del) {
04090       R result = (object_->*member_)(p1_,p2_,p3_,a1,a2);
04091       return result;
04092     } else {
04093       R result = (object_->*member_)(p1_,p2_,p3_,a1,a2);
04094       //  zero out the pointer to ensure segfault if used again
04095       member_ = NULL;
04096       delete this;
04097       return result;
04098     }
04099   }
04100 };
04101 
04102 template <bool del, class T, class P1, class P2, class P3, class A1, class A2>
04103 class _TessMemberResultCallback_3_2<del, void, T, P1, P2, P3, A1, A2> : public TessCallback2<A1,A2> {
04104  public:
04105   typedef TessCallback2<A1,A2> base;
04106   typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2) ;
04107 
04108  private:
04109    T* object_;
04110   MemberSignature member_;
04111   typename remove_reference<P1>::type p1_;
04112   typename remove_reference<P2>::type p2_;
04113   typename remove_reference<P3>::type p3_;
04114 
04115  public:
04116   inline _TessMemberResultCallback_3_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
04117     : object_(object),
04118       member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }
04119 
04120   virtual void Run(A1 a1,A2 a2) {
04121     if (!del) {
04122       (object_->*member_)(p1_,p2_,p3_,a1,a2);
04123     } else {
04124       (object_->*member_)(p1_,p2_,p3_,a1,a2);
04125       //  zero out the pointer to ensure segfault if used again
04126       member_ = NULL;
04127       delete this;
04128     }
04129   }
04130 };
04131 
04132 #ifndef SWIG
04133 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2>
04134 inline typename _TessMemberResultCallback_3_2<true,R,T1,P1,P2,P3,A1,A2>::base*
04135 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) {
04136   return new _TessMemberResultCallback_3_2<true,R,T1,P1,P2,P3,A1,A2>(obj, member, p1, p2, p3);
04137 }
04138 #endif
04139 
04140 #ifndef SWIG
04141 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2>
04142 inline typename _TessMemberResultCallback_3_2<false,R,T1,P1,P2,P3,A1,A2>::base*
04143 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) {
04144   return new _TessMemberResultCallback_3_2<false,R,T1,P1,P2,P3,A1,A2>(obj, member, p1, p2, p3);
04145 }
04146 #endif
04147 
04148 template <bool del, class R, class P1, class P2, class P3, class A1, class A2>
04149 class _TessFunctionResultCallback_3_2 : public TessResultCallback2<R,A1,A2> {
04150  public:
04151   typedef TessResultCallback2<R,A1,A2> base;
04152   typedef R (*FunctionSignature)(P1,P2,P3,A1,A2);
04153 
04154  private:
04155   FunctionSignature function_;
04156   typename remove_reference<P1>::type p1_;
04157   typename remove_reference<P2>::type p2_;
04158   typename remove_reference<P3>::type p3_;
04159 
04160  public:
04161   inline _TessFunctionResultCallback_3_2(FunctionSignature function, P1 p1, P2 p2, P3 p3)
04162     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3) { }
04163 
04164   virtual R Run(A1 a1,A2 a2) {
04165     if (!del) {
04166       R result = (*function_)(p1_,p2_,p3_,a1,a2);
04167       return result;
04168     } else {
04169       R result = (*function_)(p1_,p2_,p3_,a1,a2);
04170       //  zero out the pointer to ensure segfault if used again
04171       function_ = NULL;
04172       delete this;
04173       return result;
04174     }
04175   }
04176 };
04177 
04178 template <bool del, class P1, class P2, class P3, class A1, class A2>
04179 class _TessFunctionResultCallback_3_2<del, void, P1, P2, P3, A1, A2> : public TessCallback2<A1,A2> {
04180  public:
04181   typedef TessCallback2<A1,A2> base;
04182   typedef void (*FunctionSignature)(P1,P2,P3,A1,A2);
04183 
04184  private:
04185   FunctionSignature function_;
04186   typename remove_reference<P1>::type p1_;
04187   typename remove_reference<P2>::type p2_;
04188   typename remove_reference<P3>::type p3_;
04189 
04190  public:
04191   inline _TessFunctionResultCallback_3_2(FunctionSignature function, P1 p1, P2 p2, P3 p3)
04192     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3) { }
04193 
04194   virtual void Run(A1 a1,A2 a2) {
04195     if (!del) {
04196       (*function_)(p1_,p2_,p3_,a1,a2);
04197     } else {
04198       (*function_)(p1_,p2_,p3_,a1,a2);
04199       //  zero out the pointer to ensure segfault if used again
04200       function_ = NULL;
04201       delete this;
04202     }
04203   }
04204 };
04205 
04206 template <class R, class P1, class P2, class P3, class A1, class A2>
04207 inline typename _TessFunctionResultCallback_3_2<true,R,P1,P2,P3,A1,A2>::base*
04208 NewTessCallback(R (*function)(P1,P2,P3,A1,A2), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
04209   return new _TessFunctionResultCallback_3_2<true,R,P1,P2,P3,A1,A2>(function, p1, p2, p3);
04210 }
04211 
04212 template <class R, class P1, class P2, class P3, class A1, class A2>
04213 inline typename _TessFunctionResultCallback_3_2<false,R,P1,P2,P3,A1,A2>::base*
04214 NewPermanentTessCallback(R (*function)(P1,P2,P3,A1,A2), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
04215   return new _TessFunctionResultCallback_3_2<false,R,P1,P2,P3,A1,A2>(function, p1, p2, p3);
04216 }
04217 
04218 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class A1, class A2>
04219 class _ConstTessMemberResultCallback_4_2 : public TessResultCallback2<R,A1,A2> {
04220  public:
04221   typedef TessResultCallback2<R,A1,A2> base;
04222   typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2) const;
04223 
04224  private:
04225   const T* object_;
04226   MemberSignature member_;
04227   typename remove_reference<P1>::type p1_;
04228   typename remove_reference<P2>::type p2_;
04229   typename remove_reference<P3>::type p3_;
04230   typename remove_reference<P4>::type p4_;
04231 
04232  public:
04233   inline _ConstTessMemberResultCallback_4_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
04234     : object_(object),
04235       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
04236 
04237   virtual R Run(A1 a1,A2 a2) {
04238     if (!del) {
04239       R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2);
04240       return result;
04241     } else {
04242       R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2);
04243       //  zero out the pointer to ensure segfault if used again
04244       member_ = NULL;
04245       delete this;
04246       return result;
04247     }
04248   }
04249 };
04250 
04251 template <bool del, class T, class P1, class P2, class P3, class P4, class A1, class A2>
04252 class _ConstTessMemberResultCallback_4_2<del, void, T, P1, P2, P3, P4, A1, A2> : public TessCallback2<A1,A2> {
04253  public:
04254   typedef TessCallback2<A1,A2> base;
04255   typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2) const;
04256 
04257  private:
04258   const T* object_;
04259   MemberSignature member_;
04260   typename remove_reference<P1>::type p1_;
04261   typename remove_reference<P2>::type p2_;
04262   typename remove_reference<P3>::type p3_;
04263   typename remove_reference<P4>::type p4_;
04264 
04265  public:
04266   inline _ConstTessMemberResultCallback_4_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
04267     : object_(object),
04268       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
04269 
04270   virtual void Run(A1 a1,A2 a2) {
04271     if (!del) {
04272       (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2);
04273     } else {
04274       (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2);
04275       //  zero out the pointer to ensure segfault if used again
04276       member_ = NULL;
04277       delete this;
04278     }
04279   }
04280 };
04281 
04282 #ifndef SWIG
04283 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2>
04284 inline typename _ConstTessMemberResultCallback_4_2<true,R,T1,P1,P2,P3,P4,A1,A2>::base*
04285 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) {
04286   return new _ConstTessMemberResultCallback_4_2<true,R,T1,P1,P2,P3,P4,A1,A2>(obj, member, p1, p2, p3, p4);
04287 }
04288 #endif
04289 
04290 #ifndef SWIG
04291 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2>
04292 inline typename _ConstTessMemberResultCallback_4_2<false,R,T1,P1,P2,P3,P4,A1,A2>::base*
04293 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) {
04294   return new _ConstTessMemberResultCallback_4_2<false,R,T1,P1,P2,P3,P4,A1,A2>(obj, member, p1, p2, p3, p4);
04295 }
04296 #endif
04297 
04298 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class A1, class A2>
04299 class _TessMemberResultCallback_4_2 : public TessResultCallback2<R,A1,A2> {
04300  public:
04301   typedef TessResultCallback2<R,A1,A2> base;
04302   typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2) ;
04303 
04304  private:
04305    T* object_;
04306   MemberSignature member_;
04307   typename remove_reference<P1>::type p1_;
04308   typename remove_reference<P2>::type p2_;
04309   typename remove_reference<P3>::type p3_;
04310   typename remove_reference<P4>::type p4_;
04311 
04312  public:
04313   inline _TessMemberResultCallback_4_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
04314     : object_(object),
04315       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
04316 
04317   virtual R Run(A1 a1,A2 a2) {
04318     if (!del) {
04319       R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2);
04320       return result;
04321     } else {
04322       R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2);
04323       //  zero out the pointer to ensure segfault if used again
04324       member_ = NULL;
04325       delete this;
04326       return result;
04327     }
04328   }
04329 };
04330 
04331 template <bool del, class T, class P1, class P2, class P3, class P4, class A1, class A2>
04332 class _TessMemberResultCallback_4_2<del, void, T, P1, P2, P3, P4, A1, A2> : public TessCallback2<A1,A2> {
04333  public:
04334   typedef TessCallback2<A1,A2> base;
04335   typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2) ;
04336 
04337  private:
04338    T* object_;
04339   MemberSignature member_;
04340   typename remove_reference<P1>::type p1_;
04341   typename remove_reference<P2>::type p2_;
04342   typename remove_reference<P3>::type p3_;
04343   typename remove_reference<P4>::type p4_;
04344 
04345  public:
04346   inline _TessMemberResultCallback_4_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
04347     : object_(object),
04348       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
04349 
04350   virtual void Run(A1 a1,A2 a2) {
04351     if (!del) {
04352       (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2);
04353     } else {
04354       (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2);
04355       //  zero out the pointer to ensure segfault if used again
04356       member_ = NULL;
04357       delete this;
04358     }
04359   }
04360 };
04361 
04362 #ifndef SWIG
04363 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2>
04364 inline typename _TessMemberResultCallback_4_2<true,R,T1,P1,P2,P3,P4,A1,A2>::base*
04365 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) {
04366   return new _TessMemberResultCallback_4_2<true,R,T1,P1,P2,P3,P4,A1,A2>(obj, member, p1, p2, p3, p4);
04367 }
04368 #endif
04369 
04370 #ifndef SWIG
04371 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2>
04372 inline typename _TessMemberResultCallback_4_2<false,R,T1,P1,P2,P3,P4,A1,A2>::base*
04373 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) {
04374   return new _TessMemberResultCallback_4_2<false,R,T1,P1,P2,P3,P4,A1,A2>(obj, member, p1, p2, p3, p4);
04375 }
04376 #endif
04377 
04378 template <bool del, class R, class P1, class P2, class P3, class P4, class A1, class A2>
04379 class _TessFunctionResultCallback_4_2 : public TessResultCallback2<R,A1,A2> {
04380  public:
04381   typedef TessResultCallback2<R,A1,A2> base;
04382   typedef R (*FunctionSignature)(P1,P2,P3,P4,A1,A2);
04383 
04384  private:
04385   FunctionSignature function_;
04386   typename remove_reference<P1>::type p1_;
04387   typename remove_reference<P2>::type p2_;
04388   typename remove_reference<P3>::type p3_;
04389   typename remove_reference<P4>::type p4_;
04390 
04391  public:
04392   inline _TessFunctionResultCallback_4_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
04393     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
04394 
04395   virtual R Run(A1 a1,A2 a2) {
04396     if (!del) {
04397       R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2);
04398       return result;
04399     } else {
04400       R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2);
04401       //  zero out the pointer to ensure segfault if used again
04402       function_ = NULL;
04403       delete this;
04404       return result;
04405     }
04406   }
04407 };
04408 
04409 template <bool del, class P1, class P2, class P3, class P4, class A1, class A2>
04410 class _TessFunctionResultCallback_4_2<del, void, P1, P2, P3, P4, A1, A2> : public TessCallback2<A1,A2> {
04411  public:
04412   typedef TessCallback2<A1,A2> base;
04413   typedef void (*FunctionSignature)(P1,P2,P3,P4,A1,A2);
04414 
04415  private:
04416   FunctionSignature function_;
04417   typename remove_reference<P1>::type p1_;
04418   typename remove_reference<P2>::type p2_;
04419   typename remove_reference<P3>::type p3_;
04420   typename remove_reference<P4>::type p4_;
04421 
04422  public:
04423   inline _TessFunctionResultCallback_4_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
04424     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
04425 
04426   virtual void Run(A1 a1,A2 a2) {
04427     if (!del) {
04428       (*function_)(p1_,p2_,p3_,p4_,a1,a2);
04429     } else {
04430       (*function_)(p1_,p2_,p3_,p4_,a1,a2);
04431       //  zero out the pointer to ensure segfault if used again
04432       function_ = NULL;
04433       delete this;
04434     }
04435   }
04436 };
04437 
04438 template <class R, class P1, class P2, class P3, class P4, class A1, class A2>
04439 inline typename _TessFunctionResultCallback_4_2<true,R,P1,P2,P3,P4,A1,A2>::base*
04440 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) {
04441   return new _TessFunctionResultCallback_4_2<true,R,P1,P2,P3,P4,A1,A2>(function, p1, p2, p3, p4);
04442 }
04443 
04444 template <class R, class P1, class P2, class P3, class P4, class A1, class A2>
04445 inline typename _TessFunctionResultCallback_4_2<false,R,P1,P2,P3,P4,A1,A2>::base*
04446 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) {
04447   return new _TessFunctionResultCallback_4_2<false,R,P1,P2,P3,P4,A1,A2>(function, p1, p2, p3, p4);
04448 }
04449 
04450 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
04451 class _ConstTessMemberResultCallback_5_2 : public TessResultCallback2<R,A1,A2> {
04452  public:
04453   typedef TessResultCallback2<R,A1,A2> base;
04454   typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2) const;
04455 
04456  private:
04457   const T* object_;
04458   MemberSignature member_;
04459   typename remove_reference<P1>::type p1_;
04460   typename remove_reference<P2>::type p2_;
04461   typename remove_reference<P3>::type p3_;
04462   typename remove_reference<P4>::type p4_;
04463   typename remove_reference<P5>::type p5_;
04464 
04465  public:
04466   inline _ConstTessMemberResultCallback_5_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
04467     : object_(object),
04468       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
04469 
04470   virtual R Run(A1 a1,A2 a2) {
04471     if (!del) {
04472       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
04473       return result;
04474     } else {
04475       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
04476       //  zero out the pointer to ensure segfault if used again
04477       member_ = NULL;
04478       delete this;
04479       return result;
04480     }
04481   }
04482 };
04483 
04484 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
04485 class _ConstTessMemberResultCallback_5_2<del, void, T, P1, P2, P3, P4, P5, A1, A2> : public TessCallback2<A1,A2> {
04486  public:
04487   typedef TessCallback2<A1,A2> base;
04488   typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2) const;
04489 
04490  private:
04491   const T* object_;
04492   MemberSignature member_;
04493   typename remove_reference<P1>::type p1_;
04494   typename remove_reference<P2>::type p2_;
04495   typename remove_reference<P3>::type p3_;
04496   typename remove_reference<P4>::type p4_;
04497   typename remove_reference<P5>::type p5_;
04498 
04499  public:
04500   inline _ConstTessMemberResultCallback_5_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
04501     : object_(object),
04502       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
04503 
04504   virtual void Run(A1 a1,A2 a2) {
04505     if (!del) {
04506       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
04507     } else {
04508       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
04509       //  zero out the pointer to ensure segfault if used again
04510       member_ = NULL;
04511       delete this;
04512     }
04513   }
04514 };
04515 
04516 #ifndef SWIG
04517 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
04518 inline typename _ConstTessMemberResultCallback_5_2<true,R,T1,P1,P2,P3,P4,P5,A1,A2>::base*
04519 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) {
04520   return new _ConstTessMemberResultCallback_5_2<true,R,T1,P1,P2,P3,P4,P5,A1,A2>(obj, member, p1, p2, p3, p4, p5);
04521 }
04522 #endif
04523 
04524 #ifndef SWIG
04525 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
04526 inline typename _ConstTessMemberResultCallback_5_2<false,R,T1,P1,P2,P3,P4,P5,A1,A2>::base*
04527 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) {
04528   return new _ConstTessMemberResultCallback_5_2<false,R,T1,P1,P2,P3,P4,P5,A1,A2>(obj, member, p1, p2, p3, p4, p5);
04529 }
04530 #endif
04531 
04532 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
04533 class _TessMemberResultCallback_5_2 : public TessResultCallback2<R,A1,A2> {
04534  public:
04535   typedef TessResultCallback2<R,A1,A2> base;
04536   typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2) ;
04537 
04538  private:
04539    T* object_;
04540   MemberSignature member_;
04541   typename remove_reference<P1>::type p1_;
04542   typename remove_reference<P2>::type p2_;
04543   typename remove_reference<P3>::type p3_;
04544   typename remove_reference<P4>::type p4_;
04545   typename remove_reference<P5>::type p5_;
04546 
04547  public:
04548   inline _TessMemberResultCallback_5_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
04549     : object_(object),
04550       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
04551 
04552   virtual R Run(A1 a1,A2 a2) {
04553     if (!del) {
04554       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
04555       return result;
04556     } else {
04557       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
04558       //  zero out the pointer to ensure segfault if used again
04559       member_ = NULL;
04560       delete this;
04561       return result;
04562     }
04563   }
04564 };
04565 
04566 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
04567 class _TessMemberResultCallback_5_2<del, void, T, P1, P2, P3, P4, P5, A1, A2> : public TessCallback2<A1,A2> {
04568  public:
04569   typedef TessCallback2<A1,A2> base;
04570   typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2) ;
04571 
04572  private:
04573    T* object_;
04574   MemberSignature member_;
04575   typename remove_reference<P1>::type p1_;
04576   typename remove_reference<P2>::type p2_;
04577   typename remove_reference<P3>::type p3_;
04578   typename remove_reference<P4>::type p4_;
04579   typename remove_reference<P5>::type p5_;
04580 
04581  public:
04582   inline _TessMemberResultCallback_5_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
04583     : object_(object),
04584       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
04585 
04586   virtual void Run(A1 a1,A2 a2) {
04587     if (!del) {
04588       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
04589     } else {
04590       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
04591       //  zero out the pointer to ensure segfault if used again
04592       member_ = NULL;
04593       delete this;
04594     }
04595   }
04596 };
04597 
04598 #ifndef SWIG
04599 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
04600 inline typename _TessMemberResultCallback_5_2<true,R,T1,P1,P2,P3,P4,P5,A1,A2>::base*
04601 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) {
04602   return new _TessMemberResultCallback_5_2<true,R,T1,P1,P2,P3,P4,P5,A1,A2>(obj, member, p1, p2, p3, p4, p5);
04603 }
04604 #endif
04605 
04606 #ifndef SWIG
04607 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
04608 inline typename _TessMemberResultCallback_5_2<false,R,T1,P1,P2,P3,P4,P5,A1,A2>::base*
04609 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) {
04610   return new _TessMemberResultCallback_5_2<false,R,T1,P1,P2,P3,P4,P5,A1,A2>(obj, member, p1, p2, p3, p4, p5);
04611 }
04612 #endif
04613 
04614 template <bool del, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
04615 class _TessFunctionResultCallback_5_2 : public TessResultCallback2<R,A1,A2> {
04616  public:
04617   typedef TessResultCallback2<R,A1,A2> base;
04618   typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2);
04619 
04620  private:
04621   FunctionSignature function_;
04622   typename remove_reference<P1>::type p1_;
04623   typename remove_reference<P2>::type p2_;
04624   typename remove_reference<P3>::type p3_;
04625   typename remove_reference<P4>::type p4_;
04626   typename remove_reference<P5>::type p5_;
04627 
04628  public:
04629   inline _TessFunctionResultCallback_5_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
04630     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
04631 
04632   virtual R Run(A1 a1,A2 a2) {
04633     if (!del) {
04634       R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
04635       return result;
04636     } else {
04637       R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
04638       //  zero out the pointer to ensure segfault if used again
04639       function_ = NULL;
04640       delete this;
04641       return result;
04642     }
04643   }
04644 };
04645 
04646 template <bool del, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
04647 class _TessFunctionResultCallback_5_2<del, void, P1, P2, P3, P4, P5, A1, A2> : public TessCallback2<A1,A2> {
04648  public:
04649   typedef TessCallback2<A1,A2> base;
04650   typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2);
04651 
04652  private:
04653   FunctionSignature function_;
04654   typename remove_reference<P1>::type p1_;
04655   typename remove_reference<P2>::type p2_;
04656   typename remove_reference<P3>::type p3_;
04657   typename remove_reference<P4>::type p4_;
04658   typename remove_reference<P5>::type p5_;
04659 
04660  public:
04661   inline _TessFunctionResultCallback_5_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
04662     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
04663 
04664   virtual void Run(A1 a1,A2 a2) {
04665     if (!del) {
04666       (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
04667     } else {
04668       (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
04669       //  zero out the pointer to ensure segfault if used again
04670       function_ = NULL;
04671       delete this;
04672     }
04673   }
04674 };
04675 
04676 template <class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
04677 inline typename _TessFunctionResultCallback_5_2<true,R,P1,P2,P3,P4,P5,A1,A2>::base*
04678 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) {
04679   return new _TessFunctionResultCallback_5_2<true,R,P1,P2,P3,P4,P5,A1,A2>(function, p1, p2, p3, p4, p5);
04680 }
04681 
04682 template <class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
04683 inline typename _TessFunctionResultCallback_5_2<false,R,P1,P2,P3,P4,P5,A1,A2>::base*
04684 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) {
04685   return new _TessFunctionResultCallback_5_2<false,R,P1,P2,P3,P4,P5,A1,A2>(function, p1, p2, p3, p4, p5);
04686 }
04687 
04688 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
04689 class _ConstTessMemberResultCallback_6_2 : public TessResultCallback2<R,A1,A2> {
04690  public:
04691   typedef TessResultCallback2<R,A1,A2> base;
04692   typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2) const;
04693 
04694  private:
04695   const T* object_;
04696   MemberSignature member_;
04697   typename remove_reference<P1>::type p1_;
04698   typename remove_reference<P2>::type p2_;
04699   typename remove_reference<P3>::type p3_;
04700   typename remove_reference<P4>::type p4_;
04701   typename remove_reference<P5>::type p5_;
04702   typename remove_reference<P6>::type p6_;
04703 
04704  public:
04705   inline _ConstTessMemberResultCallback_6_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
04706     : object_(object),
04707       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
04708 
04709   virtual R Run(A1 a1,A2 a2) {
04710     if (!del) {
04711       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
04712       return result;
04713     } else {
04714       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
04715       //  zero out the pointer to ensure segfault if used again
04716       member_ = NULL;
04717       delete this;
04718       return result;
04719     }
04720   }
04721 };
04722 
04723 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
04724 class _ConstTessMemberResultCallback_6_2<del, void, T, P1, P2, P3, P4, P5, P6, A1, A2> : public TessCallback2<A1,A2> {
04725  public:
04726   typedef TessCallback2<A1,A2> base;
04727   typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2) const;
04728 
04729  private:
04730   const T* object_;
04731   MemberSignature member_;
04732   typename remove_reference<P1>::type p1_;
04733   typename remove_reference<P2>::type p2_;
04734   typename remove_reference<P3>::type p3_;
04735   typename remove_reference<P4>::type p4_;
04736   typename remove_reference<P5>::type p5_;
04737   typename remove_reference<P6>::type p6_;
04738 
04739  public:
04740   inline _ConstTessMemberResultCallback_6_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
04741     : object_(object),
04742       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
04743 
04744   virtual void Run(A1 a1,A2 a2) {
04745     if (!del) {
04746       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
04747     } else {
04748       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
04749       //  zero out the pointer to ensure segfault if used again
04750       member_ = NULL;
04751       delete this;
04752     }
04753   }
04754 };
04755 
04756 #ifndef SWIG
04757 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
04758 inline typename _ConstTessMemberResultCallback_6_2<true,R,T1,P1,P2,P3,P4,P5,P6,A1,A2>::base*
04759 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) {
04760   return new _ConstTessMemberResultCallback_6_2<true,R,T1,P1,P2,P3,P4,P5,P6,A1,A2>(obj, member, p1, p2, p3, p4, p5, p6);
04761 }
04762 #endif
04763 
04764 #ifndef SWIG
04765 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
04766 inline typename _ConstTessMemberResultCallback_6_2<false,R,T1,P1,P2,P3,P4,P5,P6,A1,A2>::base*
04767 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) {
04768   return new _ConstTessMemberResultCallback_6_2<false,R,T1,P1,P2,P3,P4,P5,P6,A1,A2>(obj, member, p1, p2, p3, p4, p5, p6);
04769 }
04770 #endif
04771 
04772 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
04773 class _TessMemberResultCallback_6_2 : public TessResultCallback2<R,A1,A2> {
04774  public:
04775   typedef TessResultCallback2<R,A1,A2> base;
04776   typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2) ;
04777 
04778  private:
04779    T* object_;
04780   MemberSignature member_;
04781   typename remove_reference<P1>::type p1_;
04782   typename remove_reference<P2>::type p2_;
04783   typename remove_reference<P3>::type p3_;
04784   typename remove_reference<P4>::type p4_;
04785   typename remove_reference<P5>::type p5_;
04786   typename remove_reference<P6>::type p6_;
04787 
04788  public:
04789   inline _TessMemberResultCallback_6_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
04790     : object_(object),
04791       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
04792 
04793   virtual R Run(A1 a1,A2 a2) {
04794     if (!del) {
04795       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
04796       return result;
04797     } else {
04798       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
04799       //  zero out the pointer to ensure segfault if used again
04800       member_ = NULL;
04801       delete this;
04802       return result;
04803     }
04804   }
04805 };
04806 
04807 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
04808 class _TessMemberResultCallback_6_2<del, void, T, P1, P2, P3, P4, P5, P6, A1, A2> : public TessCallback2<A1,A2> {
04809  public:
04810   typedef TessCallback2<A1,A2> base;
04811   typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2) ;
04812 
04813  private:
04814    T* object_;
04815   MemberSignature member_;
04816   typename remove_reference<P1>::type p1_;
04817   typename remove_reference<P2>::type p2_;
04818   typename remove_reference<P3>::type p3_;
04819   typename remove_reference<P4>::type p4_;
04820   typename remove_reference<P5>::type p5_;
04821   typename remove_reference<P6>::type p6_;
04822 
04823  public:
04824   inline _TessMemberResultCallback_6_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
04825     : object_(object),
04826       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
04827 
04828   virtual void Run(A1 a1,A2 a2) {
04829     if (!del) {
04830       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
04831     } else {
04832       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
04833       //  zero out the pointer to ensure segfault if used again
04834       member_ = NULL;
04835       delete this;
04836     }
04837   }
04838 };
04839 
04840 #ifndef SWIG
04841 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
04842 inline typename _TessMemberResultCallback_6_2<true,R,T1,P1,P2,P3,P4,P5,P6,A1,A2>::base*
04843 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) {
04844   return new _TessMemberResultCallback_6_2<true,R,T1,P1,P2,P3,P4,P5,P6,A1,A2>(obj, member, p1, p2, p3, p4, p5, p6);
04845 }
04846 #endif
04847 
04848 #ifndef SWIG
04849 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
04850 inline typename _TessMemberResultCallback_6_2<false,R,T1,P1,P2,P3,P4,P5,P6,A1,A2>::base*
04851 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) {
04852   return new _TessMemberResultCallback_6_2<false,R,T1,P1,P2,P3,P4,P5,P6,A1,A2>(obj, member, p1, p2, p3, p4, p5, p6);
04853 }
04854 #endif
04855 
04856 template <bool del, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
04857 class _TessFunctionResultCallback_6_2 : public TessResultCallback2<R,A1,A2> {
04858  public:
04859   typedef TessResultCallback2<R,A1,A2> base;
04860   typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2);
04861 
04862  private:
04863   FunctionSignature function_;
04864   typename remove_reference<P1>::type p1_;
04865   typename remove_reference<P2>::type p2_;
04866   typename remove_reference<P3>::type p3_;
04867   typename remove_reference<P4>::type p4_;
04868   typename remove_reference<P5>::type p5_;
04869   typename remove_reference<P6>::type p6_;
04870 
04871  public:
04872   inline _TessFunctionResultCallback_6_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
04873     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
04874 
04875   virtual R Run(A1 a1,A2 a2) {
04876     if (!del) {
04877       R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
04878       return result;
04879     } else {
04880       R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
04881       //  zero out the pointer to ensure segfault if used again
04882       function_ = NULL;
04883       delete this;
04884       return result;
04885     }
04886   }
04887 };
04888 
04889 template <bool del, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
04890 class _TessFunctionResultCallback_6_2<del, void, P1, P2, P3, P4, P5, P6, A1, A2> : public TessCallback2<A1,A2> {
04891  public:
04892   typedef TessCallback2<A1,A2> base;
04893   typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2);
04894 
04895  private:
04896   FunctionSignature function_;
04897   typename remove_reference<P1>::type p1_;
04898   typename remove_reference<P2>::type p2_;
04899   typename remove_reference<P3>::type p3_;
04900   typename remove_reference<P4>::type p4_;
04901   typename remove_reference<P5>::type p5_;
04902   typename remove_reference<P6>::type p6_;
04903 
04904  public:
04905   inline _TessFunctionResultCallback_6_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
04906     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
04907 
04908   virtual void Run(A1 a1,A2 a2) {
04909     if (!del) {
04910       (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
04911     } else {
04912       (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
04913       //  zero out the pointer to ensure segfault if used again
04914       function_ = NULL;
04915       delete this;
04916     }
04917   }
04918 };
04919 
04920 template <class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
04921 inline typename _TessFunctionResultCallback_6_2<true,R,P1,P2,P3,P4,P5,P6,A1,A2>::base*
04922 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) {
04923   return new _TessFunctionResultCallback_6_2<true,R,P1,P2,P3,P4,P5,P6,A1,A2>(function, p1, p2, p3, p4, p5, p6);
04924 }
04925 
04926 template <class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
04927 inline typename _TessFunctionResultCallback_6_2<false,R,P1,P2,P3,P4,P5,P6,A1,A2>::base*
04928 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) {
04929   return new _TessFunctionResultCallback_6_2<false,R,P1,P2,P3,P4,P5,P6,A1,A2>(function, p1, p2, p3, p4, p5, p6);
04930 }
04931 
04932 template <bool del, class R, class T, class A1, class A2, class A3>
04933 class _ConstTessMemberResultCallback_0_3 : public TessResultCallback3<R,A1,A2,A3> {
04934  public:
04935   typedef TessResultCallback3<R,A1,A2,A3> base;
04936   typedef R (T::*MemberSignature)(A1,A2,A3) const;
04937 
04938  private:
04939   const T* object_;
04940   MemberSignature member_;
04941 
04942  public:
04943   inline _ConstTessMemberResultCallback_0_3(
04944      const T* object, MemberSignature member)
04945     : object_(object),
04946       member_(member) {
04947   }
04948 
04949   virtual R Run(A1 a1,A2 a2,A3 a3) {
04950     if (!del) {
04951       R result = (object_->*member_)(a1,a2,a3);
04952       return result;
04953     } else {
04954       R result = (object_->*member_)(a1,a2,a3);
04955       //  zero out the pointer to ensure segfault if used again
04956       member_ = NULL;
04957       delete this;
04958       return result;
04959     }
04960   }
04961 };
04962 
04963 template <bool del, class T, class A1, class A2, class A3>
04964 class _ConstTessMemberResultCallback_0_3<del, void, T, A1, A2, A3>
04965   : public TessCallback3<A1,A2,A3> {
04966  public:
04967   typedef TessCallback3<A1,A2,A3> base;
04968   typedef void (T::*MemberSignature)(A1,A2,A3) const;
04969 
04970  private:
04971   const T* object_;
04972   MemberSignature member_;
04973 
04974  public:
04975   inline _ConstTessMemberResultCallback_0_3(
04976       const T* object, MemberSignature member)
04977     : object_(object),
04978       member_(member) {
04979   }
04980 
04981   virtual void Run(A1 a1,A2 a2,A3 a3) {
04982     if (!del) {
04983       (object_->*member_)(a1,a2,a3);
04984     } else {
04985       (object_->*member_)(a1,a2,a3);
04986       //  zero out the pointer to ensure segfault if used again
04987       member_ = NULL;
04988       delete this;
04989     }
04990   }
04991 };
04992 
04993 #ifndef SWIG
04994 template <class T1, class T2, class R, class A1, class A2, class A3>
04995 inline typename _ConstTessMemberResultCallback_0_3<true,R,T1,A1,A2,A3>::base*
04996 NewTessCallback(
04997     const T1* obj, R (T2::*member)(A1,A2,A3) const) {
04998   return new _ConstTessMemberResultCallback_0_3<true,R,T1,A1,A2,A3>(
04999       obj, member);
05000 }
05001 #endif
05002 
05003 #ifndef SWIG
05004 template <class T1, class T2, class R, class A1, class A2, class A3>
05005 inline typename _ConstTessMemberResultCallback_0_3<false,R,T1,A1,A2,A3>::base*
05006 NewPermanentTessCallback(
05007     const T1* obj, R (T2::*member)(A1,A2,A3) const) {
05008   return new _ConstTessMemberResultCallback_0_3<false,R,T1,A1,A2,A3>(
05009       obj, member);
05010 }
05011 #endif
05012 
05013 template <bool del, class R, class T, class A1, class A2, class A3>
05014 class _TessMemberResultCallback_0_3 : public TessResultCallback3<R,A1,A2,A3> {
05015  public:
05016   typedef TessResultCallback3<R,A1,A2,A3> base;
05017   typedef R (T::*MemberSignature)(A1,A2,A3) ;
05018 
05019  private:
05020    T* object_;
05021   MemberSignature member_;
05022 
05023  public:
05024   inline _TessMemberResultCallback_0_3(
05025       T* object, MemberSignature member)
05026     : object_(object),
05027       member_(member) {
05028   }
05029 
05030   virtual R Run(A1 a1,A2 a2,A3 a3) {
05031     if (!del) {
05032       R result = (object_->*member_)(a1,a2,a3);
05033       return result;
05034     } else {
05035       R result = (object_->*member_)(a1,a2,a3);
05036       //  zero out the pointer to ensure segfault if used again
05037       member_ = NULL;
05038       delete this;
05039       return result;
05040     }
05041   }
05042 };
05043 
05044 template <bool del, class T, class A1, class A2, class A3>
05045 class _TessMemberResultCallback_0_3<del, void, T, A1, A2, A3>
05046   : public TessCallback3<A1,A2,A3> {
05047  public:
05048   typedef TessCallback3<A1,A2,A3> base;
05049   typedef void (T::*MemberSignature)(A1,A2,A3) ;
05050 
05051  private:
05052    T* object_;
05053   MemberSignature member_;
05054 
05055  public:
05056   inline _TessMemberResultCallback_0_3(
05057        T* object, MemberSignature member)
05058     : object_(object),
05059       member_(member) {
05060   }
05061 
05062   virtual void Run(A1 a1,A2 a2,A3 a3) {
05063     if (!del) {
05064       (object_->*member_)(a1,a2,a3);
05065     } else {
05066       (object_->*member_)(a1,a2,a3);
05067       //  zero out the pointer to ensure segfault if used again
05068       member_ = NULL;
05069       delete this;
05070     }
05071   }
05072 };
05073 
05074 #ifndef SWIG
05075 template <class T1, class T2, class R, class A1, class A2, class A3>
05076 inline typename _TessMemberResultCallback_0_3<true,R,T1,A1,A2,A3>::base*
05077 NewTessCallback(
05078      T1* obj, R (T2::*member)(A1,A2,A3) ) {
05079   return new _TessMemberResultCallback_0_3<true,R,T1,A1,A2,A3>(
05080       obj, member);
05081 }
05082 #endif
05083 
05084 #ifndef SWIG
05085 template <class T1, class T2, class R, class A1, class A2, class A3>
05086 inline typename _TessMemberResultCallback_0_3<false,R,T1,A1,A2,A3>::base*
05087 NewPermanentTessCallback(
05088      T1* obj, R (T2::*member)(A1,A2,A3) ) {
05089   return new _TessMemberResultCallback_0_3<false,R,T1,A1,A2,A3>(
05090       obj, member);
05091 }
05092 #endif
05093 
05094 template <bool del, class R, class A1, class A2, class A3>
05095 class _TessFunctionResultCallback_0_3 : public TessResultCallback3<R,A1,A2,A3> {
05096  public:
05097   typedef TessResultCallback3<R,A1,A2,A3> base;
05098   typedef R (*FunctionSignature)(A1,A2,A3);
05099 
05100  private:
05101   FunctionSignature function_;
05102 
05103  public:
05104   inline _TessFunctionResultCallback_0_3(
05105       FunctionSignature function)
05106     : function_(function) {
05107   }
05108 
05109   virtual R Run(A1 a1,A2 a2,A3 a3) {
05110     if (!del) {
05111       R result = (*function_)(a1,a2,a3);
05112       return result;
05113     } else {
05114       R result = (*function_)(a1,a2,a3);
05115       //  zero out the pointer to ensure segfault if used again
05116       function_ = NULL;
05117       delete this;
05118       return result;
05119     }
05120   }
05121 };
05122 
05123 template <bool del, class A1, class A2, class A3>
05124 class _TessFunctionResultCallback_0_3<del, void, A1, A2, A3>
05125   : public TessCallback3<A1,A2,A3> {
05126  public:
05127   typedef TessCallback3<A1,A2,A3> base;
05128   typedef void (*FunctionSignature)(A1,A2,A3);
05129 
05130  private:
05131   FunctionSignature function_;
05132 
05133  public:
05134   inline _TessFunctionResultCallback_0_3(
05135       FunctionSignature function)
05136     : function_(function) {
05137   }
05138 
05139   virtual void Run(A1 a1,A2 a2,A3 a3) {
05140     if (!del) {
05141       (*function_)(a1,a2,a3);
05142     } else {
05143       (*function_)(a1,a2,a3);
05144       //  zero out the pointer to ensure segfault if used again
05145       function_ = NULL;
05146       delete this;
05147     }
05148   }
05149 };
05150 
05151 template <class R, class A1, class A2, class A3>
05152 inline typename _TessFunctionResultCallback_0_3<true,R,A1,A2,A3>::base*
05153 NewTessCallback(R (*function)(A1,A2,A3)) {
05154   return new _TessFunctionResultCallback_0_3<true,R,A1,A2,A3>(function);
05155 }
05156 
05157 template <class R, class A1, class A2, class A3>
05158 inline typename _TessFunctionResultCallback_0_3<false,R,A1,A2,A3>::base*
05159 NewPermanentTessCallback(R (*function)(A1,A2,A3)) {
05160   return new _TessFunctionResultCallback_0_3<false,R,A1,A2,A3>(function);
05161 }
05162 
05163 template <bool del, class R, class T, class P1, class A1, class A2, class A3>
05164 class _ConstTessMemberResultCallback_1_3
05165   : public TessResultCallback3<R,A1,A2,A3> {
05166  public:
05167   typedef TessResultCallback3<R,A1,A2,A3> base;
05168   typedef R (T::*MemberSignature)(P1,A1,A2,A3) const;
05169 
05170  private:
05171    T* object_;
05172   MemberSignature member_;
05173   typename remove_reference<P1>::type p1_;
05174 
05175  public:
05176   inline _ConstTessMemberResultCallback_1_3(T* object,
05177                                             MemberSignature member, P1 p1)
05178     : object_(object), member_(member), p1_(p1) { }
05179 
05180   virtual R Run(A1 a1, A2 a2, A3 a3) {
05181     if (!del) {
05182       R result = (object_->*member_)(p1_,a1,a2,a3);
05183       return result;
05184     } else {
05185       R result = (object_->*member_)(p1_,a1,a2,a3);
05186       //  zero out the pointer to ensure segfault if used again
05187       member_ = NULL;
05188       delete this;
05189       return result;
05190     }
05191   }
05192 };
05193 
05194 template <bool del, class T, class P1, class A1, class A2, class A3>
05195 class _ConstTessMemberResultCallback_1_3<del, void, T, P1, A1, A2, A3>
05196   : public TessCallback3<A1,A2,A3> {
05197  public:
05198   typedef TessCallback3<A1,A2,A3> base;
05199   typedef void (T::*MemberSignature)(P1,A1,A2,A3) const;
05200 
05201  private:
05202    T* object_;
05203   MemberSignature member_;
05204   typename remove_reference<P1>::type p1_;
05205 
05206  public:
05207   inline _ConstTessMemberResultCallback_1_3(T* object,
05208                                             MemberSignature member, P1 p1)
05209     : object_(object), member_(member), p1_(p1) { }
05210 
05211   virtual void Run(A1 a1, A2 a2, A3 a3) {
05212     if (!del) {
05213       (object_->*member_)(p1_,a1,a2,a3);
05214     } else {
05215       (object_->*member_)(p1_,a1,a2,a3);
05216       //  zero out the pointer to ensure segfault if used again
05217       member_ = NULL;
05218       delete this;
05219     }
05220   }
05221 };
05222 
05223 #ifndef SWIG
05224 template <class T1, class T2, class R, class P1, class A1, class A2, class A3>
05225 inline typename _ConstTessMemberResultCallback_1_3<true,R,T1,P1,A1,A2,A3>::base*
05226 NewTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3) , typename Identity<P1>::type p1) {
05227   return new _ConstTessMemberResultCallback_1_3<true,R,T1,P1,A1,A2,A3>(obj, member, p1);
05228 }
05229 #endif
05230 
05231 #ifndef SWIG
05232 template <class T1, class T2, class R, class P1, class A1, class A2, class A3>
05233 inline typename _ConstTessMemberResultCallback_1_3<false,R,T1,P1,A1,A2,A3>::base*
05234 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3) , typename Identity<P1>::type p1) {
05235   return new _ConstTessMemberResultCallback_1_3<false,R,T1,P1,A1,A2,A3>(obj, member, p1);
05236 }
05237 #endif
05238 
05239 template <bool del, class R, class T, class P1, class A1, class A2, class A3>
05240 class _TessMemberResultCallback_1_3 : public TessResultCallback3<R,A1,A2,A3> {
05241  public:
05242   typedef TessResultCallback3<R,A1,A2,A3> base;
05243   typedef R (T::*MemberSignature)(P1,A1,A2,A3) ;
05244 
05245  private:
05246    T* object_;
05247   MemberSignature member_;
05248   typename remove_reference<P1>::type p1_;
05249 
05250  public:
05251   inline _TessMemberResultCallback_1_3(T* object,
05252                                         MemberSignature member, P1 p1)
05253     : object_(object), member_(member), p1_(p1) { }
05254 
05255   virtual R Run(A1 a1, A2 a2, A3 a3) {
05256     if (!del) {
05257       R result = (object_->*member_)(p1_,a1,a2,a3);
05258       return result;
05259     } else {
05260       R result = (object_->*member_)(p1_,a1,a2,a3);
05261       //  zero out the pointer to ensure segfault if used again
05262       member_ = NULL;
05263       delete this;
05264       return result;
05265     }
05266   }
05267 };
05268 
05269 template <bool del, class T, class P1, class A1, class A2, class A3>
05270 class _TessMemberResultCallback_1_3<del, void, T, P1, A1, A2, A3>
05271   : public TessCallback3<A1,A2,A3> {
05272  public:
05273   typedef TessCallback3<A1,A2,A3> base;
05274   typedef void (T::*MemberSignature)(P1,A1,A2,A3) ;
05275 
05276  private:
05277    T* object_;
05278   MemberSignature member_;
05279   typename remove_reference<P1>::type p1_;
05280 
05281  public:
05282   inline _TessMemberResultCallback_1_3(T* object,
05283                                         MemberSignature member, P1 p1)
05284     : object_(object), member_(member), p1_(p1) { }
05285 
05286   virtual void Run(A1 a1, A2 a2, A3 a3) {
05287     if (!del) {
05288       (object_->*member_)(p1_,a1,a2,a3);
05289     } else {
05290       (object_->*member_)(p1_,a1,a2,a3);
05291       //  zero out the pointer to ensure segfault if used again
05292       member_ = NULL;
05293       delete this;
05294     }
05295   }
05296 };
05297 
05298 #ifndef SWIG
05299 template <class T1, class T2, class R, class P1, class A1, class A2, class A3>
05300 inline typename _TessMemberResultCallback_1_3<true,R,T1,P1,A1,A2,A3>::base*
05301 NewTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3) , typename Identity<P1>::type p1) {
05302   return new _TessMemberResultCallback_1_3<true,R,T1,P1,A1,A2,A3>(obj, member, p1);
05303 }
05304 #endif
05305 
05306 #ifndef SWIG
05307 template <class T1, class T2, class R, class P1, class A1, class A2, class A3>
05308 inline typename _TessMemberResultCallback_1_3<false,R,T1,P1,A1,A2,A3>::base*
05309 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3) , typename Identity<P1>::type p1) {
05310   return new _TessMemberResultCallback_1_3<false,R,T1,P1,A1,A2,A3>(obj, member, p1);
05311 }
05312 #endif
05313 
05314 template <bool del, class R, class P1, class A1, class A2, class A3>
05315 class _TessFunctionResultCallback_1_3 : public TessCallback3<A1,A2,A3> {
05316  public:
05317   typedef TessCallback3<A1,A2,A3> base;
05318   typedef R (*FunctionSignature)(P1,A1,A2,A3);
05319 
05320  private:
05321   FunctionSignature function_;
05322   typename remove_reference<P1>::type p1_;
05323 
05324  public:
05325   inline _TessFunctionResultCallback_1_3(FunctionSignature function, P1 p1)
05326     : function_(function), p1_(p1) { }
05327 
05328   virtual R Run(A1 a1, A2 a2, A3 a3) {
05329     if (!del) {
05330       R result = (*function_)(p1_,a1,a2,a3);
05331       return result;
05332     } else {
05333       R result = (*function_)(p1_,a1,a2,a3);
05334       //  zero out the pointer to ensure segfault if used again
05335       function_ = NULL;
05336       delete this;
05337       return result;
05338     }
05339   }
05340 };
05341 
05342 template <bool del, class P1, class A1, class A2, class A3>
05343 class _TessFunctionResultCallback_1_3<del, void, P1, A1, A2, A3>
05344   : public TessCallback3<A1,A2,A3> {
05345  public:
05346   typedef TessCallback3<A1,A2,A3> base;
05347   typedef void (*FunctionSignature)(P1,A1,A2,A3);
05348 
05349  private:
05350   FunctionSignature function_;
05351   typename remove_reference<P1>::type p1_;
05352 
05353  public:
05354   inline _TessFunctionResultCallback_1_3(FunctionSignature function, P1 p1)
05355     : function_(function), p1_(p1) { }
05356 
05357   virtual void Run(A1 a1, A2 a2, A3 a3) {
05358     if (!del) {
05359       (*function_)(p1_,a1,a2,a3);
05360     } else {
05361       (*function_)(p1_,a1,a2,a3);
05362       //  zero out the pointer to ensure segfault if used again
05363       function_ = NULL;
05364       delete this;
05365     }
05366   }
05367 };
05368 
05369 template <class R, class P1, class A1, class A2, class A3>
05370 inline typename _TessFunctionResultCallback_1_3<true,R,P1,A1,A2,A3>::base*
05371 NewTessCallback(R (*function)(P1,A1,A2,A3), typename Identity<P1>::type p1) {
05372   return new _TessFunctionResultCallback_1_3<true,R,P1,A1,A2,A3>(function, p1);
05373 }
05374 
05375 template <class R, class P1, class A1, class A2, class A3>
05376 inline typename _TessFunctionResultCallback_1_3<false,R,P1,A1,A2,A3>::base*
05377 NewPermanentTessCallback(R (*function)(P1,A1,A2,A3), typename Identity<P1>::type p1) {
05378   return new _TessFunctionResultCallback_1_3<false,R,P1,A1,A2,A3>(function, p1);
05379 }
05380 
05381 template <bool del, class R, class T, class P1, class P2, class A1, class A2, class A3>
05382 class _ConstTessMemberResultCallback_2_3 : public TessResultCallback3<R,A1,A2,A3> {
05383  public:
05384   typedef TessResultCallback3<R,A1,A2,A3> base;
05385   typedef R (T::*MemberSignature)(P1,P2,A1,A2,A3) const;
05386 
05387  private:
05388   const T* object_;
05389   MemberSignature member_;
05390   typename remove_reference<P1>::type p1_;
05391   typename remove_reference<P2>::type p2_;
05392 
05393  public:
05394   inline _ConstTessMemberResultCallback_2_3(const T* object, MemberSignature member, P1 p1, P2 p2)
05395     : object_(object),
05396       member_(member),      p1_(p1),      p2_(p2) { }
05397 
05398   virtual R Run(A1 a1,A2 a2,A3 a3) {
05399     if (!del) {
05400       R result = (object_->*member_)(p1_,p2_,a1,a2,a3);
05401       return result;
05402     } else {
05403       R result = (object_->*member_)(p1_,p2_,a1,a2,a3);
05404       //  zero out the pointer to ensure segfault if used again
05405       member_ = NULL;
05406       delete this;
05407       return result;
05408     }
05409   }
05410 };
05411 
05412 template <bool del, class T, class P1, class P2, class A1, class A2, class A3>
05413 class _ConstTessMemberResultCallback_2_3<del, void, T, P1, P2, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
05414  public:
05415   typedef TessCallback3<A1,A2,A3> base;
05416   typedef void (T::*MemberSignature)(P1,P2,A1,A2,A3) const;
05417 
05418  private:
05419   const T* object_;
05420   MemberSignature member_;
05421   typename remove_reference<P1>::type p1_;
05422   typename remove_reference<P2>::type p2_;
05423 
05424  public:
05425   inline _ConstTessMemberResultCallback_2_3(const T* object, MemberSignature member, P1 p1, P2 p2)
05426     : object_(object),
05427       member_(member),      p1_(p1),      p2_(p2) { }
05428 
05429   virtual void Run(A1 a1,A2 a2,A3 a3) {
05430     if (!del) {
05431       (object_->*member_)(p1_,p2_,a1,a2,a3);
05432     } else {
05433       (object_->*member_)(p1_,p2_,a1,a2,a3);
05434       //  zero out the pointer to ensure segfault if used again
05435       member_ = NULL;
05436       delete this;
05437     }
05438   }
05439 };
05440 
05441 #ifndef SWIG
05442 template <class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3>
05443 inline typename _ConstTessMemberResultCallback_2_3<true,R,T1,P1,P2,A1,A2,A3>::base*
05444 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2,A3) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
05445   return new _ConstTessMemberResultCallback_2_3<true,R,T1,P1,P2,A1,A2,A3>(obj, member, p1, p2);
05446 }
05447 #endif
05448 
05449 #ifndef SWIG
05450 template <class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3>
05451 inline typename _ConstTessMemberResultCallback_2_3<false,R,T1,P1,P2,A1,A2,A3>::base*
05452 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2,A3) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
05453   return new _ConstTessMemberResultCallback_2_3<false,R,T1,P1,P2,A1,A2,A3>(obj, member, p1, p2);
05454 }
05455 #endif
05456 
05457 template <bool del, class R, class T, class P1, class P2, class A1, class A2, class A3>
05458 class _TessMemberResultCallback_2_3 : public TessResultCallback3<R,A1,A2,A3> {
05459  public:
05460   typedef TessResultCallback3<R,A1,A2,A3> base;
05461   typedef R (T::*MemberSignature)(P1,P2,A1,A2,A3) ;
05462 
05463  private:
05464    T* object_;
05465   MemberSignature member_;
05466   typename remove_reference<P1>::type p1_;
05467   typename remove_reference<P2>::type p2_;
05468 
05469  public:
05470   inline _TessMemberResultCallback_2_3( T* object, MemberSignature member, P1 p1, P2 p2)
05471     : object_(object),
05472       member_(member),      p1_(p1),      p2_(p2) { }
05473 
05474 
05475   virtual R Run(A1 a1,A2 a2,A3 a3) {
05476     if (!del) {
05477       R result = (object_->*member_)(p1_,p2_,a1,a2,a3);
05478       return result;
05479     } else {
05480       R result = (object_->*member_)(p1_,p2_,a1,a2,a3);
05481       //  zero out the pointer to ensure segfault if used again
05482       member_ = NULL;
05483       delete this;
05484       return result;
05485     }
05486   }
05487 };
05488 
05489 template <bool del, class T, class P1, class P2, class A1, class A2, class A3>
05490 class _TessMemberResultCallback_2_3<del, void, T, P1, P2, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
05491  public:
05492   typedef TessCallback3<A1,A2,A3> base;
05493   typedef void (T::*MemberSignature)(P1,P2,A1,A2,A3) ;
05494 
05495  private:
05496    T* object_;
05497   MemberSignature member_;
05498   typename remove_reference<P1>::type p1_;
05499   typename remove_reference<P2>::type p2_;
05500 
05501  public:
05502   inline _TessMemberResultCallback_2_3( T* object, MemberSignature member, P1 p1, P2 p2)
05503     : object_(object),
05504       member_(member),      p1_(p1),      p2_(p2) { }
05505 
05506   virtual void Run(A1 a1,A2 a2,A3 a3) {
05507     if (!del) {
05508       (object_->*member_)(p1_,p2_,a1,a2,a3);
05509     } else {
05510       (object_->*member_)(p1_,p2_,a1,a2,a3);
05511       //  zero out the pointer to ensure segfault if used again
05512       member_ = NULL;
05513       delete this;
05514     }
05515   }
05516 };
05517 
05518 #ifndef SWIG
05519 template <class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3>
05520 inline typename _TessMemberResultCallback_2_3<true,R,T1,P1,P2,A1,A2,A3>::base*
05521 NewTessCallback( T1* obj, R (T2::*member)(P1,P2,A1,A2,A3) , typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
05522   return new _TessMemberResultCallback_2_3<true,R,T1,P1,P2,A1,A2,A3>(obj, member, p1, p2);
05523 }
05524 #endif
05525 
05526 #ifndef SWIG
05527 template <class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3>
05528 inline typename _TessMemberResultCallback_2_3<false,R,T1,P1,P2,A1,A2,A3>::base*
05529 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,A1,A2,A3) , typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
05530   return new _TessMemberResultCallback_2_3<false,R,T1,P1,P2,A1,A2,A3>(obj, member, p1, p2);
05531 }
05532 #endif
05533 
05534 template <bool del, class R, class P1, class P2, class A1, class A2, class A3>
05535 class _TessFunctionResultCallback_2_3 : public TessResultCallback3<R,A1,A2,A3> {
05536  public:
05537   typedef TessResultCallback3<R,A1,A2,A3> base;
05538   typedef R (*FunctionSignature)(P1,P2,A1,A2,A3);
05539 
05540  private:
05541   FunctionSignature function_;
05542   typename remove_reference<P1>::type p1_;
05543   typename remove_reference<P2>::type p2_;
05544 
05545  public:
05546   inline _TessFunctionResultCallback_2_3(FunctionSignature function, P1 p1, P2 p2)
05547     : function_(function),      p1_(p1),      p2_(p2) { }
05548 
05549   virtual R Run(A1 a1,A2 a2,A3 a3) {
05550     if (!del) {
05551       R result = (*function_)(p1_,p2_,a1,a2,a3);
05552       return result;
05553     } else {
05554       R result = (*function_)(p1_,p2_,a1,a2,a3);
05555       //  zero out the pointer to ensure segfault if used again
05556       function_ = NULL;
05557       delete this;
05558       return result;
05559     }
05560   }
05561 };
05562 
05563 template <bool del, class P1, class P2, class A1, class A2, class A3>
05564 class _TessFunctionResultCallback_2_3<del, void, P1, P2, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
05565  public:
05566   typedef TessCallback3<A1,A2,A3> base;
05567   typedef void (*FunctionSignature)(P1,P2,A1,A2,A3);
05568 
05569  private:
05570   FunctionSignature function_;
05571   typename remove_reference<P1>::type p1_;
05572   typename remove_reference<P2>::type p2_;
05573 
05574  public:
05575   inline _TessFunctionResultCallback_2_3(FunctionSignature function, P1 p1, P2 p2)
05576     : function_(function),      p1_(p1),      p2_(p2) { }
05577 
05578   virtual void Run(A1 a1,A2 a2,A3 a3) {
05579     if (!del) {
05580       (*function_)(p1_,p2_,a1,a2,a3);
05581     } else {
05582       (*function_)(p1_,p2_,a1,a2,a3);
05583       //  zero out the pointer to ensure segfault if used again
05584       function_ = NULL;
05585       delete this;
05586     }
05587   }
05588 };
05589 
05590 template <class R, class P1, class P2, class A1, class A2, class A3>
05591 inline typename _TessFunctionResultCallback_2_3<true,R,P1,P2,A1,A2,A3>::base*
05592 NewTessCallback(R (*function)(P1,P2,A1,A2,A3), typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
05593   return new _TessFunctionResultCallback_2_3<true,R,P1,P2,A1,A2,A3>(function, p1, p2);
05594 }
05595 
05596 template <class R, class P1, class P2, class A1, class A2, class A3>
05597 inline typename _TessFunctionResultCallback_2_3<false,R,P1,P2,A1,A2,A3>::base*
05598 NewPermanentTessCallback(R (*function)(P1,P2,A1,A2,A3), typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
05599   return new _TessFunctionResultCallback_2_3<false,R,P1,P2,A1,A2,A3>(function, p1, p2);
05600 }
05601 
05602 template <bool del, class R, class T, class P1, class P2, class P3, class A1, class A2, class A3>
05603 class _ConstTessMemberResultCallback_3_3 : public TessResultCallback3<R,A1,A2,A3> {
05604  public:
05605   typedef TessResultCallback3<R,A1,A2,A3> base;
05606   typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2,A3) const;
05607 
05608  private:
05609   const T* object_;
05610   MemberSignature member_;
05611   typename remove_reference<P1>::type p1_;
05612   typename remove_reference<P2>::type p2_;
05613   typename remove_reference<P3>::type p3_;
05614 
05615  public:
05616   inline _ConstTessMemberResultCallback_3_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
05617     : object_(object),
05618       member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }
05619 
05620   virtual R Run(A1 a1,A2 a2,A3 a3) {
05621     if (!del) {
05622       R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3);
05623       return result;
05624     } else {
05625       R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3);
05626       //  zero out the pointer to ensure segfault if used again
05627       member_ = NULL;
05628       delete this;
05629       return result;
05630     }
05631   }
05632 };
05633 
05634 template <bool del, class T, class P1, class P2, class P3, class A1, class A2, class A3>
05635 class _ConstTessMemberResultCallback_3_3<del, void, T, P1, P2, P3, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
05636  public:
05637   typedef TessCallback3<A1,A2,A3> base;
05638   typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2,A3) const;
05639 
05640  private:
05641   const T* object_;
05642   MemberSignature member_;
05643   typename remove_reference<P1>::type p1_;
05644   typename remove_reference<P2>::type p2_;
05645   typename remove_reference<P3>::type p3_;
05646 
05647  public:
05648   inline _ConstTessMemberResultCallback_3_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
05649     : object_(object),
05650       member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }
05651 
05652   virtual void Run(A1 a1,A2 a2,A3 a3) {
05653     if (!del) {
05654       (object_->*member_)(p1_,p2_,p3_,a1,a2,a3);
05655     } else {
05656       (object_->*member_)(p1_,p2_,p3_,a1,a2,a3);
05657       //  zero out the pointer to ensure segfault if used again
05658       member_ = NULL;
05659       delete this;
05660     }
05661   }
05662 };
05663 
05664 #ifndef SWIG
05665 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3>
05666 inline typename _ConstTessMemberResultCallback_3_3<true,R,T1,P1,P2,P3,A1,A2,A3>::base*
05667 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) {
05668   return new _ConstTessMemberResultCallback_3_3<true,R,T1,P1,P2,P3,A1,A2,A3>(obj, member, p1, p2, p3);
05669 }
05670 #endif
05671 
05672 #ifndef SWIG
05673 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3>
05674 inline typename _ConstTessMemberResultCallback_3_3<false,R,T1,P1,P2,P3,A1,A2,A3>::base*
05675 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) {
05676   return new _ConstTessMemberResultCallback_3_3<false,R,T1,P1,P2,P3,A1,A2,A3>(obj, member, p1, p2, p3);
05677 }
05678 #endif
05679 
05680 template <bool del, class R, class T, class P1, class P2, class P3, class A1, class A2, class A3>
05681 class _TessMemberResultCallback_3_3 : public TessResultCallback3<R,A1,A2,A3> {
05682  public:
05683   typedef TessResultCallback3<R,A1,A2,A3> base;
05684   typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2,A3) ;
05685 
05686  private:
05687    T* object_;
05688   MemberSignature member_;
05689   typename remove_reference<P1>::type p1_;
05690   typename remove_reference<P2>::type p2_;
05691   typename remove_reference<P3>::type p3_;
05692 
05693  public:
05694   inline _TessMemberResultCallback_3_3( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
05695     : object_(object),
05696       member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }
05697 
05698   virtual R Run(A1 a1,A2 a2,A3 a3) {
05699     if (!del) {
05700       R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3);
05701       return result;
05702     } else {
05703       R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3);
05704       //  zero out the pointer to ensure segfault if used again
05705       member_ = NULL;
05706       delete this;
05707       return result;
05708     }
05709   }
05710 };
05711 
05712 template <bool del, class T, class P1, class P2, class P3, class A1, class A2, class A3>
05713 class _TessMemberResultCallback_3_3<del, void, T, P1, P2, P3, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
05714  public:
05715   typedef TessCallback3<A1,A2,A3> base;
05716   typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2,A3) ;
05717 
05718  private:
05719    T* object_;
05720   MemberSignature member_;
05721   typename remove_reference<P1>::type p1_;
05722   typename remove_reference<P2>::type p2_;
05723   typename remove_reference<P3>::type p3_;
05724 
05725  public:
05726   inline _TessMemberResultCallback_3_3( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
05727     : object_(object),
05728       member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }
05729 
05730   virtual void Run(A1 a1,A2 a2,A3 a3) {
05731     if (!del) {
05732       (object_->*member_)(p1_,p2_,p3_,a1,a2,a3);
05733     } else {
05734       (object_->*member_)(p1_,p2_,p3_,a1,a2,a3);
05735       //  zero out the pointer to ensure segfault if used again
05736       member_ = NULL;
05737       delete this;
05738     }
05739   }
05740 };
05741 
05742 #ifndef SWIG
05743 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3>
05744 inline typename _TessMemberResultCallback_3_3<true,R,T1,P1,P2,P3,A1,A2,A3>::base*
05745 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) {
05746   return new _TessMemberResultCallback_3_3<true,R,T1,P1,P2,P3,A1,A2,A3>(obj, member, p1, p2, p3);
05747 }
05748 #endif
05749 
05750 #ifndef SWIG
05751 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3>
05752 inline typename _TessMemberResultCallback_3_3<false,R,T1,P1,P2,P3,A1,A2,A3>::base*
05753 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) {
05754   return new _TessMemberResultCallback_3_3<false,R,T1,P1,P2,P3,A1,A2,A3>(obj, member, p1, p2, p3);
05755 }
05756 #endif
05757 
05758 template <bool del, class R, class P1, class P2, class P3, class A1, class A2, class A3>
05759 class _TessFunctionResultCallback_3_3 : public TessResultCallback3<R,A1,A2,A3> {
05760  public:
05761   typedef TessResultCallback3<R,A1,A2,A3> base;
05762   typedef R (*FunctionSignature)(P1,P2,P3,A1,A2,A3);
05763 
05764  private:
05765   FunctionSignature function_;
05766   typename remove_reference<P1>::type p1_;
05767   typename remove_reference<P2>::type p2_;
05768   typename remove_reference<P3>::type p3_;
05769 
05770  public:
05771   inline _TessFunctionResultCallback_3_3(FunctionSignature function, P1 p1, P2 p2, P3 p3)
05772     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3) { }
05773 
05774   virtual R Run(A1 a1,A2 a2,A3 a3) {
05775     if (!del) {
05776       R result = (*function_)(p1_,p2_,p3_,a1,a2,a3);
05777       return result;
05778     } else {
05779       R result = (*function_)(p1_,p2_,p3_,a1,a2,a3);
05780       //  zero out the pointer to ensure segfault if used again
05781       function_ = NULL;
05782       delete this;
05783       return result;
05784     }
05785   }
05786 };
05787 
05788 template <bool del, class P1, class P2, class P3, class A1, class A2, class A3>
05789 class _TessFunctionResultCallback_3_3<del, void, P1, P2, P3, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
05790  public:
05791   typedef TessCallback3<A1,A2,A3> base;
05792   typedef void (*FunctionSignature)(P1,P2,P3,A1,A2,A3);
05793 
05794  private:
05795   FunctionSignature function_;
05796   typename remove_reference<P1>::type p1_;
05797   typename remove_reference<P2>::type p2_;
05798   typename remove_reference<P3>::type p3_;
05799 
05800  public:
05801   inline _TessFunctionResultCallback_3_3(FunctionSignature function, P1 p1, P2 p2, P3 p3)
05802     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3) { }
05803 
05804   virtual void Run(A1 a1,A2 a2,A3 a3) {
05805     if (!del) {
05806       (*function_)(p1_,p2_,p3_,a1,a2,a3);
05807     } else {
05808       (*function_)(p1_,p2_,p3_,a1,a2,a3);
05809       //  zero out the pointer to ensure segfault if used again
05810       function_ = NULL;
05811       delete this;
05812     }
05813   }
05814 };
05815 
05816 template <class R, class P1, class P2, class P3, class A1, class A2, class A3>
05817 inline typename _TessFunctionResultCallback_3_3<true,R,P1,P2,P3,A1,A2,A3>::base*
05818 NewTessCallback(R (*function)(P1,P2,P3,A1,A2,A3), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
05819   return new _TessFunctionResultCallback_3_3<true,R,P1,P2,P3,A1,A2,A3>(function, p1, p2, p3);
05820 }
05821 
05822 template <class R, class P1, class P2, class P3, class A1, class A2, class A3>
05823 inline typename _TessFunctionResultCallback_3_3<false,R,P1,P2,P3,A1,A2,A3>::base*
05824 NewPermanentTessCallback(R (*function)(P1,P2,P3,A1,A2,A3), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
05825   return new _TessFunctionResultCallback_3_3<false,R,P1,P2,P3,A1,A2,A3>(function, p1, p2, p3);
05826 }
05827 
05828 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
05829 class _ConstTessMemberResultCallback_4_3 : public TessResultCallback3<R,A1,A2,A3> {
05830  public:
05831   typedef TessResultCallback3<R,A1,A2,A3> base;
05832   typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3) const;
05833 
05834  private:
05835   const T* object_;
05836   MemberSignature member_;
05837   typename remove_reference<P1>::type p1_;
05838   typename remove_reference<P2>::type p2_;
05839   typename remove_reference<P3>::type p3_;
05840   typename remove_reference<P4>::type p4_;
05841 
05842  public:
05843   inline _ConstTessMemberResultCallback_4_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
05844     : object_(object),
05845       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
05846 
05847   virtual R Run(A1 a1,A2 a2,A3 a3) {
05848     if (!del) {
05849       R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3);
05850       return result;
05851     } else {
05852       R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3);
05853       //  zero out the pointer to ensure segfault if used again
05854       member_ = NULL;
05855       delete this;
05856       return result;
05857     }
05858   }
05859 };
05860 
05861 template <bool del, class T, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
05862 class _ConstTessMemberResultCallback_4_3<del, void, T, P1, P2, P3, P4, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
05863  public:
05864   typedef TessCallback3<A1,A2,A3> base;
05865   typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3) const;
05866 
05867  private:
05868   const T* object_;
05869   MemberSignature member_;
05870   typename remove_reference<P1>::type p1_;
05871   typename remove_reference<P2>::type p2_;
05872   typename remove_reference<P3>::type p3_;
05873   typename remove_reference<P4>::type p4_;
05874 
05875  public:
05876   inline _ConstTessMemberResultCallback_4_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
05877     : object_(object),
05878       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
05879 
05880   virtual void Run(A1 a1,A2 a2,A3 a3) {
05881     if (!del) {
05882       (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3);
05883     } else {
05884       (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3);
05885       //  zero out the pointer to ensure segfault if used again
05886       member_ = NULL;
05887       delete this;
05888     }
05889   }
05890 };
05891 
05892 #ifndef SWIG
05893 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
05894 inline typename _ConstTessMemberResultCallback_4_3<true,R,T1,P1,P2,P3,P4,A1,A2,A3>::base*
05895 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) {
05896   return new _ConstTessMemberResultCallback_4_3<true,R,T1,P1,P2,P3,P4,A1,A2,A3>(obj, member, p1, p2, p3, p4);
05897 }
05898 #endif
05899 
05900 #ifndef SWIG
05901 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
05902 inline typename _ConstTessMemberResultCallback_4_3<false,R,T1,P1,P2,P3,P4,A1,A2,A3>::base*
05903 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) {
05904   return new _ConstTessMemberResultCallback_4_3<false,R,T1,P1,P2,P3,P4,A1,A2,A3>(obj, member, p1, p2, p3, p4);
05905 }
05906 #endif
05907 
05908 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
05909 class _TessMemberResultCallback_4_3 : public TessResultCallback3<R,A1,A2,A3> {
05910  public:
05911   typedef TessResultCallback3<R,A1,A2,A3> base;
05912   typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3) ;
05913 
05914  private:
05915    T* object_;
05916   MemberSignature member_;
05917   typename remove_reference<P1>::type p1_;
05918   typename remove_reference<P2>::type p2_;
05919   typename remove_reference<P3>::type p3_;
05920   typename remove_reference<P4>::type p4_;
05921 
05922  public:
05923   inline _TessMemberResultCallback_4_3( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
05924     : object_(object),
05925       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
05926 
05927   virtual R Run(A1 a1,A2 a2,A3 a3) {
05928     if (!del) {
05929       R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3);
05930       return result;
05931     } else {
05932       R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3);
05933       //  zero out the pointer to ensure segfault if used again
05934       member_ = NULL;
05935       delete this;
05936       return result;
05937     }
05938   }
05939 };
05940 
05941 template <bool del, class T, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
05942 class _TessMemberResultCallback_4_3<del, void, T, P1, P2, P3, P4, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
05943  public:
05944   typedef TessCallback3<A1,A2,A3> base;
05945   typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3) ;
05946 
05947  private:
05948    T* object_;
05949   MemberSignature member_;
05950   typename remove_reference<P1>::type p1_;
05951   typename remove_reference<P2>::type p2_;
05952   typename remove_reference<P3>::type p3_;
05953   typename remove_reference<P4>::type p4_;
05954 
05955  public:
05956   inline _TessMemberResultCallback_4_3( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
05957     : object_(object),
05958       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
05959 
05960   virtual void Run(A1 a1,A2 a2,A3 a3) {
05961     if (!del) {
05962       (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3);
05963     } else {
05964       (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3);
05965       //  zero out the pointer to ensure segfault if used again
05966       member_ = NULL;
05967       delete this;
05968     }
05969   }
05970 };
05971 
05972 #ifndef SWIG
05973 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
05974 inline typename _TessMemberResultCallback_4_3<true,R,T1,P1,P2,P3,P4,A1,A2,A3>::base*
05975 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) {
05976   return new _TessMemberResultCallback_4_3<true,R,T1,P1,P2,P3,P4,A1,A2,A3>(obj, member, p1, p2, p3, p4);
05977 }
05978 #endif
05979 
05980 #ifndef SWIG
05981 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
05982 inline typename _TessMemberResultCallback_4_3<false,R,T1,P1,P2,P3,P4,A1,A2,A3>::base*
05983 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) {
05984   return new _TessMemberResultCallback_4_3<false,R,T1,P1,P2,P3,P4,A1,A2,A3>(obj, member, p1, p2, p3, p4);
05985 }
05986 #endif
05987 
05988 template <bool del, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
05989 class _TessFunctionResultCallback_4_3 : public TessResultCallback3<R,A1,A2,A3> {
05990  public:
05991   typedef TessResultCallback3<R,A1,A2,A3> base;
05992   typedef R (*FunctionSignature)(P1,P2,P3,P4,A1,A2,A3);
05993 
05994  private:
05995   FunctionSignature function_;
05996   typename remove_reference<P1>::type p1_;
05997   typename remove_reference<P2>::type p2_;
05998   typename remove_reference<P3>::type p3_;
05999   typename remove_reference<P4>::type p4_;
06000 
06001  public:
06002   inline _TessFunctionResultCallback_4_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
06003     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
06004 
06005   virtual R Run(A1 a1,A2 a2,A3 a3) {
06006     if (!del) {
06007       R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3);
06008       return result;
06009     } else {
06010       R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3);
06011       //  zero out the pointer to ensure segfault if used again
06012       function_ = NULL;
06013       delete this;
06014       return result;
06015     }
06016   }
06017 };
06018 
06019 template <bool del, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
06020 class _TessFunctionResultCallback_4_3<del, void, P1, P2, P3, P4, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
06021  public:
06022   typedef TessCallback3<A1,A2,A3> base;
06023   typedef void (*FunctionSignature)(P1,P2,P3,P4,A1,A2,A3);
06024 
06025  private:
06026   FunctionSignature function_;
06027   typename remove_reference<P1>::type p1_;
06028   typename remove_reference<P2>::type p2_;
06029   typename remove_reference<P3>::type p3_;
06030   typename remove_reference<P4>::type p4_;
06031 
06032  public:
06033   inline _TessFunctionResultCallback_4_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
06034     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
06035 
06036   virtual void Run(A1 a1,A2 a2,A3 a3) {
06037     if (!del) {
06038       (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3);
06039     } else {
06040       (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3);
06041       //  zero out the pointer to ensure segfault if used again
06042       function_ = NULL;
06043       delete this;
06044     }
06045   }
06046 };
06047 
06048 template <class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
06049 inline typename _TessFunctionResultCallback_4_3<true,R,P1,P2,P3,P4,A1,A2,A3>::base*
06050 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) {
06051   return new _TessFunctionResultCallback_4_3<true,R,P1,P2,P3,P4,A1,A2,A3>(function, p1, p2, p3, p4);
06052 }
06053 
06054 template <class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
06055 inline typename _TessFunctionResultCallback_4_3<false,R,P1,P2,P3,P4,A1,A2,A3>::base*
06056 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) {
06057   return new _TessFunctionResultCallback_4_3<false,R,P1,P2,P3,P4,A1,A2,A3>(function, p1, p2, p3, p4);
06058 }
06059 
06060 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
06061 class _ConstTessMemberResultCallback_5_3 : public TessResultCallback3<R,A1,A2,A3> {
06062  public:
06063   typedef TessResultCallback3<R,A1,A2,A3> base;
06064   typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3) const;
06065 
06066  private:
06067   const T* object_;
06068   MemberSignature member_;
06069   typename remove_reference<P1>::type p1_;
06070   typename remove_reference<P2>::type p2_;
06071   typename remove_reference<P3>::type p3_;
06072   typename remove_reference<P4>::type p4_;
06073   typename remove_reference<P5>::type p5_;
06074 
06075  public:
06076   inline _ConstTessMemberResultCallback_5_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
06077     : object_(object),
06078       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
06079 
06080   virtual R Run(A1 a1,A2 a2,A3 a3) {
06081     if (!del) {
06082       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
06083       return result;
06084     } else {
06085       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
06086       //  zero out the pointer to ensure segfault if used again
06087       member_ = NULL;
06088       delete this;
06089       return result;
06090     }
06091   }
06092 };
06093 
06094 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
06095 class _ConstTessMemberResultCallback_5_3<del, void, T, P1, P2, P3, P4, P5, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
06096  public:
06097   typedef TessCallback3<A1,A2,A3> base;
06098   typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3) const;
06099 
06100  private:
06101   const T* object_;
06102   MemberSignature member_;
06103   typename remove_reference<P1>::type p1_;
06104   typename remove_reference<P2>::type p2_;
06105   typename remove_reference<P3>::type p3_;
06106   typename remove_reference<P4>::type p4_;
06107   typename remove_reference<P5>::type p5_;
06108 
06109  public:
06110   inline _ConstTessMemberResultCallback_5_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
06111     : object_(object),
06112       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
06113 
06114   virtual void Run(A1 a1,A2 a2,A3 a3) {
06115     if (!del) {
06116       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
06117     } else {
06118       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
06119       //  zero out the pointer to ensure segfault if used again
06120       member_ = NULL;
06121       delete this;
06122     }
06123   }
06124 };
06125 
06126 #ifndef SWIG
06127 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
06128 inline typename _ConstTessMemberResultCallback_5_3<true,R,T1,P1,P2,P3,P4,P5,A1,A2,A3>::base*
06129 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) {
06130   return new _ConstTessMemberResultCallback_5_3<true,R,T1,P1,P2,P3,P4,P5,A1,A2,A3>(obj, member, p1, p2, p3, p4, p5);
06131 }
06132 #endif
06133 
06134 #ifndef SWIG
06135 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
06136 inline typename _ConstTessMemberResultCallback_5_3<false,R,T1,P1,P2,P3,P4,P5,A1,A2,A3>::base*
06137 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) {
06138   return new _ConstTessMemberResultCallback_5_3<false,R,T1,P1,P2,P3,P4,P5,A1,A2,A3>(obj, member, p1, p2, p3, p4, p5);
06139 }
06140 #endif
06141 
06142 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
06143 class _TessMemberResultCallback_5_3 : public TessResultCallback3<R,A1,A2,A3> {
06144  public:
06145   typedef TessResultCallback3<R,A1,A2,A3> base;
06146   typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3) ;
06147 
06148  private:
06149    T* object_;
06150   MemberSignature member_;
06151   typename remove_reference<P1>::type p1_;
06152   typename remove_reference<P2>::type p2_;
06153   typename remove_reference<P3>::type p3_;
06154   typename remove_reference<P4>::type p4_;
06155   typename remove_reference<P5>::type p5_;
06156 
06157  public:
06158   inline _TessMemberResultCallback_5_3( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
06159     : object_(object),
06160       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
06161 
06162   virtual R Run(A1 a1,A2 a2,A3 a3) {
06163     if (!del) {
06164       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
06165       return result;
06166     } else {
06167       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
06168       //  zero out the pointer to ensure segfault if used again
06169       member_ = NULL;
06170       delete this;
06171       return result;
06172     }
06173   }
06174 };
06175 
06176 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
06177 class _TessMemberResultCallback_5_3<del, void, T, P1, P2, P3, P4, P5, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
06178  public:
06179   typedef TessCallback3<A1,A2,A3> base;
06180   typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3) ;
06181 
06182  private:
06183    T* object_;
06184   MemberSignature member_;
06185   typename remove_reference<P1>::type p1_;
06186   typename remove_reference<P2>::type p2_;
06187   typename remove_reference<P3>::type p3_;
06188   typename remove_reference<P4>::type p4_;
06189   typename remove_reference<P5>::type p5_;
06190 
06191  public:
06192   inline _TessMemberResultCallback_5_3( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
06193     : object_(object),
06194       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
06195 
06196   virtual void Run(A1 a1,A2 a2,A3 a3) {
06197     if (!del) {
06198       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
06199     } else {
06200       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
06201       //  zero out the pointer to ensure segfault if used again
06202       member_ = NULL;
06203       delete this;
06204     }
06205   }
06206 };
06207 
06208 #ifndef SWIG
06209 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
06210 inline typename _TessMemberResultCallback_5_3<true,R,T1,P1,P2,P3,P4,P5,A1,A2,A3>::base*
06211 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) {
06212   return new _TessMemberResultCallback_5_3<true,R,T1,P1,P2,P3,P4,P5,A1,A2,A3>(obj, member, p1, p2, p3, p4, p5);
06213 }
06214 #endif
06215 
06216 #ifndef SWIG
06217 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
06218 inline typename _TessMemberResultCallback_5_3<false,R,T1,P1,P2,P3,P4,P5,A1,A2,A3>::base*
06219 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) {
06220   return new _TessMemberResultCallback_5_3<false,R,T1,P1,P2,P3,P4,P5,A1,A2,A3>(obj, member, p1, p2, p3, p4, p5);
06221 }
06222 #endif
06223 
06224 template <bool del, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
06225 class _TessFunctionResultCallback_5_3 : public TessResultCallback3<R,A1,A2,A3> {
06226  public:
06227   typedef TessResultCallback3<R,A1,A2,A3> base;
06228   typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2,A3);
06229 
06230  private:
06231   FunctionSignature function_;
06232   typename remove_reference<P1>::type p1_;
06233   typename remove_reference<P2>::type p2_;
06234   typename remove_reference<P3>::type p3_;
06235   typename remove_reference<P4>::type p4_;
06236   typename remove_reference<P5>::type p5_;
06237 
06238  public:
06239   inline _TessFunctionResultCallback_5_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
06240     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
06241 
06242   virtual R Run(A1 a1,A2 a2,A3 a3) {
06243     if (!del) {
06244       R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
06245       return result;
06246     } else {
06247       R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
06248       //  zero out the pointer to ensure segfault if used again
06249       function_ = NULL;
06250       delete this;
06251       return result;
06252     }
06253   }
06254 };
06255 
06256 template <bool del, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
06257 class _TessFunctionResultCallback_5_3<del, void, P1, P2, P3, P4, P5, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
06258  public:
06259   typedef TessCallback3<A1,A2,A3> base;
06260   typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2,A3);
06261 
06262  private:
06263   FunctionSignature function_;
06264   typename remove_reference<P1>::type p1_;
06265   typename remove_reference<P2>::type p2_;
06266   typename remove_reference<P3>::type p3_;
06267   typename remove_reference<P4>::type p4_;
06268   typename remove_reference<P5>::type p5_;
06269 
06270  public:
06271   inline _TessFunctionResultCallback_5_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
06272     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
06273 
06274   virtual void Run(A1 a1,A2 a2,A3 a3) {
06275     if (!del) {
06276       (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
06277     } else {
06278       (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
06279       //  zero out the pointer to ensure segfault if used again
06280       function_ = NULL;
06281       delete this;
06282     }
06283   }
06284 };
06285 
06286 template <class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
06287 inline typename _TessFunctionResultCallback_5_3<true,R,P1,P2,P3,P4,P5,A1,A2,A3>::base*
06288 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) {
06289   return new _TessFunctionResultCallback_5_3<true,R,P1,P2,P3,P4,P5,A1,A2,A3>(function, p1, p2, p3, p4, p5);
06290 }
06291 
06292 template <class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
06293 inline typename _TessFunctionResultCallback_5_3<false,R,P1,P2,P3,P4,P5,A1,A2,A3>::base*
06294 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) {
06295   return new _TessFunctionResultCallback_5_3<false,R,P1,P2,P3,P4,P5,A1,A2,A3>(function, p1, p2, p3, p4, p5);
06296 }
06297 
06298 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>
06299 class _ConstTessMemberResultCallback_6_3 : public TessResultCallback3<R,A1,A2,A3> {
06300  public:
06301   typedef TessResultCallback3<R,A1,A2,A3> base;
06302   typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3) const;
06303 
06304  private:
06305   const T* object_;
06306   MemberSignature member_;
06307   typename remove_reference<P1>::type p1_;
06308   typename remove_reference<P2>::type p2_;
06309   typename remove_reference<P3>::type p3_;
06310   typename remove_reference<P4>::type p4_;
06311   typename remove_reference<P5>::type p5_;
06312   typename remove_reference<P6>::type p6_;
06313 
06314  public:
06315   inline _ConstTessMemberResultCallback_6_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
06316     : object_(object),
06317       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
06318 
06319   virtual R Run(A1 a1,A2 a2,A3 a3) {
06320     if (!del) {
06321       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
06322       return result;
06323     } else {
06324       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
06325       //  zero out the pointer to ensure segfault if used again
06326       member_ = NULL;
06327       delete this;
06328       return result;
06329     }
06330   }
06331 };
06332 
06333 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
06334 class _ConstTessMemberResultCallback_6_3<del, void, T, P1, P2, P3, P4, P5, P6, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
06335  public:
06336   typedef TessCallback3<A1,A2,A3> base;
06337   typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3) const;
06338 
06339  private:
06340   const T* object_;
06341   MemberSignature member_;
06342   typename remove_reference<P1>::type p1_;
06343   typename remove_reference<P2>::type p2_;
06344   typename remove_reference<P3>::type p3_;
06345   typename remove_reference<P4>::type p4_;
06346   typename remove_reference<P5>::type p5_;
06347   typename remove_reference<P6>::type p6_;
06348 
06349  public:
06350   inline _ConstTessMemberResultCallback_6_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
06351     : object_(object),
06352       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
06353 
06354   virtual void Run(A1 a1,A2 a2,A3 a3) {
06355     if (!del) {
06356       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
06357     } else {
06358       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
06359       //  zero out the pointer to ensure segfault if used again
06360       member_ = NULL;
06361       delete this;
06362     }
06363   }
06364 };
06365 
06366 #ifndef SWIG
06367 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>
06368 inline typename _ConstTessMemberResultCallback_6_3<true,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3>::base*
06369 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) {
06370   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);
06371 }
06372 #endif
06373 
06374 #ifndef SWIG
06375 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>
06376 inline typename _ConstTessMemberResultCallback_6_3<false,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3>::base*
06377 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) {
06378   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);
06379 }
06380 #endif
06381 
06382 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>
06383 class _TessMemberResultCallback_6_3 : public TessResultCallback3<R,A1,A2,A3> {
06384  public:
06385   typedef TessResultCallback3<R,A1,A2,A3> base;
06386   typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3) ;
06387 
06388  private:
06389    T* object_;
06390   MemberSignature member_;
06391   typename remove_reference<P1>::type p1_;
06392   typename remove_reference<P2>::type p2_;
06393   typename remove_reference<P3>::type p3_;
06394   typename remove_reference<P4>::type p4_;
06395   typename remove_reference<P5>::type p5_;
06396   typename remove_reference<P6>::type p6_;
06397 
06398  public:
06399   inline _TessMemberResultCallback_6_3( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
06400     : object_(object),
06401       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
06402 
06403   virtual R Run(A1 a1,A2 a2,A3 a3) {
06404     if (!del) {
06405       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
06406       return result;
06407     } else {
06408       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
06409       //  zero out the pointer to ensure segfault if used again
06410       member_ = NULL;
06411       delete this;
06412       return result;
06413     }
06414   }
06415 };
06416 
06417 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
06418 class _TessMemberResultCallback_6_3<del, void, T, P1, P2, P3, P4, P5, P6, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
06419  public:
06420   typedef TessCallback3<A1,A2,A3> base;
06421   typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3) ;
06422 
06423  private:
06424    T* object_;
06425   MemberSignature member_;
06426   typename remove_reference<P1>::type p1_;
06427   typename remove_reference<P2>::type p2_;
06428   typename remove_reference<P3>::type p3_;
06429   typename remove_reference<P4>::type p4_;
06430   typename remove_reference<P5>::type p5_;
06431   typename remove_reference<P6>::type p6_;
06432 
06433  public:
06434   inline _TessMemberResultCallback_6_3( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
06435     : object_(object),
06436       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
06437 
06438   virtual void Run(A1 a1,A2 a2,A3 a3) {
06439     if (!del) {
06440       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
06441     } else {
06442       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
06443       //  zero out the pointer to ensure segfault if used again
06444       member_ = NULL;
06445       delete this;
06446     }
06447   }
06448 };
06449 
06450 #ifndef SWIG
06451 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>
06452 inline typename _TessMemberResultCallback_6_3<true,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3>::base*
06453 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) {
06454   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);
06455 }
06456 #endif
06457 
06458 #ifndef SWIG
06459 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>
06460 inline typename _TessMemberResultCallback_6_3<false,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3>::base*
06461 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) {
06462   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);
06463 }
06464 #endif
06465 
06466 template <bool del, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
06467 class _TessFunctionResultCallback_6_3 : public TessResultCallback3<R,A1,A2,A3> {
06468  public:
06469   typedef TessResultCallback3<R,A1,A2,A3> base;
06470   typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3);
06471 
06472  private:
06473   FunctionSignature function_;
06474   typename remove_reference<P1>::type p1_;
06475   typename remove_reference<P2>::type p2_;
06476   typename remove_reference<P3>::type p3_;
06477   typename remove_reference<P4>::type p4_;
06478   typename remove_reference<P5>::type p5_;
06479   typename remove_reference<P6>::type p6_;
06480 
06481  public:
06482   inline _TessFunctionResultCallback_6_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
06483     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
06484 
06485   virtual R Run(A1 a1,A2 a2,A3 a3) {
06486     if (!del) {
06487       R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
06488       return result;
06489     } else {
06490       R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
06491       //  zero out the pointer to ensure segfault if used again
06492       function_ = NULL;
06493       delete this;
06494       return result;
06495     }
06496   }
06497 };
06498 
06499 template <bool del, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
06500 class _TessFunctionResultCallback_6_3<del, void, P1, P2, P3, P4, P5, P6, A1, A2, A3> : public TessCallback3<A1,A2,A3> {
06501  public:
06502   typedef TessCallback3<A1,A2,A3> base;
06503   typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3);
06504 
06505  private:
06506   FunctionSignature function_;
06507   typename remove_reference<P1>::type p1_;
06508   typename remove_reference<P2>::type p2_;
06509   typename remove_reference<P3>::type p3_;
06510   typename remove_reference<P4>::type p4_;
06511   typename remove_reference<P5>::type p5_;
06512   typename remove_reference<P6>::type p6_;
06513 
06514  public:
06515   inline _TessFunctionResultCallback_6_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
06516     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
06517 
06518   virtual void Run(A1 a1,A2 a2,A3 a3) {
06519     if (!del) {
06520       (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
06521     } else {
06522       (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
06523       //  zero out the pointer to ensure segfault if used again
06524       function_ = NULL;
06525       delete this;
06526     }
06527   }
06528 };
06529 
06530 template <class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
06531 inline typename _TessFunctionResultCallback_6_3<true,R,P1,P2,P3,P4,P5,P6,A1,A2,A3>::base*
06532 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) {
06533   return new _TessFunctionResultCallback_6_3<true,R,P1,P2,P3,P4,P5,P6,A1,A2,A3>(function, p1, p2, p3, p4, p5, p6);
06534 }
06535 
06536 template <class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
06537 inline typename _TessFunctionResultCallback_6_3<false,R,P1,P2,P3,P4,P5,P6,A1,A2,A3>::base*
06538 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) {
06539   return new _TessFunctionResultCallback_6_3<false,R,P1,P2,P3,P4,P5,P6,A1,A2,A3>(function, p1, p2, p3, p4, p5, p6);
06540 }
06541 
06542 template <bool del, class R, class T, class A1, class A2, class A3, class A4>
06543 class _ConstTessMemberResultCallback_0_4 : public TessResultCallback4<R,A1,A2,A3,A4> {
06544  public:
06545   typedef TessResultCallback4<R,A1,A2,A3,A4> base;
06546   typedef R (T::*MemberSignature)(A1,A2,A3,A4) const;
06547 
06548  private:
06549   const T* object_;
06550   MemberSignature member_;
06551 
06552  public:
06553   inline _ConstTessMemberResultCallback_0_4(const T* object, MemberSignature member)
06554     : object_(object),
06555       member_(member) { }
06556 
06557   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
06558     if (!del) {
06559       R result = (object_->*member_)(a1,a2,a3,a4);
06560       return result;
06561     } else {
06562       R result = (object_->*member_)(a1,a2,a3,a4);
06563       //  zero out the pointer to ensure segfault if used again
06564       member_ = NULL;
06565       delete this;
06566       return result;
06567     }
06568   }
06569 };
06570 
06571 template <bool del, class T, class A1, class A2, class A3, class A4>
06572 class _ConstTessMemberResultCallback_0_4<del, void, T, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
06573  public:
06574   typedef TessCallback4<A1,A2,A3,A4> base;
06575   typedef void (T::*MemberSignature)(A1,A2,A3,A4) const;
06576 
06577  private:
06578   const T* object_;
06579   MemberSignature member_;
06580 
06581  public:
06582   inline _ConstTessMemberResultCallback_0_4(const T* object, MemberSignature member)
06583     : object_(object),
06584       member_(member) { }
06585 
06586   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
06587     if (!del) {
06588       (object_->*member_)(a1,a2,a3,a4);
06589     } else {
06590       (object_->*member_)(a1,a2,a3,a4);
06591       //  zero out the pointer to ensure segfault if used again
06592       member_ = NULL;
06593       delete this;
06594     }
06595   }
06596 };
06597 
06598 #ifndef SWIG
06599 template <class T1, class T2, class R, class A1, class A2, class A3, class A4>
06600 inline typename _ConstTessMemberResultCallback_0_4<true,R,T1,A1,A2,A3,A4>::base*
06601 NewTessCallback(const T1* obj, R (T2::*member)(A1,A2,A3,A4) const) {
06602   return new _ConstTessMemberResultCallback_0_4<true,R,T1,A1,A2,A3,A4>(obj, member);
06603 }
06604 #endif
06605 
06606 #ifndef SWIG
06607 template <class T1, class T2, class R, class A1, class A2, class A3, class A4>
06608 inline typename _ConstTessMemberResultCallback_0_4<false,R,T1,A1,A2,A3,A4>::base*
06609 NewPermanentTessCallback(const T1* obj, R (T2::*member)(A1,A2,A3,A4) const) {
06610   return new _ConstTessMemberResultCallback_0_4<false,R,T1,A1,A2,A3,A4>(obj, member);
06611 }
06612 #endif
06613 
06614 template <bool del, class R, class T, class A1, class A2, class A3, class A4>
06615 class _TessMemberResultCallback_0_4 : public TessResultCallback4<R,A1,A2,A3,A4> {
06616  public:
06617   typedef TessResultCallback4<R,A1,A2,A3,A4> base;
06618   typedef R (T::*MemberSignature)(A1,A2,A3,A4) ;
06619 
06620  private:
06621    T* object_;
06622   MemberSignature member_;
06623 
06624  public:
06625   inline _TessMemberResultCallback_0_4( T* object, MemberSignature member)
06626     : object_(object),
06627       member_(member) { }
06628 
06629   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
06630     if (!del) {
06631       R result = (object_->*member_)(a1,a2,a3,a4);
06632       return result;
06633     } else {
06634       R result = (object_->*member_)(a1,a2,a3,a4);
06635      //  zero out the pointer to ensure segfault if used again
06636       member_ = NULL;
06637       delete this;
06638       return result;
06639     }
06640   }
06641 };
06642 
06643 template <bool del, class T, class A1, class A2, class A3, class A4>
06644 class _TessMemberResultCallback_0_4<del, void, T, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
06645  public:
06646   typedef TessCallback4<A1,A2,A3,A4> base;
06647   typedef void (T::*MemberSignature)(A1,A2,A3,A4) ;
06648 
06649  private:
06650    T* object_;
06651   MemberSignature member_;
06652 
06653  public:
06654   inline _TessMemberResultCallback_0_4( T* object, MemberSignature member)
06655     : object_(object),
06656       member_(member) { }
06657 
06658   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
06659     if (!del) {
06660       (object_->*member_)(a1,a2,a3,a4);
06661     } else {
06662       (object_->*member_)(a1,a2,a3,a4);
06663       //  zero out the pointer to ensure segfault if used again
06664       member_ = NULL;
06665       delete this;
06666     }
06667   }
06668 };
06669 
06670 #ifndef SWIG
06671 template <class T1, class T2, class R, class A1, class A2, class A3, class A4>
06672 inline typename _TessMemberResultCallback_0_4<true,R,T1,A1,A2,A3,A4>::base*
06673 NewTessCallback( T1* obj, R (T2::*member)(A1,A2,A3,A4) ) {
06674   return new _TessMemberResultCallback_0_4<true,R,T1,A1,A2,A3,A4>(obj, member);
06675 }
06676 #endif
06677 
06678 #ifndef SWIG
06679 template <class T1, class T2, class R, class A1, class A2, class A3, class A4>
06680 inline typename _TessMemberResultCallback_0_4<false,R,T1,A1,A2,A3,A4>::base*
06681 NewPermanentTessCallback( T1* obj, R (T2::*member)(A1,A2,A3,A4) ) {
06682   return new _TessMemberResultCallback_0_4<false,R,T1,A1,A2,A3,A4>(obj, member);
06683 }
06684 #endif
06685 
06686 template <bool del, class R, class A1, class A2, class A3, class A4>
06687 class _TessFunctionResultCallback_0_4 : public TessResultCallback4<R,A1,A2,A3,A4> {
06688  public:
06689   typedef TessResultCallback4<R,A1,A2,A3,A4> base;
06690   typedef R (*FunctionSignature)(A1,A2,A3,A4);
06691 
06692  private:
06693   FunctionSignature function_;
06694 
06695  public:
06696   inline _TessFunctionResultCallback_0_4(FunctionSignature function)
06697     : function_(function) { }
06698 
06699   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
06700     if (!del) {
06701       R result = (*function_)(a1,a2,a3,a4);
06702       return result;
06703     } else {
06704       R result = (*function_)(a1,a2,a3,a4);
06705       //  zero out the pointer to ensure segfault if used again
06706       function_ = NULL;
06707       delete this;
06708       return result;
06709     }
06710   }
06711 };
06712 
06713 template <bool del, class A1, class A2, class A3, class A4>
06714 class _TessFunctionResultCallback_0_4<del, void, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
06715  public:
06716   typedef TessCallback4<A1,A2,A3,A4> base;
06717   typedef void (*FunctionSignature)(A1,A2,A3,A4);
06718 
06719  private:
06720   FunctionSignature function_;
06721 
06722  public:
06723   inline _TessFunctionResultCallback_0_4(FunctionSignature function)
06724     : function_(function) { }
06725 
06726   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
06727     if (!del) {
06728       (*function_)(a1,a2,a3,a4);
06729     } else {
06730       (*function_)(a1,a2,a3,a4);
06731       //  zero out the pointer to ensure segfault if used again
06732       function_ = NULL;
06733       delete this;
06734     }
06735   }
06736 };
06737 
06738 template <class R, class A1, class A2, class A3, class A4>
06739 inline typename _TessFunctionResultCallback_0_4<true,R,A1,A2,A3,A4>::base*
06740 NewTessCallback(R (*function)(A1,A2,A3,A4)) {
06741   return new _TessFunctionResultCallback_0_4<true,R,A1,A2,A3,A4>(function);
06742 }
06743 
06744 template <class R, class A1, class A2, class A3, class A4>
06745 inline typename _TessFunctionResultCallback_0_4<false,R,A1,A2,A3,A4>::base*
06746 NewPermanentTessCallback(R (*function)(A1,A2,A3,A4)) {
06747   return new _TessFunctionResultCallback_0_4<false,R,A1,A2,A3,A4>(function);
06748 }
06749 
06750 template <bool del, class R, class T, class P1, class A1, class A2, class A3, class A4>
06751 class _ConstTessMemberResultCallback_1_4 : public TessResultCallback4<R,A1,A2,A3,A4> {
06752  public:
06753   typedef TessResultCallback4<R,A1,A2,A3,A4> base;
06754   typedef R (T::*MemberSignature)(P1,A1,A2,A3,A4) const;
06755 
06756  private:
06757   const T* object_;
06758   MemberSignature member_;
06759   typename remove_reference<P1>::type p1_;
06760 
06761  public:
06762   inline _ConstTessMemberResultCallback_1_4(const T* object, MemberSignature member, P1 p1)
06763     : object_(object),
06764       member_(member),      p1_(p1) { }
06765 
06766   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
06767     if (!del) {
06768       R result = (object_->*member_)(p1_,a1,a2,a3,a4);
06769       return result;
06770     } else {
06771       R result = (object_->*member_)(p1_,a1,a2,a3,a4);
06772       //  zero out the pointer to ensure segfault if used again
06773       member_ = NULL;
06774       delete this;
06775       return result;
06776     }
06777   }
06778 };
06779 
06780 template <bool del, class T, class P1, class A1, class A2, class A3, class A4>
06781 class _ConstTessMemberResultCallback_1_4<del, void, T, P1, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
06782  public:
06783   typedef TessCallback4<A1,A2,A3,A4> base;
06784   typedef void (T::*MemberSignature)(P1,A1,A2,A3,A4) const;
06785 
06786  private:
06787   const T* object_;
06788   MemberSignature member_;
06789   typename remove_reference<P1>::type p1_;
06790 
06791  public:
06792   inline _ConstTessMemberResultCallback_1_4(const T* object, MemberSignature member, P1 p1)
06793     : object_(object),
06794       member_(member),      p1_(p1) { }
06795 
06796   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
06797     if (!del) {
06798       (object_->*member_)(p1_,a1,a2,a3,a4);
06799     } else {
06800       (object_->*member_)(p1_,a1,a2,a3,a4);
06801       //  zero out the pointer to ensure segfault if used again
06802       member_ = NULL;
06803       delete this;
06804     }
06805   }
06806 };
06807 
06808 #ifndef SWIG
06809 template <class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4>
06810 inline typename _ConstTessMemberResultCallback_1_4<true,R,T1,P1,A1,A2,A3,A4>::base*
06811 NewTessCallback(const T1* obj, R (T2::*member)(P1,A1,A2,A3,A4) const, typename Identity<P1>::type p1) {
06812   return new _ConstTessMemberResultCallback_1_4<true,R,T1,P1,A1,A2,A3,A4>(obj, member, p1);
06813 }
06814 #endif
06815 
06816 #ifndef SWIG
06817 template <class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4>
06818 inline typename _ConstTessMemberResultCallback_1_4<false,R,T1,P1,A1,A2,A3,A4>::base*
06819 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,A1,A2,A3,A4) const, typename Identity<P1>::type p1) {
06820   return new _ConstTessMemberResultCallback_1_4<false,R,T1,P1,A1,A2,A3,A4>(obj, member, p1);
06821 }
06822 #endif
06823 
06824 template <bool del, class R, class T, class P1, class A1, class A2, class A3, class A4>
06825 class _TessMemberResultCallback_1_4 : public TessResultCallback4<R,A1,A2,A3,A4> {
06826  public:
06827   typedef TessResultCallback4<R,A1,A2,A3,A4> base;
06828   typedef R (T::*MemberSignature)(P1,A1,A2,A3,A4) ;
06829 
06830  private:
06831    T* object_;
06832   MemberSignature member_;
06833   typename remove_reference<P1>::type p1_;
06834 
06835  public:
06836   inline _TessMemberResultCallback_1_4( T* object, MemberSignature member, P1 p1)
06837     : object_(object),
06838       member_(member),      p1_(p1) { }
06839 
06840   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
06841     if (!del) {
06842       R result = (object_->*member_)(p1_,a1,a2,a3,a4);
06843       return result;
06844     } else {
06845       R result = (object_->*member_)(p1_,a1,a2,a3,a4);
06846       //  zero out the pointer to ensure segfault if used again
06847       member_ = NULL;
06848       delete this;
06849       return result;
06850     }
06851   }
06852 };
06853 
06854 template <bool del, class T, class P1, class A1, class A2, class A3, class A4>
06855 class _TessMemberResultCallback_1_4<del, void, T, P1, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
06856  public:
06857   typedef TessCallback4<A1,A2,A3,A4> base;
06858   typedef void (T::*MemberSignature)(P1,A1,A2,A3,A4) ;
06859 
06860  private:
06861    T* object_;
06862   MemberSignature member_;
06863   typename remove_reference<P1>::type p1_;
06864 
06865  public:
06866   inline _TessMemberResultCallback_1_4( T* object, MemberSignature member, P1 p1)
06867     : object_(object),
06868       member_(member),      p1_(p1) { }
06869 
06870   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
06871     if (!del) {
06872       (object_->*member_)(p1_,a1,a2,a3,a4);
06873     } else {
06874       (object_->*member_)(p1_,a1,a2,a3,a4);
06875       //  zero out the pointer to ensure segfault if used again
06876       member_ = NULL;
06877       delete this;
06878     }
06879   }
06880 };
06881 
06882 #ifndef SWIG
06883 template <class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4>
06884 inline typename _TessMemberResultCallback_1_4<true,R,T1,P1,A1,A2,A3,A4>::base*
06885 NewTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3,A4) , typename Identity<P1>::type p1) {
06886   return new _TessMemberResultCallback_1_4<true,R,T1,P1,A1,A2,A3,A4>(obj, member, p1);
06887 }
06888 #endif
06889 
06890 #ifndef SWIG
06891 template <class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4>
06892 inline typename _TessMemberResultCallback_1_4<false,R,T1,P1,A1,A2,A3,A4>::base*
06893 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3,A4) , typename Identity<P1>::type p1) {
06894   return new _TessMemberResultCallback_1_4<false,R,T1,P1,A1,A2,A3,A4>(obj, member, p1);
06895 }
06896 #endif
06897 
06898 template <bool del, class R, class P1, class A1, class A2, class A3, class A4>
06899 class _TessFunctionResultCallback_1_4 : public TessResultCallback4<R,A1,A2,A3,A4> {
06900  public:
06901   typedef TessResultCallback4<R,A1,A2,A3,A4> base;
06902   typedef R (*FunctionSignature)(P1,A1,A2,A3,A4);
06903 
06904  private:
06905   FunctionSignature function_;
06906   typename remove_reference<P1>::type p1_;
06907 
06908  public:
06909   inline _TessFunctionResultCallback_1_4(FunctionSignature function, P1 p1)
06910     : function_(function),      p1_(p1) { }
06911 
06912   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
06913     if (!del) {
06914       R result = (*function_)(p1_,a1,a2,a3,a4);
06915       return result;
06916     } else {
06917       R result = (*function_)(p1_,a1,a2,a3,a4);
06918       //  zero out the pointer to ensure segfault if used again
06919       function_ = NULL;
06920       delete this;
06921       return result;
06922     }
06923   }
06924 };
06925 
06926 template <bool del, class P1, class A1, class A2, class A3, class A4>
06927 class _TessFunctionResultCallback_1_4<del, void, P1, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
06928  public:
06929   typedef TessCallback4<A1,A2,A3,A4> base;
06930   typedef void (*FunctionSignature)(P1,A1,A2,A3,A4);
06931 
06932  private:
06933   FunctionSignature function_;
06934   typename remove_reference<P1>::type p1_;
06935 
06936  public:
06937   inline _TessFunctionResultCallback_1_4(FunctionSignature function, P1 p1)
06938     : function_(function),      p1_(p1) { }
06939 
06940   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
06941     if (!del) {
06942       (*function_)(p1_,a1,a2,a3,a4);
06943     } else {
06944       (*function_)(p1_,a1,a2,a3,a4);
06945       //  zero out the pointer to ensure segfault if used again
06946       function_ = NULL;
06947       delete this;
06948     }
06949   }
06950 };
06951 
06952 template <class R, class P1, class A1, class A2, class A3, class A4>
06953 inline typename _TessFunctionResultCallback_1_4<true,R,P1,A1,A2,A3,A4>::base*
06954 NewTessCallback(R (*function)(P1,A1,A2,A3,A4), typename Identity<P1>::type p1) {
06955   return new _TessFunctionResultCallback_1_4<true,R,P1,A1,A2,A3,A4>(function, p1);
06956 }
06957 
06958 template <class R, class P1, class A1, class A2, class A3, class A4>
06959 inline typename _TessFunctionResultCallback_1_4<false,R,P1,A1,A2,A3,A4>::base*
06960 NewPermanentTessCallback(R (*function)(P1,A1,A2,A3,A4), typename Identity<P1>::type p1) {
06961   return new _TessFunctionResultCallback_1_4<false,R,P1,A1,A2,A3,A4>(function, p1);
06962 }
06963 
06964 template <bool del, class R, class T, class P1, class P2, class A1, class A2, class A3, class A4>
06965 class _ConstTessMemberResultCallback_2_4 : public TessResultCallback4<R,A1,A2,A3,A4> {
06966  public:
06967   typedef TessResultCallback4<R,A1,A2,A3,A4> base;
06968   typedef R (T::*MemberSignature)(P1,P2,A1,A2,A3,A4) const;
06969 
06970  private:
06971   const T* object_;
06972   MemberSignature member_;
06973   typename remove_reference<P1>::type p1_;
06974   typename remove_reference<P2>::type p2_;
06975 
06976  public:
06977   inline _ConstTessMemberResultCallback_2_4(const T* object, MemberSignature member, P1 p1, P2 p2)
06978     : object_(object),
06979       member_(member),      p1_(p1),      p2_(p2) { }
06980 
06981   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
06982     if (!del) {
06983       R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4);
06984       return result;
06985     } else {
06986       R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4);
06987       //  zero out the pointer to ensure segfault if used again
06988       member_ = NULL;
06989       delete this;
06990       return result;
06991     }
06992   }
06993 };
06994 
06995 template <bool del, class T, class P1, class P2, class A1, class A2, class A3, class A4>
06996 class _ConstTessMemberResultCallback_2_4<del, void, T, P1, P2, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
06997  public:
06998   typedef TessCallback4<A1,A2,A3,A4> base;
06999   typedef void (T::*MemberSignature)(P1,P2,A1,A2,A3,A4) const;
07000 
07001  private:
07002   const T* object_;
07003   MemberSignature member_;
07004   typename remove_reference<P1>::type p1_;
07005   typename remove_reference<P2>::type p2_;
07006 
07007  public:
07008   inline _ConstTessMemberResultCallback_2_4(const T* object, MemberSignature member, P1 p1, P2 p2)
07009     : object_(object),
07010       member_(member),      p1_(p1),      p2_(p2) { }
07011 
07012   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
07013     if (!del) {
07014       (object_->*member_)(p1_,p2_,a1,a2,a3,a4);
07015     } else {
07016       (object_->*member_)(p1_,p2_,a1,a2,a3,a4);
07017       //  zero out the pointer to ensure segfault if used again
07018       member_ = NULL;
07019       delete this;
07020     }
07021   }
07022 };
07023 
07024 #ifndef SWIG
07025 template <class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4>
07026 inline typename _ConstTessMemberResultCallback_2_4<true,R,T1,P1,P2,A1,A2,A3,A4>::base*
07027 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
07028   return new _ConstTessMemberResultCallback_2_4<true,R,T1,P1,P2,A1,A2,A3,A4>(obj, member, p1, p2);
07029 }
07030 #endif
07031 
07032 #ifndef SWIG
07033 template <class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4>
07034 inline typename _ConstTessMemberResultCallback_2_4<false,R,T1,P1,P2,A1,A2,A3,A4>::base*
07035 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
07036   return new _ConstTessMemberResultCallback_2_4<false,R,T1,P1,P2,A1,A2,A3,A4>(obj, member, p1, p2);
07037 }
07038 #endif
07039 
07040 template <bool del, class R, class T, class P1, class P2, class A1, class A2, class A3, class A4>
07041 class _TessMemberResultCallback_2_4 : public TessResultCallback4<R,A1,A2,A3,A4> {
07042  public:
07043   typedef TessResultCallback4<R,A1,A2,A3,A4> base;
07044   typedef R (T::*MemberSignature)(P1,P2,A1,A2,A3,A4) ;
07045 
07046  private:
07047    T* object_;
07048   MemberSignature member_;
07049   typename remove_reference<P1>::type p1_;
07050   typename remove_reference<P2>::type p2_;
07051 
07052  public:
07053   inline _TessMemberResultCallback_2_4( T* object, MemberSignature member, P1 p1, P2 p2)
07054     : object_(object),
07055       member_(member),      p1_(p1),      p2_(p2) { }
07056 
07057   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
07058     if (!del) {
07059       R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4);
07060       return result;
07061     } else {
07062       R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4);
07063       //  zero out the pointer to ensure segfault if used again
07064       member_ = NULL;
07065       delete this;
07066       return result;
07067     }
07068   }
07069 };
07070 
07071 template <bool del, class T, class P1, class P2, class A1, class A2, class A3, class A4>
07072 class _TessMemberResultCallback_2_4<del, void, T, P1, P2, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
07073  public:
07074   typedef TessCallback4<A1,A2,A3,A4> base;
07075   typedef void (T::*MemberSignature)(P1,P2,A1,A2,A3,A4) ;
07076 
07077  private:
07078    T* object_;
07079   MemberSignature member_;
07080   typename remove_reference<P1>::type p1_;
07081   typename remove_reference<P2>::type p2_;
07082 
07083  public:
07084   inline _TessMemberResultCallback_2_4( T* object, MemberSignature member, P1 p1, P2 p2)
07085     : object_(object),
07086       member_(member),      p1_(p1),      p2_(p2) { }
07087 
07088   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
07089     if (!del) {
07090       (object_->*member_)(p1_,p2_,a1,a2,a3,a4);
07091     } else {
07092       (object_->*member_)(p1_,p2_,a1,a2,a3,a4);
07093       //  zero out the pointer to ensure segfault if used again
07094       member_ = NULL;
07095       delete this;
07096     }
07097   }
07098 };
07099 
07100 #ifndef SWIG
07101 template <class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4>
07102 inline typename _TessMemberResultCallback_2_4<true,R,T1,P1,P2,A1,A2,A3,A4>::base*
07103 NewTessCallback( T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4) , typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
07104   return new _TessMemberResultCallback_2_4<true,R,T1,P1,P2,A1,A2,A3,A4>(obj, member, p1, p2);
07105 }
07106 #endif
07107 
07108 #ifndef SWIG
07109 template <class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4>
07110 inline typename _TessMemberResultCallback_2_4<false,R,T1,P1,P2,A1,A2,A3,A4>::base*
07111 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4) , typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
07112   return new _TessMemberResultCallback_2_4<false,R,T1,P1,P2,A1,A2,A3,A4>(obj, member, p1, p2);
07113 }
07114 #endif
07115 
07116 template <bool del, class R, class P1, class P2, class A1, class A2, class A3, class A4>
07117 class _TessFunctionResultCallback_2_4 : public TessResultCallback4<R,A1,A2,A3,A4> {
07118  public:
07119   typedef TessResultCallback4<R,A1,A2,A3,A4> base;
07120   typedef R (*FunctionSignature)(P1,P2,A1,A2,A3,A4);
07121 
07122  private:
07123   FunctionSignature function_;
07124   typename remove_reference<P1>::type p1_;
07125   typename remove_reference<P2>::type p2_;
07126 
07127  public:
07128   inline _TessFunctionResultCallback_2_4(FunctionSignature function, P1 p1, P2 p2)
07129     : function_(function),      p1_(p1),      p2_(p2) { }
07130 
07131   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
07132     if (!del) {
07133       R result = (*function_)(p1_,p2_,a1,a2,a3,a4);
07134       return result;
07135     } else {
07136       R result = (*function_)(p1_,p2_,a1,a2,a3,a4);
07137       //  zero out the pointer to ensure segfault if used again
07138       function_ = NULL;
07139       delete this;
07140       return result;
07141     }
07142   }
07143 };
07144 
07145 template <bool del, class P1, class P2, class A1, class A2, class A3, class A4>
07146 class _TessFunctionResultCallback_2_4<del, void, P1, P2, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
07147  public:
07148   typedef TessCallback4<A1,A2,A3,A4> base;
07149   typedef void (*FunctionSignature)(P1,P2,A1,A2,A3,A4);
07150 
07151  private:
07152   FunctionSignature function_;
07153   typename remove_reference<P1>::type p1_;
07154   typename remove_reference<P2>::type p2_;
07155 
07156  public:
07157   inline _TessFunctionResultCallback_2_4(FunctionSignature function, P1 p1, P2 p2)
07158     : function_(function),      p1_(p1),      p2_(p2) { }
07159 
07160   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
07161     if (!del) {
07162       (*function_)(p1_,p2_,a1,a2,a3,a4);
07163     } else {
07164       (*function_)(p1_,p2_,a1,a2,a3,a4);
07165       //  zero out the pointer to ensure segfault if used again
07166       function_ = NULL;
07167       delete this;
07168     }
07169   }
07170 };
07171 
07172 template <class R, class P1, class P2, class A1, class A2, class A3, class A4>
07173 inline typename _TessFunctionResultCallback_2_4<true,R,P1,P2,A1,A2,A3,A4>::base*
07174 NewTessCallback(R (*function)(P1,P2,A1,A2,A3,A4), typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
07175   return new _TessFunctionResultCallback_2_4<true,R,P1,P2,A1,A2,A3,A4>(function, p1, p2);
07176 }
07177 
07178 template <class R, class P1, class P2, class A1, class A2, class A3, class A4>
07179 inline typename _TessFunctionResultCallback_2_4<false,R,P1,P2,A1,A2,A3,A4>::base*
07180 NewPermanentTessCallback(R (*function)(P1,P2,A1,A2,A3,A4), typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
07181   return new _TessFunctionResultCallback_2_4<false,R,P1,P2,A1,A2,A3,A4>(function, p1, p2);
07182 }
07183 
07184 template <bool del, class R, class T, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
07185 class _ConstTessMemberResultCallback_3_4 : public TessResultCallback4<R,A1,A2,A3,A4> {
07186  public:
07187   typedef TessResultCallback4<R,A1,A2,A3,A4> base;
07188   typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4) const;
07189 
07190  private:
07191   const T* object_;
07192   MemberSignature member_;
07193   typename remove_reference<P1>::type p1_;
07194   typename remove_reference<P2>::type p2_;
07195   typename remove_reference<P3>::type p3_;
07196 
07197  public:
07198   inline _ConstTessMemberResultCallback_3_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
07199     : object_(object),
07200       member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }
07201 
07202   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
07203     if (!del) {
07204       R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4);
07205       return result;
07206     } else {
07207       R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4);
07208       //  zero out the pointer to ensure segfault if used again
07209       member_ = NULL;
07210       delete this;
07211       return result;
07212     }
07213   }
07214 };
07215 
07216 template <bool del, class T, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
07217 class _ConstTessMemberResultCallback_3_4<del, void, T, P1, P2, P3, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
07218  public:
07219   typedef TessCallback4<A1,A2,A3,A4> base;
07220   typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4) const;
07221 
07222  private:
07223   const T* object_;
07224   MemberSignature member_;
07225   typename remove_reference<P1>::type p1_;
07226   typename remove_reference<P2>::type p2_;
07227   typename remove_reference<P3>::type p3_;
07228 
07229  public:
07230   inline _ConstTessMemberResultCallback_3_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
07231     : object_(object),
07232       member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }
07233 
07234   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
07235     if (!del) {
07236       (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4);
07237     } else {
07238       (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4);
07239       //  zero out the pointer to ensure segfault if used again
07240       member_ = NULL;
07241       delete this;
07242     }
07243   }
07244 };
07245 
07246 #ifndef SWIG
07247 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
07248 inline typename _ConstTessMemberResultCallback_3_4<true,R,T1,P1,P2,P3,A1,A2,A3,A4>::base*
07249 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) {
07250   return new _ConstTessMemberResultCallback_3_4<true,R,T1,P1,P2,P3,A1,A2,A3,A4>(obj, member, p1, p2, p3);
07251 }
07252 #endif
07253 
07254 #ifndef SWIG
07255 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
07256 inline typename _ConstTessMemberResultCallback_3_4<false,R,T1,P1,P2,P3,A1,A2,A3,A4>::base*
07257 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) {
07258   return new _ConstTessMemberResultCallback_3_4<false,R,T1,P1,P2,P3,A1,A2,A3,A4>(obj, member, p1, p2, p3);
07259 }
07260 #endif
07261 
07262 template <bool del, class R, class T, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
07263 class _TessMemberResultCallback_3_4 : public TessResultCallback4<R,A1,A2,A3,A4> {
07264  public:
07265   typedef TessResultCallback4<R,A1,A2,A3,A4> base;
07266   typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4) ;
07267 
07268  private:
07269    T* object_;
07270   MemberSignature member_;
07271   typename remove_reference<P1>::type p1_;
07272   typename remove_reference<P2>::type p2_;
07273   typename remove_reference<P3>::type p3_;
07274 
07275  public:
07276   inline _TessMemberResultCallback_3_4( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
07277     : object_(object),
07278       member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }
07279 
07280   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
07281     if (!del) {
07282       R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4);
07283       return result;
07284     } else {
07285       R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4);
07286       //  zero out the pointer to ensure segfault if used again
07287       member_ = NULL;
07288       delete this;
07289       return result;
07290     }
07291   }
07292 };
07293 
07294 template <bool del, class T, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
07295 class _TessMemberResultCallback_3_4<del, void, T, P1, P2, P3, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
07296  public:
07297   typedef TessCallback4<A1,A2,A3,A4> base;
07298   typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4) ;
07299 
07300  private:
07301    T* object_;
07302   MemberSignature member_;
07303   typename remove_reference<P1>::type p1_;
07304   typename remove_reference<P2>::type p2_;
07305   typename remove_reference<P3>::type p3_;
07306 
07307  public:
07308   inline _TessMemberResultCallback_3_4( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
07309     : object_(object),
07310       member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }
07311 
07312   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
07313     if (!del) {
07314       (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4);
07315     } else {
07316       (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4);
07317       //  zero out the pointer to ensure segfault if used again
07318       member_ = NULL;
07319       delete this;
07320     }
07321   }
07322 };
07323 
07324 #ifndef SWIG
07325 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
07326 inline typename _TessMemberResultCallback_3_4<true,R,T1,P1,P2,P3,A1,A2,A3,A4>::base*
07327 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) {
07328   return new _TessMemberResultCallback_3_4<true,R,T1,P1,P2,P3,A1,A2,A3,A4>(obj, member, p1, p2, p3);
07329 }
07330 #endif
07331 
07332 #ifndef SWIG
07333 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
07334 inline typename _TessMemberResultCallback_3_4<false,R,T1,P1,P2,P3,A1,A2,A3,A4>::base*
07335 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) {
07336   return new _TessMemberResultCallback_3_4<false,R,T1,P1,P2,P3,A1,A2,A3,A4>(obj, member, p1, p2, p3);
07337 }
07338 #endif
07339 
07340 template <bool del, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
07341 class _TessFunctionResultCallback_3_4 : public TessResultCallback4<R,A1,A2,A3,A4> {
07342  public:
07343   typedef TessResultCallback4<R,A1,A2,A3,A4> base;
07344   typedef R (*FunctionSignature)(P1,P2,P3,A1,A2,A3,A4);
07345 
07346  private:
07347   FunctionSignature function_;
07348   typename remove_reference<P1>::type p1_;
07349   typename remove_reference<P2>::type p2_;
07350   typename remove_reference<P3>::type p3_;
07351 
07352  public:
07353   inline _TessFunctionResultCallback_3_4(FunctionSignature function, P1 p1, P2 p2, P3 p3)
07354     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3) { }
07355 
07356   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
07357     if (!del) {
07358       R result = (*function_)(p1_,p2_,p3_,a1,a2,a3,a4);
07359       return result;
07360     } else {
07361       R result = (*function_)(p1_,p2_,p3_,a1,a2,a3,a4);
07362       //  zero out the pointer to ensure segfault if used again
07363       function_ = NULL;
07364       delete this;
07365       return result;
07366     }
07367   }
07368 };
07369 
07370 template <bool del, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
07371 class _TessFunctionResultCallback_3_4<del, void, P1, P2, P3, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
07372  public:
07373   typedef TessCallback4<A1,A2,A3,A4> base;
07374   typedef void (*FunctionSignature)(P1,P2,P3,A1,A2,A3,A4);
07375 
07376  private:
07377   FunctionSignature function_;
07378   typename remove_reference<P1>::type p1_;
07379   typename remove_reference<P2>::type p2_;
07380   typename remove_reference<P3>::type p3_;
07381 
07382  public:
07383   inline _TessFunctionResultCallback_3_4(FunctionSignature function, P1 p1, P2 p2, P3 p3)
07384     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3) { }
07385 
07386   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
07387     if (!del) {
07388       (*function_)(p1_,p2_,p3_,a1,a2,a3,a4);
07389     } else {
07390       (*function_)(p1_,p2_,p3_,a1,a2,a3,a4);
07391       //  zero out the pointer to ensure segfault if used again
07392       function_ = NULL;
07393       delete this;
07394     }
07395   }
07396 };
07397 
07398 template <class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
07399 inline typename _TessFunctionResultCallback_3_4<true,R,P1,P2,P3,A1,A2,A3,A4>::base*
07400 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) {
07401   return new _TessFunctionResultCallback_3_4<true,R,P1,P2,P3,A1,A2,A3,A4>(function, p1, p2, p3);
07402 }
07403 
07404 template <class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
07405 inline typename _TessFunctionResultCallback_3_4<false,R,P1,P2,P3,A1,A2,A3,A4>::base*
07406 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) {
07407   return new _TessFunctionResultCallback_3_4<false,R,P1,P2,P3,A1,A2,A3,A4>(function, p1, p2, p3);
07408 }
07409 
07410 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
07411 class _ConstTessMemberResultCallback_4_4 : public TessResultCallback4<R,A1,A2,A3,A4> {
07412  public:
07413   typedef TessResultCallback4<R,A1,A2,A3,A4> base;
07414   typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4) const;
07415 
07416  private:
07417   const T* object_;
07418   MemberSignature member_;
07419   typename remove_reference<P1>::type p1_;
07420   typename remove_reference<P2>::type p2_;
07421   typename remove_reference<P3>::type p3_;
07422   typename remove_reference<P4>::type p4_;
07423 
07424  public:
07425   inline _ConstTessMemberResultCallback_4_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
07426     : object_(object),
07427       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
07428 
07429   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
07430     if (!del) {
07431       R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
07432       return result;
07433     } else {
07434       R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
07435       //  zero out the pointer to ensure segfault if used again
07436       member_ = NULL;
07437       delete this;
07438       return result;
07439     }
07440   }
07441 };
07442 
07443 template <bool del, class T, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
07444 class _ConstTessMemberResultCallback_4_4<del, void, T, P1, P2, P3, P4, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
07445  public:
07446   typedef TessCallback4<A1,A2,A3,A4> base;
07447   typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4) const;
07448 
07449  private:
07450   const T* object_;
07451   MemberSignature member_;
07452   typename remove_reference<P1>::type p1_;
07453   typename remove_reference<P2>::type p2_;
07454   typename remove_reference<P3>::type p3_;
07455   typename remove_reference<P4>::type p4_;
07456 
07457  public:
07458   inline _ConstTessMemberResultCallback_4_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
07459     : object_(object),
07460       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
07461 
07462   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
07463     if (!del) {
07464       (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
07465     } else {
07466       (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
07467       //  zero out the pointer to ensure segfault if used again
07468       member_ = NULL;
07469       delete this;
07470     }
07471   }
07472 };
07473 
07474 #ifndef SWIG
07475 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
07476 inline typename _ConstTessMemberResultCallback_4_4<true,R,T1,P1,P2,P3,P4,A1,A2,A3,A4>::base*
07477 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) {
07478   return new _ConstTessMemberResultCallback_4_4<true,R,T1,P1,P2,P3,P4,A1,A2,A3,A4>(obj, member, p1, p2, p3, p4);
07479 }
07480 #endif
07481 
07482 #ifndef SWIG
07483 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
07484 inline typename _ConstTessMemberResultCallback_4_4<false,R,T1,P1,P2,P3,P4,A1,A2,A3,A4>::base*
07485 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) {
07486   return new _ConstTessMemberResultCallback_4_4<false,R,T1,P1,P2,P3,P4,A1,A2,A3,A4>(obj, member, p1, p2, p3, p4);
07487 }
07488 #endif
07489 
07490 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
07491 class _TessMemberResultCallback_4_4 : public TessResultCallback4<R,A1,A2,A3,A4> {
07492  public:
07493   typedef TessResultCallback4<R,A1,A2,A3,A4> base;
07494   typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4) ;
07495 
07496  private:
07497    T* object_;
07498   MemberSignature member_;
07499   typename remove_reference<P1>::type p1_;
07500   typename remove_reference<P2>::type p2_;
07501   typename remove_reference<P3>::type p3_;
07502   typename remove_reference<P4>::type p4_;
07503 
07504  public:
07505   inline _TessMemberResultCallback_4_4( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
07506     : object_(object),
07507       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
07508 
07509   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
07510     if (!del) {
07511       R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
07512       return result;
07513     } else {
07514       R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
07515       //  zero out the pointer to ensure segfault if used again
07516       member_ = NULL;
07517       delete this;
07518       return result;
07519     }
07520   }
07521 };
07522 
07523 template <bool del, class T, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
07524 class _TessMemberResultCallback_4_4<del, void, T, P1, P2, P3, P4, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
07525  public:
07526   typedef TessCallback4<A1,A2,A3,A4> base;
07527   typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4) ;
07528 
07529  private:
07530    T* object_;
07531   MemberSignature member_;
07532   typename remove_reference<P1>::type p1_;
07533   typename remove_reference<P2>::type p2_;
07534   typename remove_reference<P3>::type p3_;
07535   typename remove_reference<P4>::type p4_;
07536 
07537  public:
07538   inline _TessMemberResultCallback_4_4( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
07539     : object_(object),
07540       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
07541 
07542   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
07543     if (!del) {
07544       (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
07545     } else {
07546       (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
07547       //  zero out the pointer to ensure segfault if used again
07548       member_ = NULL;
07549       delete this;
07550     }
07551   }
07552 };
07553 
07554 #ifndef SWIG
07555 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
07556 inline typename _TessMemberResultCallback_4_4<true,R,T1,P1,P2,P3,P4,A1,A2,A3,A4>::base*
07557 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) {
07558   return new _TessMemberResultCallback_4_4<true,R,T1,P1,P2,P3,P4,A1,A2,A3,A4>(obj, member, p1, p2, p3, p4);
07559 }
07560 #endif
07561 
07562 #ifndef SWIG
07563 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
07564 inline typename _TessMemberResultCallback_4_4<false,R,T1,P1,P2,P3,P4,A1,A2,A3,A4>::base*
07565 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) {
07566   return new _TessMemberResultCallback_4_4<false,R,T1,P1,P2,P3,P4,A1,A2,A3,A4>(obj, member, p1, p2, p3, p4);
07567 }
07568 #endif
07569 
07570 template <bool del, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
07571 class _TessFunctionResultCallback_4_4 : public TessResultCallback4<R,A1,A2,A3,A4> {
07572  public:
07573   typedef TessResultCallback4<R,A1,A2,A3,A4> base;
07574   typedef R (*FunctionSignature)(P1,P2,P3,P4,A1,A2,A3,A4);
07575 
07576  private:
07577   FunctionSignature function_;
07578   typename remove_reference<P1>::type p1_;
07579   typename remove_reference<P2>::type p2_;
07580   typename remove_reference<P3>::type p3_;
07581   typename remove_reference<P4>::type p4_;
07582 
07583  public:
07584   inline _TessFunctionResultCallback_4_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
07585     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
07586 
07587   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
07588     if (!del) {
07589       R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
07590       return result;
07591     } else {
07592       R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
07593       //  zero out the pointer to ensure segfault if used again
07594       function_ = NULL;
07595       delete this;
07596       return result;
07597     }
07598   }
07599 };
07600 
07601 template <bool del, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
07602 class _TessFunctionResultCallback_4_4<del, void, P1, P2, P3, P4, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
07603  public:
07604   typedef TessCallback4<A1,A2,A3,A4> base;
07605   typedef void (*FunctionSignature)(P1,P2,P3,P4,A1,A2,A3,A4);
07606 
07607  private:
07608   FunctionSignature function_;
07609   typename remove_reference<P1>::type p1_;
07610   typename remove_reference<P2>::type p2_;
07611   typename remove_reference<P3>::type p3_;
07612   typename remove_reference<P4>::type p4_;
07613 
07614  public:
07615   inline _TessFunctionResultCallback_4_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
07616     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
07617 
07618   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
07619     if (!del) {
07620       (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
07621     } else {
07622       (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
07623       //  zero out the pointer to ensure segfault if used again
07624       function_ = NULL;
07625       delete this;
07626     }
07627   }
07628 };
07629 
07630 template <class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
07631 inline typename _TessFunctionResultCallback_4_4<true,R,P1,P2,P3,P4,A1,A2,A3,A4>::base*
07632 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) {
07633   return new _TessFunctionResultCallback_4_4<true,R,P1,P2,P3,P4,A1,A2,A3,A4>(function, p1, p2, p3, p4);
07634 }
07635 
07636 template <class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
07637 inline typename _TessFunctionResultCallback_4_4<false,R,P1,P2,P3,P4,A1,A2,A3,A4>::base*
07638 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) {
07639   return new _TessFunctionResultCallback_4_4<false,R,P1,P2,P3,P4,A1,A2,A3,A4>(function, p1, p2, p3, p4);
07640 }
07641 
07642 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>
07643 class _ConstTessMemberResultCallback_5_4 : public TessResultCallback4<R,A1,A2,A3,A4> {
07644  public:
07645   typedef TessResultCallback4<R,A1,A2,A3,A4> base;
07646   typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4) const;
07647 
07648  private:
07649   const T* object_;
07650   MemberSignature member_;
07651   typename remove_reference<P1>::type p1_;
07652   typename remove_reference<P2>::type p2_;
07653   typename remove_reference<P3>::type p3_;
07654   typename remove_reference<P4>::type p4_;
07655   typename remove_reference<P5>::type p5_;
07656 
07657  public:
07658   inline _ConstTessMemberResultCallback_5_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
07659     : object_(object),
07660       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
07661 
07662   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
07663     if (!del) {
07664       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
07665       return result;
07666     } else {
07667       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
07668       //  zero out the pointer to ensure segfault if used again
07669       member_ = NULL;
07670       delete this;
07671       return result;
07672     }
07673   }
07674 };
07675 
07676 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
07677 class _ConstTessMemberResultCallback_5_4<del, void, T, P1, P2, P3, P4, P5, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
07678  public:
07679   typedef TessCallback4<A1,A2,A3,A4> base;
07680   typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4) const;
07681 
07682  private:
07683   const T* object_;
07684   MemberSignature member_;
07685   typename remove_reference<P1>::type p1_;
07686   typename remove_reference<P2>::type p2_;
07687   typename remove_reference<P3>::type p3_;
07688   typename remove_reference<P4>::type p4_;
07689   typename remove_reference<P5>::type p5_;
07690 
07691  public:
07692   inline _ConstTessMemberResultCallback_5_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
07693     : object_(object),
07694       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
07695 
07696   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
07697     if (!del) {
07698       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
07699     } else {
07700       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
07701       //  zero out the pointer to ensure segfault if used again
07702       member_ = NULL;
07703       delete this;
07704     }
07705   }
07706 };
07707 
07708 #ifndef SWIG
07709 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>
07710 inline typename _ConstTessMemberResultCallback_5_4<true,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4>::base*
07711 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) {
07712   return new _ConstTessMemberResultCallback_5_4<true,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4>(obj, member, p1, p2, p3, p4, p5);
07713 }
07714 #endif
07715 
07716 #ifndef SWIG
07717 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>
07718 inline typename _ConstTessMemberResultCallback_5_4<false,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4>::base*
07719 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) {
07720   return new _ConstTessMemberResultCallback_5_4<false,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4>(obj, member, p1, p2, p3, p4, p5);
07721 }
07722 #endif
07723 
07724 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>
07725 class _TessMemberResultCallback_5_4 : public TessResultCallback4<R,A1,A2,A3,A4> {
07726  public:
07727   typedef TessResultCallback4<R,A1,A2,A3,A4> base;
07728   typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4) ;
07729 
07730  private:
07731    T* object_;
07732   MemberSignature member_;
07733   typename remove_reference<P1>::type p1_;
07734   typename remove_reference<P2>::type p2_;
07735   typename remove_reference<P3>::type p3_;
07736   typename remove_reference<P4>::type p4_;
07737   typename remove_reference<P5>::type p5_;
07738 
07739  public:
07740   inline _TessMemberResultCallback_5_4( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
07741     : object_(object),
07742       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
07743 
07744   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
07745     if (!del) {
07746       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
07747       return result;
07748     } else {
07749       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
07750       //  zero out the pointer to ensure segfault if used again
07751       member_ = NULL;
07752       delete this;
07753       return result;
07754     }
07755   }
07756 };
07757 
07758 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
07759 class _TessMemberResultCallback_5_4<del, void, T, P1, P2, P3, P4, P5, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
07760  public:
07761   typedef TessCallback4<A1,A2,A3,A4> base;
07762   typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4) ;
07763 
07764  private:
07765    T* object_;
07766   MemberSignature member_;
07767   typename remove_reference<P1>::type p1_;
07768   typename remove_reference<P2>::type p2_;
07769   typename remove_reference<P3>::type p3_;
07770   typename remove_reference<P4>::type p4_;
07771   typename remove_reference<P5>::type p5_;
07772 
07773  public:
07774   inline _TessMemberResultCallback_5_4( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
07775     : object_(object),
07776       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
07777 
07778   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
07779     if (!del) {
07780       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
07781     } else {
07782       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
07783       //  zero out the pointer to ensure segfault if used again
07784       member_ = NULL;
07785       delete this;
07786     }
07787   }
07788 };
07789 
07790 #ifndef SWIG
07791 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>
07792 inline typename _TessMemberResultCallback_5_4<true,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4>::base*
07793 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) {
07794   return new _TessMemberResultCallback_5_4<true,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4>(obj, member, p1, p2, p3, p4, p5);
07795 }
07796 #endif
07797 
07798 #ifndef SWIG
07799 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>
07800 inline typename _TessMemberResultCallback_5_4<false,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4>::base*
07801 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) {
07802   return new _TessMemberResultCallback_5_4<false,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4>(obj, member, p1, p2, p3, p4, p5);
07803 }
07804 #endif
07805 
07806 template <bool del, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
07807 class _TessFunctionResultCallback_5_4 : public TessResultCallback4<R,A1,A2,A3,A4> {
07808  public:
07809   typedef TessResultCallback4<R,A1,A2,A3,A4> base;
07810   typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4);
07811 
07812  private:
07813   FunctionSignature function_;
07814   typename remove_reference<P1>::type p1_;
07815   typename remove_reference<P2>::type p2_;
07816   typename remove_reference<P3>::type p3_;
07817   typename remove_reference<P4>::type p4_;
07818   typename remove_reference<P5>::type p5_;
07819 
07820  public:
07821   inline _TessFunctionResultCallback_5_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
07822     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
07823 
07824   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
07825     if (!del) {
07826       R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
07827       return result;
07828     } else {
07829       R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
07830       //  zero out the pointer to ensure segfault if used again
07831       function_ = NULL;
07832       delete this;
07833       return result;
07834     }
07835   }
07836 };
07837 
07838 template <bool del, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
07839 class _TessFunctionResultCallback_5_4<del, void, P1, P2, P3, P4, P5, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
07840  public:
07841   typedef TessCallback4<A1,A2,A3,A4> base;
07842   typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4);
07843 
07844  private:
07845   FunctionSignature function_;
07846   typename remove_reference<P1>::type p1_;
07847   typename remove_reference<P2>::type p2_;
07848   typename remove_reference<P3>::type p3_;
07849   typename remove_reference<P4>::type p4_;
07850   typename remove_reference<P5>::type p5_;
07851 
07852  public:
07853   inline _TessFunctionResultCallback_5_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
07854     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
07855 
07856   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
07857     if (!del) {
07858       (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
07859     } else {
07860       (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
07861       //  zero out the pointer to ensure segfault if used again
07862       function_ = NULL;
07863       delete this;
07864     }
07865   }
07866 };
07867 
07868 template <class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
07869 inline typename _TessFunctionResultCallback_5_4<true,R,P1,P2,P3,P4,P5,A1,A2,A3,A4>::base*
07870 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) {
07871   return new _TessFunctionResultCallback_5_4<true,R,P1,P2,P3,P4,P5,A1,A2,A3,A4>(function, p1, p2, p3, p4, p5);
07872 }
07873 
07874 template <class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
07875 inline typename _TessFunctionResultCallback_5_4<false,R,P1,P2,P3,P4,P5,A1,A2,A3,A4>::base*
07876 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) {
07877   return new _TessFunctionResultCallback_5_4<false,R,P1,P2,P3,P4,P5,A1,A2,A3,A4>(function, p1, p2, p3, p4, p5);
07878 }
07879 
07880 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>
07881 class _ConstTessMemberResultCallback_6_4 : public TessResultCallback4<R,A1,A2,A3,A4> {
07882  public:
07883   typedef TessResultCallback4<R,A1,A2,A3,A4> base;
07884   typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) const;
07885 
07886  private:
07887   const T* object_;
07888   MemberSignature member_;
07889   typename remove_reference<P1>::type p1_;
07890   typename remove_reference<P2>::type p2_;
07891   typename remove_reference<P3>::type p3_;
07892   typename remove_reference<P4>::type p4_;
07893   typename remove_reference<P5>::type p5_;
07894   typename remove_reference<P6>::type p6_;
07895 
07896  public:
07897   inline _ConstTessMemberResultCallback_6_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
07898     : object_(object),
07899       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
07900 
07901   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
07902     if (!del) {
07903       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
07904       return result;
07905     } else {
07906       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
07907       //  zero out the pointer to ensure segfault if used again
07908       member_ = NULL;
07909       delete this;
07910       return result;
07911     }
07912   }
07913 };
07914 
07915 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>
07916 class _ConstTessMemberResultCallback_6_4<del, void, T, P1, P2, P3, P4, P5, P6, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
07917  public:
07918   typedef TessCallback4<A1,A2,A3,A4> base;
07919   typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) const;
07920 
07921  private:
07922   const T* object_;
07923   MemberSignature member_;
07924   typename remove_reference<P1>::type p1_;
07925   typename remove_reference<P2>::type p2_;
07926   typename remove_reference<P3>::type p3_;
07927   typename remove_reference<P4>::type p4_;
07928   typename remove_reference<P5>::type p5_;
07929   typename remove_reference<P6>::type p6_;
07930 
07931  public:
07932   inline _ConstTessMemberResultCallback_6_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
07933     : object_(object),
07934       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
07935 
07936   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
07937     if (!del) {
07938       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
07939     } else {
07940       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
07941       //  zero out the pointer to ensure segfault if used again
07942       member_ = NULL;
07943       delete this;
07944     }
07945   }
07946 };
07947 
07948 #ifndef SWIG
07949 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>
07950 inline typename _ConstTessMemberResultCallback_6_4<true,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4>::base*
07951 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) {
07952   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);
07953 }
07954 #endif
07955 
07956 #ifndef SWIG
07957 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>
07958 inline typename _ConstTessMemberResultCallback_6_4<false,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4>::base*
07959 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) {
07960   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);
07961 }
07962 #endif
07963 
07964 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>
07965 class _TessMemberResultCallback_6_4 : public TessResultCallback4<R,A1,A2,A3,A4> {
07966  public:
07967   typedef TessResultCallback4<R,A1,A2,A3,A4> base;
07968   typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) ;
07969 
07970  private:
07971    T* object_;
07972   MemberSignature member_;
07973   typename remove_reference<P1>::type p1_;
07974   typename remove_reference<P2>::type p2_;
07975   typename remove_reference<P3>::type p3_;
07976   typename remove_reference<P4>::type p4_;
07977   typename remove_reference<P5>::type p5_;
07978   typename remove_reference<P6>::type p6_;
07979 
07980  public:
07981   inline _TessMemberResultCallback_6_4( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
07982     : object_(object),
07983       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
07984 
07985   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
07986     if (!del) {
07987       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
07988       return result;
07989     } else {
07990       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
07991       //  zero out the pointer to ensure segfault if used again
07992       member_ = NULL;
07993       delete this;
07994       return result;
07995     }
07996   }
07997 };
07998 
07999 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>
08000 class _TessMemberResultCallback_6_4<del, void, T, P1, P2, P3, P4, P5, P6, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
08001  public:
08002   typedef TessCallback4<A1,A2,A3,A4> base;
08003   typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) ;
08004 
08005  private:
08006    T* object_;
08007   MemberSignature member_;
08008   typename remove_reference<P1>::type p1_;
08009   typename remove_reference<P2>::type p2_;
08010   typename remove_reference<P3>::type p3_;
08011   typename remove_reference<P4>::type p4_;
08012   typename remove_reference<P5>::type p5_;
08013   typename remove_reference<P6>::type p6_;
08014 
08015  public:
08016   inline _TessMemberResultCallback_6_4( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
08017     : object_(object),
08018       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
08019 
08020   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
08021     if (!del) {
08022       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
08023     } else {
08024       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
08025       //  zero out the pointer to ensure segfault if used again
08026       member_ = NULL;
08027       delete this;
08028     }
08029   }
08030 };
08031 
08032 #ifndef SWIG
08033 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>
08034 inline typename _TessMemberResultCallback_6_4<true,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4>::base*
08035 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) {
08036   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);
08037 }
08038 #endif
08039 
08040 #ifndef SWIG
08041 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>
08042 inline typename _TessMemberResultCallback_6_4<false,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4>::base*
08043 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) {
08044   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);
08045 }
08046 #endif
08047 
08048 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>
08049 class _TessFunctionResultCallback_6_4 : public TessResultCallback4<R,A1,A2,A3,A4> {
08050  public:
08051   typedef TessResultCallback4<R,A1,A2,A3,A4> base;
08052   typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4);
08053 
08054  private:
08055   FunctionSignature function_;
08056   typename remove_reference<P1>::type p1_;
08057   typename remove_reference<P2>::type p2_;
08058   typename remove_reference<P3>::type p3_;
08059   typename remove_reference<P4>::type p4_;
08060   typename remove_reference<P5>::type p5_;
08061   typename remove_reference<P6>::type p6_;
08062 
08063  public:
08064   inline _TessFunctionResultCallback_6_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
08065     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
08066 
08067   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
08068     if (!del) {
08069       R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
08070       return result;
08071     } else {
08072       R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
08073       //  zero out the pointer to ensure segfault if used again
08074       function_ = NULL;
08075       delete this;
08076       return result;
08077     }
08078   }
08079 };
08080 
08081 template <bool del, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4>
08082 class _TessFunctionResultCallback_6_4<del, void, P1, P2, P3, P4, P5, P6, A1, A2, A3, A4> : public TessCallback4<A1,A2,A3,A4> {
08083  public:
08084   typedef TessCallback4<A1,A2,A3,A4> base;
08085   typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4);
08086 
08087  private:
08088   FunctionSignature function_;
08089   typename remove_reference<P1>::type p1_;
08090   typename remove_reference<P2>::type p2_;
08091   typename remove_reference<P3>::type p3_;
08092   typename remove_reference<P4>::type p4_;
08093   typename remove_reference<P5>::type p5_;
08094   typename remove_reference<P6>::type p6_;
08095 
08096  public:
08097   inline _TessFunctionResultCallback_6_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
08098     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
08099 
08100   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
08101     if (!del) {
08102       (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
08103     } else {
08104       (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
08105       //  zero out the pointer to ensure segfault if used again
08106       function_ = NULL;
08107       delete this;
08108     }
08109   }
08110 };
08111 
08112 template <class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4>
08113 inline typename _TessFunctionResultCallback_6_4<true,R,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4>::base*
08114 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) {
08115   return new _TessFunctionResultCallback_6_4<true,R,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4>(function, p1, p2, p3, p4, p5, p6);
08116 }
08117 
08118 template <class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4>
08119 inline typename _TessFunctionResultCallback_6_4<false,R,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4>::base*
08120 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) {
08121   return new _TessFunctionResultCallback_6_4<false,R,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4>(function, p1, p2, p3, p4, p5, p6);
08122 }
08123 
08124 template <class A1,class A2,class A3,class A4,class A5>
08125 class TessCallback5 {
08126  public:
08127   virtual ~TessCallback5() { }
08128   virtual void Run(A1,A2,A3,A4,A5) = 0;
08129 };
08130 
08131 template <class R, class A1,class A2,class A3,class A4,class A5>
08132 class TessResultCallback5 {
08133  public:
08134   virtual ~TessResultCallback5() { }
08135   virtual R Run(A1,A2,A3,A4,A5) = 0;
08136 };
08137 
08138 template <bool del, class R, class T, class A1, class A2, class A3, class A4, class A5>
08139 class _ConstTessMemberResultCallback_0_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
08140  public:
08141   typedef TessResultCallback5<R,A1,A2,A3,A4,A5> base;
08142   typedef R (T::*MemberSignature)(A1,A2,A3,A4,A5) const;
08143 
08144  private:
08145   const T* object_;
08146   MemberSignature member_;
08147 
08148  public:
08149   inline _ConstTessMemberResultCallback_0_5(const T* object, MemberSignature member)
08150     : object_(object),
08151       member_(member) { }
08152 
08153   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
08154     if (!del) {
08155       R result = (object_->*member_)(a1,a2,a3,a4,a5);
08156       return result;
08157     } else {
08158       R result = (object_->*member_)(a1,a2,a3,a4,a5);
08159       //  zero out the pointer to ensure segfault if used again
08160       member_ = NULL;
08161       delete this;
08162       return result;
08163     }
08164   }
08165 };
08166 
08167 template <bool del, class T, class A1, class A2, class A3, class A4, class A5>
08168 class _ConstTessMemberResultCallback_0_5<del, void, T, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
08169  public:
08170   typedef TessCallback5<A1,A2,A3,A4,A5> base;
08171   typedef void (T::*MemberSignature)(A1,A2,A3,A4,A5) const;
08172 
08173  private:
08174   const T* object_;
08175   MemberSignature member_;
08176 
08177  public:
08178   inline _ConstTessMemberResultCallback_0_5(const T* object, MemberSignature member)
08179     : object_(object),
08180       member_(member) { }
08181 
08182   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
08183     if (!del) {
08184       (object_->*member_)(a1,a2,a3,a4,a5);
08185     } else {
08186       (object_->*member_)(a1,a2,a3,a4,a5);
08187       //  zero out the pointer to ensure segfault if used again
08188       member_ = NULL;
08189       delete this;
08190     }
08191   }
08192 };
08193 
08194 #ifndef SWIG
08195 template <class T1, class T2, class R, class A1, class A2, class A3, class A4, class A5>
08196 inline typename _ConstTessMemberResultCallback_0_5<true,R,T1,A1,A2,A3,A4,A5>::base*
08197 NewTessCallback(const T1* obj, R (T2::*member)(A1,A2,A3,A4,A5) const) {
08198   return new _ConstTessMemberResultCallback_0_5<true,R,T1,A1,A2,A3,A4,A5>(obj, member);
08199 }
08200 #endif
08201 
08202 #ifndef SWIG
08203 template <class T1, class T2, class R, class A1, class A2, class A3, class A4, class A5>
08204 inline typename _ConstTessMemberResultCallback_0_5<false,R,T1,A1,A2,A3,A4,A5>::base*
08205 NewPermanentTessCallback(const T1* obj, R (T2::*member)(A1,A2,A3,A4,A5) const) {
08206   return new _ConstTessMemberResultCallback_0_5<false,R,T1,A1,A2,A3,A4,A5>(obj, member);
08207 }
08208 #endif
08209 
08210 template <bool del, class R, class T, class A1, class A2, class A3, class A4, class A5>
08211 class _TessMemberResultCallback_0_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
08212  public:
08213   typedef TessResultCallback5<R,A1,A2,A3,A4,A5> base;
08214   typedef R (T::*MemberSignature)(A1,A2,A3,A4,A5) ;
08215 
08216  private:
08217    T* object_;
08218   MemberSignature member_;
08219 
08220  public:
08221   inline _TessMemberResultCallback_0_5( T* object, MemberSignature member)
08222     : object_(object),
08223       member_(member) { }
08224 
08225   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
08226     if (!del) {
08227       R result = (object_->*member_)(a1,a2,a3,a4,a5);
08228       return result;
08229     } else {
08230       R result = (object_->*member_)(a1,a2,a3,a4,a5);
08231       //  zero out the pointer to ensure segfault if used again
08232       member_ = NULL;
08233       delete this;
08234       return result;
08235     }
08236   }
08237 };
08238 
08239 template <bool del, class T, class A1, class A2, class A3, class A4, class A5>
08240 class _TessMemberResultCallback_0_5<del, void, T, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
08241  public:
08242   typedef TessCallback5<A1,A2,A3,A4,A5> base;
08243   typedef void (T::*MemberSignature)(A1,A2,A3,A4,A5) ;
08244 
08245  private:
08246    T* object_;
08247   MemberSignature member_;
08248 
08249  public:
08250   inline _TessMemberResultCallback_0_5( T* object, MemberSignature member)
08251     : object_(object),
08252       member_(member) { }
08253 
08254   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
08255     if (!del) {
08256       (object_->*member_)(a1,a2,a3,a4,a5);
08257     } else {
08258       (object_->*member_)(a1,a2,a3,a4,a5);
08259       //  zero out the pointer to ensure segfault if used again
08260       member_ = NULL;
08261       delete this;
08262     }
08263   }
08264 };
08265 
08266 #ifndef SWIG
08267 template <class T1, class T2, class R, class A1, class A2, class A3, class A4, class A5>
08268 inline typename _TessMemberResultCallback_0_5<true,R,T1,A1,A2,A3,A4,A5>::base*
08269 NewTessCallback( T1* obj, R (T2::*member)(A1,A2,A3,A4,A5) ) {
08270   return new _TessMemberResultCallback_0_5<true,R,T1,A1,A2,A3,A4,A5>(obj, member);
08271 }
08272 #endif
08273 
08274 #ifndef SWIG
08275 template <class T1, class T2, class R, class A1, class A2, class A3, class A4, class A5>
08276 inline typename _TessMemberResultCallback_0_5<false,R,T1,A1,A2,A3,A4,A5>::base*
08277 NewPermanentTessCallback( T1* obj, R (T2::*member)(A1,A2,A3,A4,A5) ) {
08278   return new _TessMemberResultCallback_0_5<false,R,T1,A1,A2,A3,A4,A5>(obj, member);
08279 }
08280 #endif
08281 
08282 template <bool del, class R, class A1, class A2, class A3, class A4, class A5>
08283 class _TessFunctionResultCallback_0_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
08284  public:
08285   typedef TessResultCallback5<R,A1,A2,A3,A4,A5> base;
08286   typedef R (*FunctionSignature)(A1,A2,A3,A4,A5);
08287 
08288  private:
08289   FunctionSignature function_;
08290 
08291  public:
08292   inline _TessFunctionResultCallback_0_5(FunctionSignature function)
08293     : function_(function) { }
08294 
08295   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
08296     if (!del) {
08297       R result = (*function_)(a1,a2,a3,a4,a5);
08298       return result;
08299     } else {
08300       R result = (*function_)(a1,a2,a3,a4,a5);
08301       //  zero out the pointer to ensure segfault if used again
08302       function_ = NULL;
08303       delete this;
08304       return result;
08305     }
08306   }
08307 };
08308 
08309 template <bool del, class A1, class A2, class A3, class A4, class A5>
08310 class _TessFunctionResultCallback_0_5<del, void, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
08311  public:
08312   typedef TessCallback5<A1,A2,A3,A4,A5> base;
08313   typedef void (*FunctionSignature)(A1,A2,A3,A4,A5);
08314 
08315  private:
08316   FunctionSignature function_;
08317 
08318  public:
08319   inline _TessFunctionResultCallback_0_5(FunctionSignature function)
08320     : function_(function) { }
08321 
08322   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
08323     if (!del) {
08324       (*function_)(a1,a2,a3,a4,a5);
08325     } else {
08326       (*function_)(a1,a2,a3,a4,a5);
08327       //  zero out the pointer to ensure segfault if used again
08328       function_ = NULL;
08329       delete this;
08330     }
08331   }
08332 };
08333 
08334 template <class R, class A1, class A2, class A3, class A4, class A5>
08335 inline typename _TessFunctionResultCallback_0_5<true,R,A1,A2,A3,A4,A5>::base*
08336 NewTessCallback(R (*function)(A1,A2,A3,A4,A5)) {
08337   return new _TessFunctionResultCallback_0_5<true,R,A1,A2,A3,A4,A5>(function);
08338 }
08339 
08340 template <class R, class A1, class A2, class A3, class A4, class A5>
08341 inline typename _TessFunctionResultCallback_0_5<false,R,A1,A2,A3,A4,A5>::base*
08342 NewPermanentTessCallback(R (*function)(A1,A2,A3,A4,A5)) {
08343   return new _TessFunctionResultCallback_0_5<false,R,A1,A2,A3,A4,A5>(function);
08344 }
08345 
08346 template <bool del, class R, class T, class P1, class A1, class A2, class A3, class A4, class A5>
08347 class _ConstTessMemberResultCallback_1_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
08348  public:
08349   typedef TessResultCallback5<R,A1,A2,A3,A4,A5> base;
08350   typedef R (T::*MemberSignature)(P1,A1,A2,A3,A4,A5) const;
08351 
08352  private:
08353   const T* object_;
08354   MemberSignature member_;
08355   typename remove_reference<P1>::type p1_;
08356 
08357  public:
08358   inline _ConstTessMemberResultCallback_1_5(const T* object, MemberSignature member, P1 p1)
08359     : object_(object),
08360       member_(member),      p1_(p1) { }
08361 
08362   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
08363     if (!del) {
08364       R result = (object_->*member_)(p1_,a1,a2,a3,a4,a5);
08365       return result;
08366     } else {
08367       R result = (object_->*member_)(p1_,a1,a2,a3,a4,a5);
08368       //  zero out the pointer to ensure segfault if used again
08369       member_ = NULL;
08370       delete this;
08371       return result;
08372     }
08373   }
08374 };
08375 
08376 template <bool del, class T, class P1, class A1, class A2, class A3, class A4, class A5>
08377 class _ConstTessMemberResultCallback_1_5<del, void, T, P1, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
08378  public:
08379   typedef TessCallback5<A1,A2,A3,A4,A5> base;
08380   typedef void (T::*MemberSignature)(P1,A1,A2,A3,A4,A5) const;
08381 
08382  private:
08383   const T* object_;
08384   MemberSignature member_;
08385   typename remove_reference<P1>::type p1_;
08386 
08387  public:
08388   inline _ConstTessMemberResultCallback_1_5(const T* object, MemberSignature member, P1 p1)
08389     : object_(object),
08390       member_(member),      p1_(p1) { }
08391 
08392   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
08393     if (!del) {
08394       (object_->*member_)(p1_,a1,a2,a3,a4,a5);
08395     } else {
08396       (object_->*member_)(p1_,a1,a2,a3,a4,a5);
08397       //  zero out the pointer to ensure segfault if used again
08398       member_ = NULL;
08399       delete this;
08400     }
08401   }
08402 };
08403 
08404 #ifndef SWIG
08405 template <class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4, class A5>
08406 inline typename _ConstTessMemberResultCallback_1_5<true,R,T1,P1,A1,A2,A3,A4,A5>::base*
08407 NewTessCallback(const T1* obj, R (T2::*member)(P1,A1,A2,A3,A4,A5) const, typename Identity<P1>::type p1) {
08408   return new _ConstTessMemberResultCallback_1_5<true,R,T1,P1,A1,A2,A3,A4,A5>(obj, member, p1);
08409 }
08410 #endif
08411 
08412 #ifndef SWIG
08413 template <class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4, class A5>
08414 inline typename _ConstTessMemberResultCallback_1_5<false,R,T1,P1,A1,A2,A3,A4,A5>::base*
08415 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,A1,A2,A3,A4,A5) const, typename Identity<P1>::type p1) {
08416   return new _ConstTessMemberResultCallback_1_5<false,R,T1,P1,A1,A2,A3,A4,A5>(obj, member, p1);
08417 }
08418 #endif
08419 
08420 template <bool del, class R, class T, class P1, class A1, class A2, class A3, class A4, class A5>
08421 class _TessMemberResultCallback_1_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
08422  public:
08423   typedef TessResultCallback5<R,A1,A2,A3,A4,A5> base;
08424   typedef R (T::*MemberSignature)(P1,A1,A2,A3,A4,A5) ;
08425 
08426  private:
08427    T* object_;
08428   MemberSignature member_;
08429   typename remove_reference<P1>::type p1_;
08430 
08431  public:
08432   inline _TessMemberResultCallback_1_5( T* object, MemberSignature member, P1 p1)
08433     : object_(object),
08434       member_(member),      p1_(p1) { }
08435 
08436   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
08437     if (!del) {
08438       R result = (object_->*member_)(p1_,a1,a2,a3,a4,a5);
08439       return result;
08440     } else {
08441       R result = (object_->*member_)(p1_,a1,a2,a3,a4,a5);
08442       //  zero out the pointer to ensure segfault if used again
08443       member_ = NULL;
08444       delete this;
08445       return result;
08446     }
08447   }
08448 };
08449 
08450 template <bool del, class T, class P1, class A1, class A2, class A3, class A4, class A5>
08451 class _TessMemberResultCallback_1_5<del, void, T, P1, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
08452  public:
08453   typedef TessCallback5<A1,A2,A3,A4,A5> base;
08454   typedef void (T::*MemberSignature)(P1,A1,A2,A3,A4,A5) ;
08455 
08456  private:
08457    T* object_;
08458   MemberSignature member_;
08459   typename remove_reference<P1>::type p1_;
08460 
08461  public:
08462   inline _TessMemberResultCallback_1_5( T* object, MemberSignature member, P1 p1)
08463     : object_(object),
08464       member_(member),      p1_(p1) { }
08465 
08466   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
08467     if (!del) {
08468       (object_->*member_)(p1_,a1,a2,a3,a4,a5);
08469     } else {
08470       (object_->*member_)(p1_,a1,a2,a3,a4,a5);
08471       //  zero out the pointer to ensure segfault if used again
08472       member_ = NULL;
08473       delete this;
08474     }
08475   }
08476 };
08477 
08478 #ifndef SWIG
08479 template <class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4, class A5>
08480 inline typename _TessMemberResultCallback_1_5<true,R,T1,P1,A1,A2,A3,A4,A5>::base*
08481 NewTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3,A4,A5) , typename Identity<P1>::type p1) {
08482   return new _TessMemberResultCallback_1_5<true,R,T1,P1,A1,A2,A3,A4,A5>(obj, member, p1);
08483 }
08484 #endif
08485 
08486 #ifndef SWIG
08487 template <class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4, class A5>
08488 inline typename _TessMemberResultCallback_1_5<false,R,T1,P1,A1,A2,A3,A4,A5>::base*
08489 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3,A4,A5) , typename Identity<P1>::type p1) {
08490   return new _TessMemberResultCallback_1_5<false,R,T1,P1,A1,A2,A3,A4,A5>(obj, member, p1);
08491 }
08492 #endif
08493 
08494 template <bool del, class R, class P1, class A1, class A2, class A3, class A4, class A5>
08495 class _TessFunctionResultCallback_1_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
08496  public:
08497   typedef TessResultCallback5<R,A1,A2,A3,A4,A5> base;
08498   typedef R (*FunctionSignature)(P1,A1,A2,A3,A4,A5);
08499 
08500  private:
08501   FunctionSignature function_;
08502   typename remove_reference<P1>::type p1_;
08503 
08504  public:
08505   inline _TessFunctionResultCallback_1_5(FunctionSignature function, P1 p1)
08506     : function_(function),      p1_(p1) { }
08507 
08508   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
08509     if (!del) {
08510       R result = (*function_)(p1_,a1,a2,a3,a4,a5);
08511       return result;
08512     } else {
08513       R result = (*function_)(p1_,a1,a2,a3,a4,a5);
08514       //  zero out the pointer to ensure segfault if used again
08515       function_ = NULL;
08516       delete this;
08517       return result;
08518     }
08519   }
08520 };
08521 
08522 template <bool del, class P1, class A1, class A2, class A3, class A4, class A5>
08523 class _TessFunctionResultCallback_1_5<del, void, P1, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
08524  public:
08525   typedef TessCallback5<A1,A2,A3,A4,A5> base;
08526   typedef void (*FunctionSignature)(P1,A1,A2,A3,A4,A5);
08527 
08528  private:
08529   FunctionSignature function_;
08530   typename remove_reference<P1>::type p1_;
08531 
08532  public:
08533   inline _TessFunctionResultCallback_1_5(FunctionSignature function, P1 p1)
08534     : function_(function),      p1_(p1) { }
08535 
08536   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
08537     if (!del) {
08538       (*function_)(p1_,a1,a2,a3,a4,a5);
08539     } else {
08540       (*function_)(p1_,a1,a2,a3,a4,a5);
08541       //  zero out the pointer to ensure segfault if used again
08542       function_ = NULL;
08543       delete this;
08544     }
08545   }
08546 };
08547 
08548 template <class R, class P1, class A1, class A2, class A3, class A4, class A5>
08549 inline typename _TessFunctionResultCallback_1_5<true,R,P1,A1,A2,A3,A4,A5>::base*
08550 NewTessCallback(R (*function)(P1,A1,A2,A3,A4,A5), typename Identity<P1>::type p1) {
08551   return new _TessFunctionResultCallback_1_5<true,R,P1,A1,A2,A3,A4,A5>(function, p1);
08552 }
08553 
08554 template <class R, class P1, class A1, class A2, class A3, class A4, class A5>
08555 inline typename _TessFunctionResultCallback_1_5<false,R,P1,A1,A2,A3,A4,A5>::base*
08556 NewPermanentTessCallback(R (*function)(P1,A1,A2,A3,A4,A5), typename Identity<P1>::type p1) {
08557   return new _TessFunctionResultCallback_1_5<false,R,P1,A1,A2,A3,A4,A5>(function, p1);
08558 }
08559 
08560 template <bool del, class R, class T, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
08561 class _ConstTessMemberResultCallback_2_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
08562  public:
08563   typedef TessResultCallback5<R,A1,A2,A3,A4,A5> base;
08564   typedef R (T::*MemberSignature)(P1,P2,A1,A2,A3,A4,A5) const;
08565 
08566  private:
08567   const T* object_;
08568   MemberSignature member_;
08569   typename remove_reference<P1>::type p1_;
08570   typename remove_reference<P2>::type p2_;
08571 
08572  public:
08573   inline _ConstTessMemberResultCallback_2_5(const T* object, MemberSignature member, P1 p1, P2 p2)
08574     : object_(object),
08575       member_(member),      p1_(p1),      p2_(p2) { }
08576 
08577   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
08578     if (!del) {
08579       R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5);
08580       return result;
08581     } else {
08582       R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5);
08583       //  zero out the pointer to ensure segfault if used again
08584       member_ = NULL;
08585       delete this;
08586       return result;
08587     }
08588   }
08589 };
08590 
08591 template <bool del, class T, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
08592 class _ConstTessMemberResultCallback_2_5<del, void, T, P1, P2, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
08593  public:
08594   typedef TessCallback5<A1,A2,A3,A4,A5> base;
08595   typedef void (T::*MemberSignature)(P1,P2,A1,A2,A3,A4,A5) const;
08596 
08597  private:
08598   const T* object_;
08599   MemberSignature member_;
08600   typename remove_reference<P1>::type p1_;
08601   typename remove_reference<P2>::type p2_;
08602 
08603  public:
08604   inline _ConstTessMemberResultCallback_2_5(const T* object, MemberSignature member, P1 p1, P2 p2)
08605     : object_(object),
08606       member_(member),      p1_(p1),      p2_(p2) { }
08607 
08608   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
08609     if (!del) {
08610       (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5);
08611     } else {
08612       (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5);
08613       //  zero out the pointer to ensure segfault if used again
08614       member_ = NULL;
08615       delete this;
08616     }
08617   }
08618 };
08619 
08620 #ifndef SWIG
08621 template <class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
08622 inline typename _ConstTessMemberResultCallback_2_5<true,R,T1,P1,P2,A1,A2,A3,A4,A5>::base*
08623 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) {
08624   return new _ConstTessMemberResultCallback_2_5<true,R,T1,P1,P2,A1,A2,A3,A4,A5>(obj, member, p1, p2);
08625 }
08626 #endif
08627 
08628 #ifndef SWIG
08629 template <class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
08630 inline typename _ConstTessMemberResultCallback_2_5<false,R,T1,P1,P2,A1,A2,A3,A4,A5>::base*
08631 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) {
08632   return new _ConstTessMemberResultCallback_2_5<false,R,T1,P1,P2,A1,A2,A3,A4,A5>(obj, member, p1, p2);
08633 }
08634 #endif
08635 
08636 template <bool del, class R, class T, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
08637 class _TessMemberResultCallback_2_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
08638  public:
08639   typedef TessResultCallback5<R,A1,A2,A3,A4,A5> base;
08640   typedef R (T::*MemberSignature)(P1,P2,A1,A2,A3,A4,A5) ;
08641 
08642  private:
08643    T* object_;
08644   MemberSignature member_;
08645   typename remove_reference<P1>::type p1_;
08646   typename remove_reference<P2>::type p2_;
08647 
08648  public:
08649   inline _TessMemberResultCallback_2_5( T* object, MemberSignature member, P1 p1, P2 p2)
08650     : object_(object),
08651       member_(member),      p1_(p1),      p2_(p2) { }
08652 
08653   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
08654     if (!del) {
08655       R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5);
08656       return result;
08657     } else {
08658       R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5);
08659       //  zero out the pointer to ensure segfault if used again
08660       member_ = NULL;
08661       delete this;
08662       return result;
08663     }
08664   }
08665 };
08666 
08667 template <bool del, class T, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
08668 class _TessMemberResultCallback_2_5<del, void, T, P1, P2, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
08669  public:
08670   typedef TessCallback5<A1,A2,A3,A4,A5> base;
08671   typedef void (T::*MemberSignature)(P1,P2,A1,A2,A3,A4,A5) ;
08672 
08673  private:
08674    T* object_;
08675   MemberSignature member_;
08676   typename remove_reference<P1>::type p1_;
08677   typename remove_reference<P2>::type p2_;
08678 
08679  public:
08680   inline _TessMemberResultCallback_2_5( T* object, MemberSignature member, P1 p1, P2 p2)
08681     : object_(object),
08682       member_(member),      p1_(p1),      p2_(p2) { }
08683 
08684   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
08685     if (!del) {
08686       (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5);
08687     } else {
08688       (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5);
08689       //  zero out the pointer to ensure segfault if used again
08690       member_ = NULL;
08691       delete this;
08692     }
08693   }
08694 };
08695 
08696 #ifndef SWIG
08697 template <class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
08698 inline typename _TessMemberResultCallback_2_5<true,R,T1,P1,P2,A1,A2,A3,A4,A5>::base*
08699 NewTessCallback( T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4,A5) , typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
08700   return new _TessMemberResultCallback_2_5<true,R,T1,P1,P2,A1,A2,A3,A4,A5>(obj, member, p1, p2);
08701 }
08702 #endif
08703 
08704 #ifndef SWIG
08705 template <class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
08706 inline typename _TessMemberResultCallback_2_5<false,R,T1,P1,P2,A1,A2,A3,A4,A5>::base*
08707 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4,A5) , typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
08708   return new _TessMemberResultCallback_2_5<false,R,T1,P1,P2,A1,A2,A3,A4,A5>(obj, member, p1, p2);
08709 }
08710 #endif
08711 
08712 template <bool del, class R, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
08713 class _TessFunctionResultCallback_2_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
08714  public:
08715   typedef TessResultCallback5<R,A1,A2,A3,A4,A5> base;
08716   typedef R (*FunctionSignature)(P1,P2,A1,A2,A3,A4,A5);
08717 
08718  private:
08719   FunctionSignature function_;
08720   typename remove_reference<P1>::type p1_;
08721   typename remove_reference<P2>::type p2_;
08722 
08723  public:
08724   inline _TessFunctionResultCallback_2_5(FunctionSignature function, P1 p1, P2 p2)
08725     : function_(function),      p1_(p1),      p2_(p2) { }
08726 
08727   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
08728     if (!del) {
08729       R result = (*function_)(p1_,p2_,a1,a2,a3,a4,a5);
08730       return result;
08731     } else {
08732       R result = (*function_)(p1_,p2_,a1,a2,a3,a4,a5);
08733       //  zero out the pointer to ensure segfault if used again
08734       function_ = NULL;
08735       delete this;
08736       return result;
08737     }
08738   }
08739 };
08740 
08741 template <bool del, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
08742 class _TessFunctionResultCallback_2_5<del, void, P1, P2, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
08743  public:
08744   typedef TessCallback5<A1,A2,A3,A4,A5> base;
08745   typedef void (*FunctionSignature)(P1,P2,A1,A2,A3,A4,A5);
08746 
08747  private:
08748   FunctionSignature function_;
08749   typename remove_reference<P1>::type p1_;
08750   typename remove_reference<P2>::type p2_;
08751 
08752  public:
08753   inline _TessFunctionResultCallback_2_5(FunctionSignature function, P1 p1, P2 p2)
08754     : function_(function),      p1_(p1),      p2_(p2) { }
08755 
08756   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
08757     if (!del) {
08758       (*function_)(p1_,p2_,a1,a2,a3,a4,a5);
08759     } else {
08760       (*function_)(p1_,p2_,a1,a2,a3,a4,a5);
08761       //  zero out the pointer to ensure segfault if used again
08762       function_ = NULL;
08763       delete this;
08764     }
08765   }
08766 };
08767 
08768 template <class R, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
08769 inline typename _TessFunctionResultCallback_2_5<true,R,P1,P2,A1,A2,A3,A4,A5>::base*
08770 NewTessCallback(R (*function)(P1,P2,A1,A2,A3,A4,A5), typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
08771   return new _TessFunctionResultCallback_2_5<true,R,P1,P2,A1,A2,A3,A4,A5>(function, p1, p2);
08772 }
08773 
08774 template <class R, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
08775 inline typename _TessFunctionResultCallback_2_5<false,R,P1,P2,A1,A2,A3,A4,A5>::base*
08776 NewPermanentTessCallback(R (*function)(P1,P2,A1,A2,A3,A4,A5), typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
08777   return new _TessFunctionResultCallback_2_5<false,R,P1,P2,A1,A2,A3,A4,A5>(function, p1, p2);
08778 }
08779 
08780 template <bool del, class R, class T, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
08781 class _ConstTessMemberResultCallback_3_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
08782  public:
08783   typedef TessResultCallback5<R,A1,A2,A3,A4,A5> base;
08784   typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4,A5) const;
08785 
08786  private:
08787   const T* object_;
08788   MemberSignature member_;
08789   typename remove_reference<P1>::type p1_;
08790   typename remove_reference<P2>::type p2_;
08791   typename remove_reference<P3>::type p3_;
08792 
08793  public:
08794   inline _ConstTessMemberResultCallback_3_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
08795     : object_(object),
08796       member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }
08797 
08798   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
08799     if (!del) {
08800       R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
08801       return result;
08802     } else {
08803       R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
08804       //  zero out the pointer to ensure segfault if used again
08805       member_ = NULL;
08806       delete this;
08807       return result;
08808     }
08809   }
08810 };
08811 
08812 template <bool del, class T, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
08813 class _ConstTessMemberResultCallback_3_5<del, void, T, P1, P2, P3, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
08814  public:
08815   typedef TessCallback5<A1,A2,A3,A4,A5> base;
08816   typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4,A5) const;
08817 
08818  private:
08819   const T* object_;
08820   MemberSignature member_;
08821   typename remove_reference<P1>::type p1_;
08822   typename remove_reference<P2>::type p2_;
08823   typename remove_reference<P3>::type p3_;
08824 
08825  public:
08826   inline _ConstTessMemberResultCallback_3_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
08827     : object_(object),
08828       member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }
08829 
08830   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
08831     if (!del) {
08832       (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
08833     } else {
08834       (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
08835       //  zero out the pointer to ensure segfault if used again
08836       member_ = NULL;
08837       delete this;
08838     }
08839   }
08840 };
08841 
08842 #ifndef SWIG
08843 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
08844 inline typename _ConstTessMemberResultCallback_3_5<true,R,T1,P1,P2,P3,A1,A2,A3,A4,A5>::base*
08845 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) {
08846   return new _ConstTessMemberResultCallback_3_5<true,R,T1,P1,P2,P3,A1,A2,A3,A4,A5>(obj, member, p1, p2, p3);
08847 }
08848 #endif
08849 
08850 #ifndef SWIG
08851 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
08852 inline typename _ConstTessMemberResultCallback_3_5<false,R,T1,P1,P2,P3,A1,A2,A3,A4,A5>::base*
08853 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) {
08854   return new _ConstTessMemberResultCallback_3_5<false,R,T1,P1,P2,P3,A1,A2,A3,A4,A5>(obj, member, p1, p2, p3);
08855 }
08856 #endif
08857 
08858 template <bool del, class R, class T, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
08859 class _TessMemberResultCallback_3_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
08860  public:
08861   typedef TessResultCallback5<R,A1,A2,A3,A4,A5> base;
08862   typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4,A5) ;
08863 
08864  private:
08865    T* object_;
08866   MemberSignature member_;
08867   typename remove_reference<P1>::type p1_;
08868   typename remove_reference<P2>::type p2_;
08869   typename remove_reference<P3>::type p3_;
08870 
08871  public:
08872   inline _TessMemberResultCallback_3_5( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
08873     : object_(object),
08874       member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }
08875 
08876   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
08877     if (!del) {
08878       R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
08879       return result;
08880     } else {
08881       R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
08882       //  zero out the pointer to ensure segfault if used again
08883       member_ = NULL;
08884       delete this;
08885       return result;
08886     }
08887   }
08888 };
08889 
08890 template <bool del, class T, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
08891 class _TessMemberResultCallback_3_5<del, void, T, P1, P2, P3, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
08892  public:
08893   typedef TessCallback5<A1,A2,A3,A4,A5> base;
08894   typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4,A5) ;
08895 
08896  private:
08897    T* object_;
08898   MemberSignature member_;
08899   typename remove_reference<P1>::type p1_;
08900   typename remove_reference<P2>::type p2_;
08901   typename remove_reference<P3>::type p3_;
08902 
08903  public:
08904   inline _TessMemberResultCallback_3_5( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
08905     : object_(object),
08906       member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }
08907 
08908   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
08909     if (!del) {
08910       (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
08911     } else {
08912       (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
08913       //  zero out the pointer to ensure segfault if used again
08914       member_ = NULL;
08915       delete this;
08916     }
08917   }
08918 };
08919 
08920 #ifndef SWIG
08921 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
08922 inline typename _TessMemberResultCallback_3_5<true,R,T1,P1,P2,P3,A1,A2,A3,A4,A5>::base*
08923 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) {
08924   return new _TessMemberResultCallback_3_5<true,R,T1,P1,P2,P3,A1,A2,A3,A4,A5>(obj, member, p1, p2, p3);
08925 }
08926 #endif
08927 
08928 #ifndef SWIG
08929 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
08930 inline typename _TessMemberResultCallback_3_5<false,R,T1,P1,P2,P3,A1,A2,A3,A4,A5>::base*
08931 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) {
08932   return new _TessMemberResultCallback_3_5<false,R,T1,P1,P2,P3,A1,A2,A3,A4,A5>(obj, member, p1, p2, p3);
08933 }
08934 #endif
08935 
08936 template <bool del, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
08937 class _TessFunctionResultCallback_3_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
08938  public:
08939   typedef TessResultCallback5<R,A1,A2,A3,A4,A5> base;
08940   typedef R (*FunctionSignature)(P1,P2,P3,A1,A2,A3,A4,A5);
08941 
08942  private:
08943   FunctionSignature function_;
08944   typename remove_reference<P1>::type p1_;
08945   typename remove_reference<P2>::type p2_;
08946   typename remove_reference<P3>::type p3_;
08947 
08948  public:
08949   inline _TessFunctionResultCallback_3_5(FunctionSignature function, P1 p1, P2 p2, P3 p3)
08950     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3) { }
08951 
08952   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
08953     if (!del) {
08954       R result = (*function_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
08955       return result;
08956     } else {
08957       R result = (*function_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
08958       //  zero out the pointer to ensure segfault if used again
08959       function_ = NULL;
08960       delete this;
08961       return result;
08962     }
08963   }
08964 };
08965 
08966 template <bool del, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
08967 class _TessFunctionResultCallback_3_5<del, void, P1, P2, P3, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
08968  public:
08969   typedef TessCallback5<A1,A2,A3,A4,A5> base;
08970   typedef void (*FunctionSignature)(P1,P2,P3,A1,A2,A3,A4,A5);
08971 
08972  private:
08973   FunctionSignature function_;
08974   typename remove_reference<P1>::type p1_;
08975   typename remove_reference<P2>::type p2_;
08976   typename remove_reference<P3>::type p3_;
08977 
08978  public:
08979   inline _TessFunctionResultCallback_3_5(FunctionSignature function, P1 p1, P2 p2, P3 p3)
08980     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3) { }
08981 
08982   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
08983     if (!del) {
08984       (*function_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
08985     } else {
08986       (*function_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
08987       //  zero out the pointer to ensure segfault if used again
08988       function_ = NULL;
08989       delete this;
08990     }
08991   }
08992 };
08993 
08994 template <class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
08995 inline typename _TessFunctionResultCallback_3_5<true,R,P1,P2,P3,A1,A2,A3,A4,A5>::base*
08996 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) {
08997   return new _TessFunctionResultCallback_3_5<true,R,P1,P2,P3,A1,A2,A3,A4,A5>(function, p1, p2, p3);
08998 }
08999 
09000 template <class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
09001 inline typename _TessFunctionResultCallback_3_5<false,R,P1,P2,P3,A1,A2,A3,A4,A5>::base*
09002 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) {
09003   return new _TessFunctionResultCallback_3_5<false,R,P1,P2,P3,A1,A2,A3,A4,A5>(function, p1, p2, p3);
09004 }
09005 
09006 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>
09007 class _ConstTessMemberResultCallback_4_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
09008  public:
09009   typedef TessResultCallback5<R,A1,A2,A3,A4,A5> base;
09010   typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4,A5) const;
09011 
09012  private:
09013   const T* object_;
09014   MemberSignature member_;
09015   typename remove_reference<P1>::type p1_;
09016   typename remove_reference<P2>::type p2_;
09017   typename remove_reference<P3>::type p3_;
09018   typename remove_reference<P4>::type p4_;
09019 
09020  public:
09021   inline _ConstTessMemberResultCallback_4_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
09022     : object_(object),
09023       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
09024 
09025   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
09026     if (!del) {
09027       R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
09028       return result;
09029     } else {
09030       R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
09031       //  zero out the pointer to ensure segfault if used again
09032       member_ = NULL;
09033       delete this;
09034       return result;
09035     }
09036   }
09037 };
09038 
09039 template <bool del, class T, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
09040 class _ConstTessMemberResultCallback_4_5<del, void, T, P1, P2, P3, P4, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
09041  public:
09042   typedef TessCallback5<A1,A2,A3,A4,A5> base;
09043   typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4,A5) const;
09044 
09045  private:
09046   const T* object_;
09047   MemberSignature member_;
09048   typename remove_reference<P1>::type p1_;
09049   typename remove_reference<P2>::type p2_;
09050   typename remove_reference<P3>::type p3_;
09051   typename remove_reference<P4>::type p4_;
09052 
09053  public:
09054   inline _ConstTessMemberResultCallback_4_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
09055     : object_(object),
09056       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
09057 
09058   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
09059     if (!del) {
09060       (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
09061     } else {
09062       (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
09063       //  zero out the pointer to ensure segfault if used again
09064       member_ = NULL;
09065       delete this;
09066     }
09067   }
09068 };
09069 
09070 #ifndef SWIG
09071 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>
09072 inline typename _ConstTessMemberResultCallback_4_5<true,R,T1,P1,P2,P3,P4,A1,A2,A3,A4,A5>::base*
09073 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) {
09074   return new _ConstTessMemberResultCallback_4_5<true,R,T1,P1,P2,P3,P4,A1,A2,A3,A4,A5>(obj, member, p1, p2, p3, p4);
09075 }
09076 #endif
09077 
09078 #ifndef SWIG
09079 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>
09080 inline typename _ConstTessMemberResultCallback_4_5<false,R,T1,P1,P2,P3,P4,A1,A2,A3,A4,A5>::base*
09081 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) {
09082   return new _ConstTessMemberResultCallback_4_5<false,R,T1,P1,P2,P3,P4,A1,A2,A3,A4,A5>(obj, member, p1, p2, p3, p4);
09083 }
09084 #endif
09085 
09086 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>
09087 class _TessMemberResultCallback_4_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
09088  public:
09089   typedef TessResultCallback5<R,A1,A2,A3,A4,A5> base;
09090   typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4,A5) ;
09091 
09092  private:
09093    T* object_;
09094   MemberSignature member_;
09095   typename remove_reference<P1>::type p1_;
09096   typename remove_reference<P2>::type p2_;
09097   typename remove_reference<P3>::type p3_;
09098   typename remove_reference<P4>::type p4_;
09099 
09100  public:
09101   inline _TessMemberResultCallback_4_5( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
09102     : object_(object),
09103       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
09104 
09105   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
09106     if (!del) {
09107       R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
09108       return result;
09109     } else {
09110       R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
09111       //  zero out the pointer to ensure segfault if used again
09112       member_ = NULL;
09113       delete this;
09114       return result;
09115     }
09116   }
09117 };
09118 
09119 template <bool del, class T, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
09120 class _TessMemberResultCallback_4_5<del, void, T, P1, P2, P3, P4, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
09121  public:
09122   typedef TessCallback5<A1,A2,A3,A4,A5> base;
09123   typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4,A5) ;
09124 
09125  private:
09126    T* object_;
09127   MemberSignature member_;
09128   typename remove_reference<P1>::type p1_;
09129   typename remove_reference<P2>::type p2_;
09130   typename remove_reference<P3>::type p3_;
09131   typename remove_reference<P4>::type p4_;
09132 
09133  public:
09134   inline _TessMemberResultCallback_4_5( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
09135     : object_(object),
09136       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
09137 
09138   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
09139     if (!del) {
09140       (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
09141     } else {
09142       (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
09143       //  zero out the pointer to ensure segfault if used again
09144       member_ = NULL;
09145       delete this;
09146     }
09147   }
09148 };
09149 
09150 #ifndef SWIG
09151 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>
09152 inline typename _TessMemberResultCallback_4_5<true,R,T1,P1,P2,P3,P4,A1,A2,A3,A4,A5>::base*
09153 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) {
09154   return new _TessMemberResultCallback_4_5<true,R,T1,P1,P2,P3,P4,A1,A2,A3,A4,A5>(obj, member, p1, p2, p3, p4);
09155 }
09156 #endif
09157 
09158 #ifndef SWIG
09159 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>
09160 inline typename _TessMemberResultCallback_4_5<false,R,T1,P1,P2,P3,P4,A1,A2,A3,A4,A5>::base*
09161 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) {
09162   return new _TessMemberResultCallback_4_5<false,R,T1,P1,P2,P3,P4,A1,A2,A3,A4,A5>(obj, member, p1, p2, p3, p4);
09163 }
09164 #endif
09165 
09166 template <bool del, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
09167 class _TessFunctionResultCallback_4_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
09168  public:
09169   typedef TessResultCallback5<R,A1,A2,A3,A4,A5> base;
09170   typedef R (*FunctionSignature)(P1,P2,P3,P4,A1,A2,A3,A4,A5);
09171 
09172  private:
09173   FunctionSignature function_;
09174   typename remove_reference<P1>::type p1_;
09175   typename remove_reference<P2>::type p2_;
09176   typename remove_reference<P3>::type p3_;
09177   typename remove_reference<P4>::type p4_;
09178 
09179  public:
09180   inline _TessFunctionResultCallback_4_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
09181     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
09182 
09183   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
09184     if (!del) {
09185       R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
09186       return result;
09187     } else {
09188       R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
09189       //  zero out the pointer to ensure segfault if used again
09190       function_ = NULL;
09191       delete this;
09192       return result;
09193     }
09194   }
09195 };
09196 
09197 template <bool del, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
09198 class _TessFunctionResultCallback_4_5<del, void, P1, P2, P3, P4, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
09199  public:
09200   typedef TessCallback5<A1,A2,A3,A4,A5> base;
09201   typedef void (*FunctionSignature)(P1,P2,P3,P4,A1,A2,A3,A4,A5);
09202 
09203  private:
09204   FunctionSignature function_;
09205   typename remove_reference<P1>::type p1_;
09206   typename remove_reference<P2>::type p2_;
09207   typename remove_reference<P3>::type p3_;
09208   typename remove_reference<P4>::type p4_;
09209 
09210  public:
09211   inline _TessFunctionResultCallback_4_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
09212     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }
09213 
09214   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
09215     if (!del) {
09216       (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
09217     } else {
09218       (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
09219       //  zero out the pointer to ensure segfault if used again
09220       function_ = NULL;
09221       delete this;
09222     }
09223   }
09224 };
09225 
09226 template <class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
09227 inline typename _TessFunctionResultCallback_4_5<true,R,P1,P2,P3,P4,A1,A2,A3,A4,A5>::base*
09228 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) {
09229   return new _TessFunctionResultCallback_4_5<true,R,P1,P2,P3,P4,A1,A2,A3,A4,A5>(function, p1, p2, p3, p4);
09230 }
09231 
09232 template <class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
09233 inline typename _TessFunctionResultCallback_4_5<false,R,P1,P2,P3,P4,A1,A2,A3,A4,A5>::base*
09234 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) {
09235   return new _TessFunctionResultCallback_4_5<false,R,P1,P2,P3,P4,A1,A2,A3,A4,A5>(function, p1, p2, p3, p4);
09236 }
09237 
09238 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>
09239 class _ConstTessMemberResultCallback_5_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
09240  public:
09241   typedef TessResultCallback5<R,A1,A2,A3,A4,A5> base;
09242   typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) const;
09243 
09244  private:
09245   const T* object_;
09246   MemberSignature member_;
09247   typename remove_reference<P1>::type p1_;
09248   typename remove_reference<P2>::type p2_;
09249   typename remove_reference<P3>::type p3_;
09250   typename remove_reference<P4>::type p4_;
09251   typename remove_reference<P5>::type p5_;
09252 
09253  public:
09254   inline _ConstTessMemberResultCallback_5_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
09255     : object_(object),
09256       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
09257 
09258 
09259   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
09260     if (!del) {
09261       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
09262       return result;
09263     } else {
09264       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
09265       //  zero out the pointer to ensure segfault if used again
09266       member_ = NULL;
09267       delete this;
09268       return result;
09269     }
09270   }
09271 };
09272 
09273 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>
09274 class _ConstTessMemberResultCallback_5_5<del, void, T, P1, P2, P3, P4, P5, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
09275  public:
09276   typedef TessCallback5<A1,A2,A3,A4,A5> base;
09277   typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) const;
09278 
09279  private:
09280   const T* object_;
09281   MemberSignature member_;
09282   typename remove_reference<P1>::type p1_;
09283   typename remove_reference<P2>::type p2_;
09284   typename remove_reference<P3>::type p3_;
09285   typename remove_reference<P4>::type p4_;
09286   typename remove_reference<P5>::type p5_;
09287 
09288  public:
09289   inline _ConstTessMemberResultCallback_5_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
09290     : object_(object),
09291       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
09292 
09293   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
09294     if (!del) {
09295       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
09296     } else {
09297       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
09298       //  zero out the pointer to ensure segfault if used again
09299       member_ = NULL;
09300       delete this;
09301     }
09302   }
09303 };
09304 
09305 #ifndef SWIG
09306 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>
09307 inline typename _ConstTessMemberResultCallback_5_5<true,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4,A5>::base*
09308 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) {
09309   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);
09310 }
09311 #endif
09312 
09313 #ifndef SWIG
09314 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>
09315 inline typename _ConstTessMemberResultCallback_5_5<false,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4,A5>::base*
09316 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) {
09317   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);
09318 }
09319 #endif
09320 
09321 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>
09322 class _TessMemberResultCallback_5_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
09323  public:
09324   typedef TessResultCallback5<R,A1,A2,A3,A4,A5> base;
09325   typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) ;
09326 
09327  private:
09328    T* object_;
09329   MemberSignature member_;
09330   typename remove_reference<P1>::type p1_;
09331   typename remove_reference<P2>::type p2_;
09332   typename remove_reference<P3>::type p3_;
09333   typename remove_reference<P4>::type p4_;
09334   typename remove_reference<P5>::type p5_;
09335 
09336  public:
09337   inline _TessMemberResultCallback_5_5( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
09338     : object_(object),
09339       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
09340 
09341   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
09342     if (!del) {
09343       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
09344       return result;
09345     } else {
09346       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
09347       //  zero out the pointer to ensure segfault if used again
09348       member_ = NULL;
09349       delete this;
09350       return result;
09351     }
09352   }
09353 };
09354 
09355 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>
09356 class _TessMemberResultCallback_5_5<del, void, T, P1, P2, P3, P4, P5, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
09357  public:
09358   typedef TessCallback5<A1,A2,A3,A4,A5> base;
09359   typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) ;
09360 
09361  private:
09362    T* object_;
09363   MemberSignature member_;
09364   typename remove_reference<P1>::type p1_;
09365   typename remove_reference<P2>::type p2_;
09366   typename remove_reference<P3>::type p3_;
09367   typename remove_reference<P4>::type p4_;
09368   typename remove_reference<P5>::type p5_;
09369 
09370  public:
09371   inline _TessMemberResultCallback_5_5( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
09372     : object_(object),
09373       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
09374 
09375   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
09376     if (!del) {
09377       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
09378     } else {
09379       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
09380       //  zero out the pointer to ensure segfault if used again
09381       member_ = NULL;
09382       delete this;
09383     }
09384   }
09385 };
09386 
09387 #ifndef SWIG
09388 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>
09389 inline typename _TessMemberResultCallback_5_5<true,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4,A5>::base*
09390 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) {
09391   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);
09392 }
09393 #endif
09394 
09395 #ifndef SWIG
09396 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>
09397 inline typename _TessMemberResultCallback_5_5<false,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4,A5>::base*
09398 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) {
09399   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);
09400 }
09401 #endif
09402 
09403 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>
09404 class _TessFunctionResultCallback_5_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
09405  public:
09406   typedef TessResultCallback5<R,A1,A2,A3,A4,A5> base;
09407   typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5);
09408 
09409  private:
09410   FunctionSignature function_;
09411   typename remove_reference<P1>::type p1_;
09412   typename remove_reference<P2>::type p2_;
09413   typename remove_reference<P3>::type p3_;
09414   typename remove_reference<P4>::type p4_;
09415   typename remove_reference<P5>::type p5_;
09416 
09417  public:
09418   inline _TessFunctionResultCallback_5_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
09419     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
09420 
09421   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
09422     if (!del) {
09423       R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
09424       return result;
09425     } else {
09426       R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
09427       //  zero out the pointer to ensure segfault if used again
09428       function_ = NULL;
09429       delete this;
09430       return result;
09431     }
09432   }
09433 };
09434 
09435 template <bool del, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4, class A5>
09436 class _TessFunctionResultCallback_5_5<del, void, P1, P2, P3, P4, P5, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
09437  public:
09438   typedef TessCallback5<A1,A2,A3,A4,A5> base;
09439   typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5);
09440 
09441  private:
09442   FunctionSignature function_;
09443   typename remove_reference<P1>::type p1_;
09444   typename remove_reference<P2>::type p2_;
09445   typename remove_reference<P3>::type p3_;
09446   typename remove_reference<P4>::type p4_;
09447   typename remove_reference<P5>::type p5_;
09448 
09449  public:
09450   inline _TessFunctionResultCallback_5_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
09451     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }
09452 
09453   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
09454     if (!del) {
09455       (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
09456     } else {
09457       (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
09458       //  zero out the pointer to ensure segfault if used again
09459       function_ = NULL;
09460       delete this;
09461     }
09462   }
09463 };
09464 
09465 template <class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4, class A5>
09466 inline typename _TessFunctionResultCallback_5_5<true,R,P1,P2,P3,P4,P5,A1,A2,A3,A4,A5>::base*
09467 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) {
09468   return new _TessFunctionResultCallback_5_5<true,R,P1,P2,P3,P4,P5,A1,A2,A3,A4,A5>(function, p1, p2, p3, p4, p5);
09469 }
09470 
09471 template <class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4, class A5>
09472 inline typename _TessFunctionResultCallback_5_5<false,R,P1,P2,P3,P4,P5,A1,A2,A3,A4,A5>::base*
09473 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) {
09474   return new _TessFunctionResultCallback_5_5<false,R,P1,P2,P3,P4,P5,A1,A2,A3,A4,A5>(function, p1, p2, p3, p4, p5);
09475 }
09476 
09477 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>
09478 class _ConstTessMemberResultCallback_6_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
09479  public:
09480   typedef TessResultCallback5<R,A1,A2,A3,A4,A5> base;
09481   typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) const;
09482 
09483  private:
09484   const T* object_;
09485   MemberSignature member_;
09486   typename remove_reference<P1>::type p1_;
09487   typename remove_reference<P2>::type p2_;
09488   typename remove_reference<P3>::type p3_;
09489   typename remove_reference<P4>::type p4_;
09490   typename remove_reference<P5>::type p5_;
09491   typename remove_reference<P6>::type p6_;
09492 
09493  public:
09494   inline _ConstTessMemberResultCallback_6_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
09495     : object_(object),
09496       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
09497 
09498   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
09499     if (!del) {
09500       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
09501       return result;
09502     } else {
09503       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
09504       //  zero out the pointer to ensure segfault if used again
09505       member_ = NULL;
09506       delete this;
09507       return result;
09508     }
09509   }
09510 };
09511 
09512 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>
09513 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> {
09514  public:
09515   typedef TessCallback5<A1,A2,A3,A4,A5> base;
09516   typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) const;
09517 
09518  private:
09519   const T* object_;
09520   MemberSignature member_;
09521   typename remove_reference<P1>::type p1_;
09522   typename remove_reference<P2>::type p2_;
09523   typename remove_reference<P3>::type p3_;
09524   typename remove_reference<P4>::type p4_;
09525   typename remove_reference<P5>::type p5_;
09526   typename remove_reference<P6>::type p6_;
09527 
09528  public:
09529   inline _ConstTessMemberResultCallback_6_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
09530     : object_(object),
09531       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
09532 
09533   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
09534     if (!del) {
09535       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
09536     } else {
09537       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
09538       //  zero out the pointer to ensure segfault if used again
09539       member_ = NULL;
09540       delete this;
09541     }
09542   }
09543 };
09544 
09545 #ifndef SWIG
09546 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>
09547 inline typename _ConstTessMemberResultCallback_6_5<true,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5>::base*
09548 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) {
09549   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);
09550 }
09551 #endif
09552 
09553 #ifndef SWIG
09554 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>
09555 inline typename _ConstTessMemberResultCallback_6_5<false,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5>::base*
09556 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) {
09557   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);
09558 }
09559 #endif
09560 
09561 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>
09562 class _TessMemberResultCallback_6_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
09563  public:
09564   typedef TessResultCallback5<R,A1,A2,A3,A4,A5> base;
09565   typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) ;
09566 
09567  private:
09568    T* object_;
09569   MemberSignature member_;
09570   typename remove_reference<P1>::type p1_;
09571   typename remove_reference<P2>::type p2_;
09572   typename remove_reference<P3>::type p3_;
09573   typename remove_reference<P4>::type p4_;
09574   typename remove_reference<P5>::type p5_;
09575   typename remove_reference<P6>::type p6_;
09576 
09577  public:
09578   inline _TessMemberResultCallback_6_5( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
09579     : object_(object),
09580       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
09581 
09582   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
09583     if (!del) {
09584       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
09585       return result;
09586     } else {
09587       R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
09588       //  zero out the pointer to ensure segfault if used again
09589       member_ = NULL;
09590       delete this;
09591       return result;
09592     }
09593   }
09594 };
09595 
09596 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>
09597 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> {
09598  public:
09599   typedef TessCallback5<A1,A2,A3,A4,A5> base;
09600   typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) ;
09601 
09602  private:
09603    T* object_;
09604   MemberSignature member_;
09605   typename remove_reference<P1>::type p1_;
09606   typename remove_reference<P2>::type p2_;
09607   typename remove_reference<P3>::type p3_;
09608   typename remove_reference<P4>::type p4_;
09609   typename remove_reference<P5>::type p5_;
09610   typename remove_reference<P6>::type p6_;
09611 
09612  public:
09613   inline _TessMemberResultCallback_6_5( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
09614     : object_(object),
09615       member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
09616 
09617   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
09618     if (!del) {
09619       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
09620     } else {
09621       (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
09622       //  zero out the pointer to ensure segfault if used again
09623       member_ = NULL;
09624       delete this;
09625     }
09626   }
09627 };
09628 
09629 #ifndef SWIG
09630 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>
09631 inline typename _TessMemberResultCallback_6_5<true,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5>::base*
09632 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) {
09633   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);
09634 }
09635 #endif
09636 
09637 #ifndef SWIG
09638 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>
09639 inline typename _TessMemberResultCallback_6_5<false,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5>::base*
09640 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) {
09641   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);
09642 }
09643 #endif
09644 
09645 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>
09646 class _TessFunctionResultCallback_6_5 : public TessResultCallback5<R,A1,A2,A3,A4,A5> {
09647  public:
09648   typedef TessResultCallback5<R,A1,A2,A3,A4,A5> base;
09649   typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5);
09650 
09651  private:
09652   FunctionSignature function_;
09653   typename remove_reference<P1>::type p1_;
09654   typename remove_reference<P2>::type p2_;
09655   typename remove_reference<P3>::type p3_;
09656   typename remove_reference<P4>::type p4_;
09657   typename remove_reference<P5>::type p5_;
09658   typename remove_reference<P6>::type p6_;
09659 
09660  public:
09661   inline _TessFunctionResultCallback_6_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
09662     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
09663 
09664   virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
09665     if (!del) {
09666       R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
09667       return result;
09668     } else {
09669       R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
09670       //  zero out the pointer to ensure segfault if used again
09671       function_ = NULL;
09672       delete this;
09673       return result;
09674     }
09675   }
09676 };
09677 
09678 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>
09679 class _TessFunctionResultCallback_6_5<del, void, P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5> : public TessCallback5<A1,A2,A3,A4,A5> {
09680  public:
09681   typedef TessCallback5<A1,A2,A3,A4,A5> base;
09682   typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5);
09683 
09684  private:
09685   FunctionSignature function_;
09686   typename remove_reference<P1>::type p1_;
09687   typename remove_reference<P2>::type p2_;
09688   typename remove_reference<P3>::type p3_;
09689   typename remove_reference<P4>::type p4_;
09690   typename remove_reference<P5>::type p5_;
09691   typename remove_reference<P6>::type p6_;
09692 
09693  public:
09694   inline _TessFunctionResultCallback_6_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
09695     : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }
09696 
09697   virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
09698     if (!del) {
09699       (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
09700     } else {
09701       (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
09702       //  zero out the pointer to ensure segfault if used again
09703       function_ = NULL;
09704       delete this;
09705     }
09706   }
09707 };
09708 
09709 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>
09710 inline typename _TessFunctionResultCallback_6_5<true,R,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5>::base*
09711 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) {
09712   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);
09713 }
09714 
09715 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>
09716 inline typename _TessFunctionResultCallback_6_5<false,R,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5>::base*
09717 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) {
09718   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);
09719 }
09720 
09721 #endif /* _TESS_CALLBACK_SPECIALIZATIONS_H */
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines