tesseract
3.03
|
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 */