/////////////////////////////////////////////////////////////////////// // File: tesscallback.h // Description: classes and functions to replace pointer-to-functions // Author: Samuel Charron // // (C) Copyright 2006, Google Inc. // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // http://www.apache.org/licenses/LICENSE-2.0 // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // /////////////////////////////////////////////////////////////////////// #ifndef TESS_CALLBACK_SPECIALIZATIONS_H_ #define TESS_CALLBACK_SPECIALIZATIONS_H_ #include "host.h" // For NULL. struct TessCallbackUtils_ { static void FailIsRepeatable(const char* name); }; class TessClosure { public: virtual ~TessClosure() { } virtual void Run() = 0; }; template class TessResultCallback { public: virtual ~TessResultCallback() { } virtual R Run() = 0; }; template class _ConstTessMemberResultCallback_0_0 : public TessResultCallback { public: typedef TessResultCallback base; typedef R (T::*MemberSignature)() const; private: const T* object_; MemberSignature member_; public: inline _ConstTessMemberResultCallback_0_0( const T* object, MemberSignature member) : object_(object), member_(member) { } virtual R Run() { if (!del) { R result = (object_->*member_)(); return result; } else { R result = (object_->*member_)(); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_0_0 : public TessClosure { public: typedef TessClosure base; typedef void (T::*MemberSignature)() const; private: const T* object_; MemberSignature member_; public: inline _ConstTessMemberResultCallback_0_0( const T* object, MemberSignature member) : object_(object), member_(member) { } virtual void Run() { if (!del) { (object_->*member_)(); } else { (object_->*member_)(); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_0_0::base* NewTessCallback( const T1* obj, R (T2::*member)() const) { return new _ConstTessMemberResultCallback_0_0( obj, member); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_0_0::base* NewPermanentTessCallback( const T1* obj, R (T2::*member)() const) { return new _ConstTessMemberResultCallback_0_0( obj, member); } #endif template class _TessMemberResultCallback_0_0 : public TessResultCallback { public: typedef TessResultCallback base; typedef R (T::*MemberSignature)() ; private: T* object_; MemberSignature member_; public: inline _TessMemberResultCallback_0_0( T* object, MemberSignature member) : object_(object), member_(member) { } virtual R Run() { if (!del) { R result = (object_->*member_)(); return result; } else { R result = (object_->*member_)(); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_0_0 : public TessClosure { public: typedef TessClosure base; typedef void (T::*MemberSignature)() ; private: T* object_; MemberSignature member_; public: inline _TessMemberResultCallback_0_0( T* object, MemberSignature member) : object_(object), member_(member) { } virtual void Run() { if (!del) { (object_->*member_)(); } else { (object_->*member_)(); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_0_0::base* NewTessCallback( T1* obj, R (T2::*member)() ) { return new _TessMemberResultCallback_0_0( obj, member); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_0_0::base* NewPermanentTessCallback( T1* obj, R (T2::*member)() ) { return new _TessMemberResultCallback_0_0( obj, member); } #endif template class _TessFunctionResultCallback_0_0 : public TessResultCallback { public: typedef TessResultCallback base; typedef R (*FunctionSignature)(); private: FunctionSignature function_; public: inline _TessFunctionResultCallback_0_0( FunctionSignature function) : function_(function) { } virtual R Run() { if (!del) { R result = (*function_)(); return result; } else { R result = (*function_)(); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_0_0 : public TessClosure { public: typedef TessClosure base; typedef void (*FunctionSignature)(); private: FunctionSignature function_; public: inline _TessFunctionResultCallback_0_0( FunctionSignature function) : function_(function) { } virtual void Run() { if (!del) { (*function_)(); } else { (*function_)(); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_0_0::base* NewTessCallback(R (*function)()) { return new _TessFunctionResultCallback_0_0(function); } template inline typename _TessFunctionResultCallback_0_0::base* NewPermanentTessCallback(R (*function)()) { return new _TessFunctionResultCallback_0_0(function); } // Specified by TR1 [4.7.2] Reference modifications. template struct remove_reference; template struct remove_reference { typedef T type; }; template struct remove_reference { typedef T type; }; // Identity::type is a typedef of T. Useful for preventing the // compiler from inferring the type of an argument in templates. template struct Identity { typedef T type; }; template class _ConstTessMemberResultCallback_1_0 : public TessResultCallback { public: typedef TessResultCallback base; typedef R (T::*MemberSignature)(P1) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; public: inline _ConstTessMemberResultCallback_1_0(const T* object, MemberSignature member, P1 p1) : object_(object), member_(member), p1_(p1) { } virtual R Run() { if (!del) { R result = (object_->*member_)(p1_); return result; } else { R result = (object_->*member_)(p1_); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_1_0 : public TessClosure { public: typedef TessClosure base; typedef void (T::*MemberSignature)(P1) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; public: inline _ConstTessMemberResultCallback_1_0(const T* object, MemberSignature member, P1 p1) : object_(object), member_(member), p1_(p1) { } virtual void Run() { if (!del) { (object_->*member_)(p1_); } else { (object_->*member_)(p1_); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_1_0::base* NewTessCallback(const T1* obj, R (T2::*member)(P1) const, typename Identity::type p1) { return new _ConstTessMemberResultCallback_1_0(obj, member, p1); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_1_0::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1) const, typename Identity::type p1) { return new _ConstTessMemberResultCallback_1_0(obj, member, p1); } #endif template class _TessMemberResultCallback_1_0 : public TessResultCallback { public: typedef TessResultCallback base; typedef R (T::*MemberSignature)(P1) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; public: inline _TessMemberResultCallback_1_0( T* object, MemberSignature member, P1 p1) : object_(object), member_(member), p1_(p1) { } virtual R Run() { if (!del) { R result = (object_->*member_)(p1_); return result; } else { R result = (object_->*member_)(p1_); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_1_0 : public TessClosure { public: typedef TessClosure base; typedef void (T::*MemberSignature)(P1) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; public: inline _TessMemberResultCallback_1_0( T* object, MemberSignature member, P1 p1) : object_(object), member_(member), p1_(p1) { } virtual void Run() { if (!del) { (object_->*member_)(p1_); } else { (object_->*member_)(p1_); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_1_0::base* NewTessCallback( T1* obj, R (T2::*member)(P1) , typename Identity::type p1) { return new _TessMemberResultCallback_1_0(obj, member, p1); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_1_0::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1) , typename Identity::type p1) { return new _TessMemberResultCallback_1_0(obj, member, p1); } #endif template class _TessFunctionResultCallback_1_0 : public TessResultCallback { public: typedef TessResultCallback base; typedef R (*FunctionSignature)(P1); private: FunctionSignature function_; typename remove_reference::type p1_; public: inline _TessFunctionResultCallback_1_0(FunctionSignature function, P1 p1) : function_(function), p1_(p1) { } virtual R Run() { if (!del) { R result = (*function_)(p1_); return result; } else { R result = (*function_)(p1_); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_1_0 : public TessClosure { public: typedef TessClosure base; typedef void (*FunctionSignature)(P1); private: FunctionSignature function_; typename remove_reference::type p1_; public: inline _TessFunctionResultCallback_1_0(FunctionSignature function, P1 p1) : function_(function), p1_(p1) { } virtual void Run() { if (!del) { (*function_)(p1_); } else { (*function_)(p1_); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_1_0::base* NewTessCallback(R (*function)(P1), typename Identity::type p1) { return new _TessFunctionResultCallback_1_0(function, p1); } template inline typename _TessFunctionResultCallback_1_0::base* NewPermanentTessCallback(R (*function)(P1), typename Identity::type p1) { return new _TessFunctionResultCallback_1_0(function, p1); } template class _ConstTessMemberResultCallback_2_0 : public TessResultCallback { public: typedef TessResultCallback base; typedef R (T::*MemberSignature)(P1,P2) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _ConstTessMemberResultCallback_2_0(const T* object, MemberSignature member, P1 p1, P2 p2) : object_(object), member_(member), p1_(p1), p2_(p2) { } virtual R Run() { if (!del) { R result = (object_->*member_)(p1_,p2_); return result; } else { R result = (object_->*member_)(p1_,p2_); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_2_0 : public TessClosure { public: typedef TessClosure base; typedef void (T::*MemberSignature)(P1,P2) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _ConstTessMemberResultCallback_2_0(const T* object, MemberSignature member, P1 p1, P2 p2) : object_(object), member_(member), p1_(p1), p2_(p2) { } virtual void Run() { if (!del) { (object_->*member_)(p1_,p2_); } else { (object_->*member_)(p1_,p2_); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_2_0::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2) const, typename Identity::type p1, typename Identity::type p2) { return new _ConstTessMemberResultCallback_2_0(obj, member, p1, p2); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_2_0::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2) const, typename Identity::type p1, typename Identity::type p2) { return new _ConstTessMemberResultCallback_2_0(obj, member, p1, p2); } #endif template class _TessMemberResultCallback_2_0 : public TessResultCallback { public: typedef TessResultCallback base; typedef R (T::*MemberSignature)(P1,P2) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _TessMemberResultCallback_2_0( T* object, MemberSignature member, P1 p1, P2 p2) : object_(object), member_(member), p1_(p1), p2_(p2) { } virtual R Run() { if (!del) { R result = (object_->*member_)(p1_,p2_); return result; } else { R result = (object_->*member_)(p1_,p2_); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_2_0 : public TessClosure { public: typedef TessClosure base; typedef void (T::*MemberSignature)(P1,P2) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _TessMemberResultCallback_2_0( T* object, MemberSignature member, P1 p1, P2 p2) : object_(object), member_(member), p1_(p1), p2_(p2) { } virtual void Run() { if (!del) { (object_->*member_)(p1_,p2_); } else { (object_->*member_)(p1_,p2_); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_2_0::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2) , typename Identity::type p1, typename Identity::type p2) { return new _TessMemberResultCallback_2_0(obj, member, p1, p2); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_2_0::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2) , typename Identity::type p1, typename Identity::type p2) { return new _TessMemberResultCallback_2_0(obj, member, p1, p2); } #endif template class _TessFunctionResultCallback_2_0 : public TessResultCallback { public: typedef TessResultCallback base; typedef R (*FunctionSignature)(P1,P2); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _TessFunctionResultCallback_2_0(FunctionSignature function, P1 p1, P2 p2) : function_(function), p1_(p1), p2_(p2) { } virtual R Run() { if (!del) { R result = (*function_)(p1_,p2_); return result; } else { R result = (*function_)(p1_,p2_); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_2_0 : public TessClosure { public: typedef TessClosure base; typedef void (*FunctionSignature)(P1,P2); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _TessFunctionResultCallback_2_0(FunctionSignature function, P1 p1, P2 p2) : function_(function), p1_(p1), p2_(p2) { } virtual void Run() { if (!del) { (*function_)(p1_,p2_); } else { (*function_)(p1_,p2_); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_2_0::base* NewTessCallback(R (*function)(P1,P2), typename Identity::type p1, typename Identity::type p2) { return new _TessFunctionResultCallback_2_0(function, p1, p2); } template inline typename _TessFunctionResultCallback_2_0::base* NewPermanentTessCallback(R (*function)(P1,P2), typename Identity::type p1, typename Identity::type p2) { return new _TessFunctionResultCallback_2_0(function, p1, p2); } template class _ConstTessMemberResultCallback_3_0 : public TessResultCallback { public: typedef TessResultCallback base; typedef R (T::*MemberSignature)(P1,P2,P3) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _ConstTessMemberResultCallback_3_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) { } virtual R Run() { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_3_0 : public TessClosure { public: typedef TessClosure base; typedef void (T::*MemberSignature)(P1,P2,P3) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _ConstTessMemberResultCallback_3_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) { } virtual void Run() { if (!del) { (object_->*member_)(p1_,p2_,p3_); } else { (object_->*member_)(p1_,p2_,p3_); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_3_0::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _ConstTessMemberResultCallback_3_0(obj, member, p1, p2, p3); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_3_0::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _ConstTessMemberResultCallback_3_0(obj, member, p1, p2, p3); } #endif template class _TessMemberResultCallback_3_0 : public TessResultCallback { public: typedef TessResultCallback base; typedef R (T::*MemberSignature)(P1,P2,P3) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _TessMemberResultCallback_3_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) { } virtual R Run() { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_3_0 : public TessClosure { public: typedef TessClosure base; typedef void (T::*MemberSignature)(P1,P2,P3) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _TessMemberResultCallback_3_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) { } virtual void Run() { if (!del) { (object_->*member_)(p1_,p2_,p3_); } else { (object_->*member_)(p1_,p2_,p3_); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_3_0::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _TessMemberResultCallback_3_0(obj, member, p1, p2, p3); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_3_0::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _TessMemberResultCallback_3_0(obj, member, p1, p2, p3); } #endif template class _TessFunctionResultCallback_3_0 : public TessResultCallback { public: typedef TessResultCallback base; typedef R (*FunctionSignature)(P1,P2,P3); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _TessFunctionResultCallback_3_0(FunctionSignature function, P1 p1, P2 p2, P3 p3) : function_(function), p1_(p1), p2_(p2), p3_(p3) { } virtual R Run() { if (!del) { R result = (*function_)(p1_,p2_,p3_); return result; } else { R result = (*function_)(p1_,p2_,p3_); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_3_0 : public TessClosure { public: typedef TessClosure base; typedef void (*FunctionSignature)(P1,P2,P3); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _TessFunctionResultCallback_3_0(FunctionSignature function, P1 p1, P2 p2, P3 p3) : function_(function), p1_(p1), p2_(p2), p3_(p3) { } virtual void Run() { if (!del) { (*function_)(p1_,p2_,p3_); } else { (*function_)(p1_,p2_,p3_); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_3_0::base* NewTessCallback(R (*function)(P1,P2,P3), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _TessFunctionResultCallback_3_0(function, p1, p2, p3); } template inline typename _TessFunctionResultCallback_3_0::base* NewPermanentTessCallback(R (*function)(P1,P2,P3), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _TessFunctionResultCallback_3_0(function, p1, p2, p3); } template class _ConstTessMemberResultCallback_4_0 : public TessResultCallback { public: typedef TessResultCallback base; typedef R (T::*MemberSignature)(P1,P2,P3,P4) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _ConstTessMemberResultCallback_4_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual R Run() { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_4_0 : public TessClosure { public: typedef TessClosure base; typedef void (T::*MemberSignature)(P1,P2,P3,P4) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _ConstTessMemberResultCallback_4_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual void Run() { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_); } else { (object_->*member_)(p1_,p2_,p3_,p4_); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_4_0::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _ConstTessMemberResultCallback_4_0(obj, member, p1, p2, p3, p4); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_4_0::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _ConstTessMemberResultCallback_4_0(obj, member, p1, p2, p3, p4); } #endif template class _TessMemberResultCallback_4_0 : public TessResultCallback { public: typedef TessResultCallback base; typedef R (T::*MemberSignature)(P1,P2,P3,P4) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _TessMemberResultCallback_4_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual R Run() { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_4_0 : public TessClosure { public: typedef TessClosure base; typedef void (T::*MemberSignature)(P1,P2,P3,P4) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _TessMemberResultCallback_4_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual void Run() { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_); } else { (object_->*member_)(p1_,p2_,p3_,p4_); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_4_0::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _TessMemberResultCallback_4_0(obj, member, p1, p2, p3, p4); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_4_0::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _TessMemberResultCallback_4_0(obj, member, p1, p2, p3, p4); } #endif template class _TessFunctionResultCallback_4_0 : public TessResultCallback { public: typedef TessResultCallback base; typedef R (*FunctionSignature)(P1,P2,P3,P4); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _TessFunctionResultCallback_4_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual R Run() { if (!del) { R result = (*function_)(p1_,p2_,p3_,p4_); return result; } else { R result = (*function_)(p1_,p2_,p3_,p4_); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_4_0 : public TessClosure { public: typedef TessClosure base; typedef void (*FunctionSignature)(P1,P2,P3,P4); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _TessFunctionResultCallback_4_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual void Run() { if (!del) { (*function_)(p1_,p2_,p3_,p4_); } else { (*function_)(p1_,p2_,p3_,p4_); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_4_0::base* NewTessCallback(R (*function)(P1,P2,P3,P4), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _TessFunctionResultCallback_4_0(function, p1, p2, p3, p4); } template inline typename _TessFunctionResultCallback_4_0::base* NewPermanentTessCallback(R (*function)(P1,P2,P3,P4), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _TessFunctionResultCallback_4_0(function, p1, p2, p3, p4); } template class _ConstTessMemberResultCallback_5_0 : public TessResultCallback { public: typedef TessResultCallback base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _ConstTessMemberResultCallback_5_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual R Run() { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_5_0 : public TessClosure { public: typedef TessClosure base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _ConstTessMemberResultCallback_5_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual void Run() { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,p5_); } else { (object_->*member_)(p1_,p2_,p3_,p4_,p5_); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_5_0::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _ConstTessMemberResultCallback_5_0(obj, member, p1, p2, p3, p4, p5); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_5_0::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _ConstTessMemberResultCallback_5_0(obj, member, p1, p2, p3, p4, p5); } #endif template class _TessMemberResultCallback_5_0 : public TessResultCallback { public: typedef TessResultCallback base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _TessMemberResultCallback_5_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual R Run() { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_5_0 : public TessClosure { public: typedef TessClosure base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _TessMemberResultCallback_5_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual void Run() { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,p5_); } else { (object_->*member_)(p1_,p2_,p3_,p4_,p5_); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_5_0::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _TessMemberResultCallback_5_0(obj, member, p1, p2, p3, p4, p5); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_5_0::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _TessMemberResultCallback_5_0(obj, member, p1, p2, p3, p4, p5); } #endif template class _TessFunctionResultCallback_5_0 : public TessResultCallback { public: typedef TessResultCallback base; typedef R (*FunctionSignature)(P1,P2,P3,P4,P5); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _TessFunctionResultCallback_5_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual R Run() { if (!del) { R result = (*function_)(p1_,p2_,p3_,p4_,p5_); return result; } else { R result = (*function_)(p1_,p2_,p3_,p4_,p5_); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_5_0 : public TessClosure { public: typedef TessClosure base; typedef void (*FunctionSignature)(P1,P2,P3,P4,P5); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _TessFunctionResultCallback_5_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual void Run() { if (!del) { (*function_)(p1_,p2_,p3_,p4_,p5_); } else { (*function_)(p1_,p2_,p3_,p4_,p5_); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_5_0::base* NewTessCallback(R (*function)(P1,P2,P3,P4,P5), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _TessFunctionResultCallback_5_0(function, p1, p2, p3, p4, p5); } template inline typename _TessFunctionResultCallback_5_0::base* NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _TessFunctionResultCallback_5_0(function, p1, p2, p3, p4, p5); } template class _ConstTessMemberResultCallback_6_0 : public TessResultCallback { public: typedef TessResultCallback base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _ConstTessMemberResultCallback_6_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual R Run() { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_6_0 : public TessClosure { public: typedef TessClosure base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _ConstTessMemberResultCallback_6_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual void Run() { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_); } else { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_6_0::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _ConstTessMemberResultCallback_6_0(obj, member, p1, p2, p3, p4, p5, p6); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_6_0::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _ConstTessMemberResultCallback_6_0(obj, member, p1, p2, p3, p4, p5, p6); } #endif template class _TessMemberResultCallback_6_0 : public TessResultCallback { public: typedef TessResultCallback base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _TessMemberResultCallback_6_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual R Run() { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_6_0 : public TessClosure { public: typedef TessClosure base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _TessMemberResultCallback_6_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual void Run() { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_); } else { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_6_0::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _TessMemberResultCallback_6_0(obj, member, p1, p2, p3, p4, p5, p6); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_6_0::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _TessMemberResultCallback_6_0(obj, member, p1, p2, p3, p4, p5, p6); } #endif template class _TessFunctionResultCallback_6_0 : public TessResultCallback { public: typedef TessResultCallback base; typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,P6); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _TessFunctionResultCallback_6_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual R Run() { if (!del) { R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_); return result; } else { R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_6_0 : public TessClosure { public: typedef TessClosure base; typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,P6); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _TessFunctionResultCallback_6_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual void Run() { if (!del) { (*function_)(p1_,p2_,p3_,p4_,p5_,p6_); } else { (*function_)(p1_,p2_,p3_,p4_,p5_,p6_); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_6_0::base* NewTessCallback(R (*function)(P1,P2,P3,P4,P5,P6), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _TessFunctionResultCallback_6_0(function, p1, p2, p3, p4, p5, p6); } template inline typename _TessFunctionResultCallback_6_0::base* NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,P6), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _TessFunctionResultCallback_6_0(function, p1, p2, p3, p4, p5, p6); } template class TessCallback1 { public: virtual ~TessCallback1() { } virtual void Run(A1) = 0; }; template class TessResultCallback1 { public: virtual ~TessResultCallback1() { } virtual R Run(A1) = 0; }; template class TessCallback2 { public: virtual ~TessCallback2() { } virtual void Run(A1,A2) = 0; }; template class TessResultCallback2 { public: virtual ~TessResultCallback2() { } virtual R Run(A1,A2) = 0; }; template class TessCallback3 { public: virtual ~TessCallback3() { } virtual void Run(A1,A2,A3) = 0; }; template class TessResultCallback3 { public: virtual ~TessResultCallback3() { } virtual R Run(A1,A2,A3) = 0; }; template class TessCallback4 { public: virtual ~TessCallback4() { } virtual void Run(A1,A2,A3,A4) = 0; }; template class TessResultCallback4 { public: virtual ~TessResultCallback4() { } virtual R Run(A1,A2,A3,A4) = 0; }; template class _ConstTessMemberResultCallback_0_1 : public TessResultCallback1 { public: typedef TessResultCallback1 base; typedef R (T::*MemberSignature)(A1) const; private: const T* object_; MemberSignature member_; public: inline _ConstTessMemberResultCallback_0_1( const T* object, MemberSignature member) : object_(object), member_(member) { } virtual R Run(A1 a1) { if (!del) { R result = (object_->*member_)(a1); return result; } else { R result = (object_->*member_)(a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_0_1 : public TessCallback1 { public: typedef TessCallback1 base; typedef void (T::*MemberSignature)(A1) const; private: const T* object_; MemberSignature member_; public: inline _ConstTessMemberResultCallback_0_1( const T* object, MemberSignature member) : object_(object), member_(member) { } virtual void Run(A1 a1) { if (!del) { (object_->*member_)(a1); } else { (object_->*member_)(a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_0_1::base* NewTessCallback( const T1* obj, R (T2::*member)(A1) const) { return new _ConstTessMemberResultCallback_0_1( obj, member); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_0_1::base* NewPermanentTessCallback( const T1* obj, R (T2::*member)(A1) const) { return new _ConstTessMemberResultCallback_0_1( obj, member); } #endif template class _TessMemberResultCallback_0_1 : public TessResultCallback1 { public: typedef TessResultCallback1 base; typedef R (T::*MemberSignature)(A1) ; private: T* object_; MemberSignature member_; public: inline _TessMemberResultCallback_0_1( T* object, MemberSignature member) : object_(object), member_(member) { } virtual R Run(A1 a1) { if (!del) { R result = (object_->*member_)(a1); return result; } else { R result = (object_->*member_)(a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_0_1 : public TessCallback1 { public: typedef TessCallback1 base; typedef void (T::*MemberSignature)(A1) ; private: T* object_; MemberSignature member_; public: inline _TessMemberResultCallback_0_1( T* object, MemberSignature member) : object_(object), member_(member) { } virtual void Run(A1 a1) { if (!del) { (object_->*member_)(a1); } else { (object_->*member_)(a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_0_1::base* NewTessCallback( T1* obj, R (T2::*member)(A1) ) { return new _TessMemberResultCallback_0_1( obj, member); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_0_1::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(A1) ) { return new _TessMemberResultCallback_0_1( obj, member); } #endif template class _TessFunctionResultCallback_0_1 : public TessResultCallback1 { public: typedef TessResultCallback1 base; typedef R (*FunctionSignature)(A1); private: FunctionSignature function_; public: inline _TessFunctionResultCallback_0_1( FunctionSignature function) : function_(function) { } virtual R Run(A1 a1) { if (!del) { R result = (*function_)(a1); return result; } else { R result = (*function_)(a1); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_0_1 : public TessCallback1 { public: typedef TessCallback1 base; typedef void (*FunctionSignature)(A1); private: FunctionSignature function_; public: inline _TessFunctionResultCallback_0_1( FunctionSignature function) : function_(function) { } virtual void Run(A1 a1) { if (!del) { (*function_)(a1); } else { (*function_)(a1); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_0_1::base* NewTessCallback(R (*function)(A1)) { return new _TessFunctionResultCallback_0_1(function); } template inline typename _TessFunctionResultCallback_0_1::base* NewPermanentTessCallback(R (*function)(A1)) { return new _TessFunctionResultCallback_0_1(function); } template class _ConstTessMemberResultCallback_1_1 : public TessResultCallback1 { public: typedef TessResultCallback1 base; typedef R (T::*MemberSignature)(P1,A1) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; public: inline _ConstTessMemberResultCallback_1_1(const T* object, MemberSignature member, P1 p1) : object_(object), member_(member), p1_(p1) { } virtual R Run(A1 a1) { if (!del) { R result = (object_->*member_)(p1_,a1); return result; } else { R result = (object_->*member_)(p1_,a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_1_1 : public TessCallback1 { public: typedef TessCallback1 base; typedef void (T::*MemberSignature)(P1,A1) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; public: inline _ConstTessMemberResultCallback_1_1(const T* object, MemberSignature member, P1 p1) : object_(object), member_(member), p1_(p1) { } virtual void Run(A1 a1) { if (!del) { (object_->*member_)(p1_,a1); } else { (object_->*member_)(p1_,a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_1_1::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,A1) const, typename Identity::type p1) { return new _ConstTessMemberResultCallback_1_1(obj, member, p1); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_1_1::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,A1) const, typename Identity::type p1) { return new _ConstTessMemberResultCallback_1_1(obj, member, p1); } #endif template class _TessMemberResultCallback_1_1 : public TessResultCallback1 { public: typedef TessResultCallback1 base; typedef R (T::*MemberSignature)(P1,A1) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; public: inline _TessMemberResultCallback_1_1( T* object, MemberSignature member, P1 p1) : object_(object), member_(member), p1_(p1) { } virtual R Run(A1 a1) { if (!del) { R result = (object_->*member_)(p1_,a1); return result; } else { R result = (object_->*member_)(p1_,a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_1_1 : public TessCallback1 { public: typedef TessCallback1 base; typedef void (T::*MemberSignature)(P1,A1) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; public: inline _TessMemberResultCallback_1_1( T* object, MemberSignature member, P1 p1) : object_(object), member_(member), p1_(p1) { } virtual void Run(A1 a1) { if (!del) { (object_->*member_)(p1_,a1); } else { (object_->*member_)(p1_,a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_1_1::base* NewTessCallback( T1* obj, R (T2::*member)(P1,A1) , typename Identity::type p1) { return new _TessMemberResultCallback_1_1(obj, member, p1); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_1_1::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,A1) , typename Identity::type p1) { return new _TessMemberResultCallback_1_1(obj, member, p1); } #endif template class _TessFunctionResultCallback_1_1 : public TessResultCallback1 { public: typedef TessResultCallback1 base; typedef R (*FunctionSignature)(P1,A1); private: FunctionSignature function_; typename remove_reference::type p1_; public: inline _TessFunctionResultCallback_1_1(FunctionSignature function, P1 p1) : function_(function), p1_(p1) { } virtual R Run(A1 a1) { if (!del) { R result = (*function_)(p1_,a1); return result; } else { R result = (*function_)(p1_,a1); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_1_1 : public TessCallback1 { public: typedef TessCallback1 base; typedef void (*FunctionSignature)(P1,A1); private: FunctionSignature function_; typename remove_reference::type p1_; public: inline _TessFunctionResultCallback_1_1(FunctionSignature function, P1 p1) : function_(function), p1_(p1) { } virtual void Run(A1 a1) { if (!del) { (*function_)(p1_,a1); } else { (*function_)(p1_,a1); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_1_1::base* NewTessCallback(R (*function)(P1,A1), typename Identity::type p1) { return new _TessFunctionResultCallback_1_1(function, p1); } template inline typename _TessFunctionResultCallback_1_1::base* NewPermanentTessCallback(R (*function)(P1,A1), typename Identity::type p1) { return new _TessFunctionResultCallback_1_1(function, p1); } template class _ConstTessMemberResultCallback_2_1 : public TessResultCallback1 { public: typedef TessResultCallback1 base; typedef R (T::*MemberSignature)(P1,P2,A1) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _ConstTessMemberResultCallback_2_1(const T* object, MemberSignature member, P1 p1, P2 p2) : object_(object), member_(member), p1_(p1), p2_(p2) { } virtual R Run(A1 a1) { if (!del) { R result = (object_->*member_)(p1_,p2_,a1); return result; } else { R result = (object_->*member_)(p1_,p2_,a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_2_1 : public TessCallback1 { public: typedef TessCallback1 base; typedef void (T::*MemberSignature)(P1,P2,A1) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _ConstTessMemberResultCallback_2_1(const T* object, MemberSignature member, P1 p1, P2 p2) : object_(object), member_(member), p1_(p1), p2_(p2) { } virtual void Run(A1 a1) { if (!del) { (object_->*member_)(p1_,p2_,a1); } else { (object_->*member_)(p1_,p2_,a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_2_1::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1) const, typename Identity::type p1, typename Identity::type p2) { return new _ConstTessMemberResultCallback_2_1(obj, member, p1, p2); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_2_1::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1) const, typename Identity::type p1, typename Identity::type p2) { return new _ConstTessMemberResultCallback_2_1(obj, member, p1, p2); } #endif template class _TessMemberResultCallback_2_1 : public TessResultCallback1 { public: typedef TessResultCallback1 base; typedef R (T::*MemberSignature)(P1,P2,A1) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _TessMemberResultCallback_2_1( T* object, MemberSignature member, P1 p1, P2 p2) : object_(object), member_(member), p1_(p1), p2_(p2) { } virtual R Run(A1 a1) { if (!del) { R result = (object_->*member_)(p1_,p2_,a1); return result; } else { R result = (object_->*member_)(p1_,p2_,a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_2_1 : public TessCallback1 { public: typedef TessCallback1 base; typedef void (T::*MemberSignature)(P1,P2,A1) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _TessMemberResultCallback_2_1( T* object, MemberSignature member, P1 p1, P2 p2) : object_(object), member_(member), p1_(p1), p2_(p2) { } virtual void Run(A1 a1) { if (!del) { (object_->*member_)(p1_,p2_,a1); } else { (object_->*member_)(p1_,p2_,a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_2_1::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,A1) , typename Identity::type p1, typename Identity::type p2) { return new _TessMemberResultCallback_2_1(obj, member, p1, p2); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_2_1::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,A1) , typename Identity::type p1, typename Identity::type p2) { return new _TessMemberResultCallback_2_1(obj, member, p1, p2); } #endif template class _TessFunctionResultCallback_2_1 : public TessResultCallback1 { public: typedef TessResultCallback1 base; typedef R (*FunctionSignature)(P1,P2,A1); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _TessFunctionResultCallback_2_1(FunctionSignature function, P1 p1, P2 p2) : function_(function), p1_(p1), p2_(p2) { } virtual R Run(A1 a1) { if (!del) { R result = (*function_)(p1_,p2_,a1); return result; } else { R result = (*function_)(p1_,p2_,a1); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_2_1 : public TessCallback1 { public: typedef TessCallback1 base; typedef void (*FunctionSignature)(P1,P2,A1); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _TessFunctionResultCallback_2_1(FunctionSignature function, P1 p1, P2 p2) : function_(function), p1_(p1), p2_(p2) { } virtual void Run(A1 a1) { if (!del) { (*function_)(p1_,p2_,a1); } else { (*function_)(p1_,p2_,a1); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_2_1::base* NewTessCallback(R (*function)(P1,P2,A1), typename Identity::type p1, typename Identity::type p2) { return new _TessFunctionResultCallback_2_1(function, p1, p2); } template inline typename _TessFunctionResultCallback_2_1::base* NewPermanentTessCallback(R (*function)(P1,P2,A1), typename Identity::type p1, typename Identity::type p2) { return new _TessFunctionResultCallback_2_1(function, p1, p2); } template class _ConstTessMemberResultCallback_3_1 : public TessResultCallback1 { public: typedef TessResultCallback1 base; typedef R (T::*MemberSignature)(P1,P2,P3,A1) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _ConstTessMemberResultCallback_3_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) { } virtual R Run(A1 a1) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,a1); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_3_1 : public TessCallback1 { public: typedef TessCallback1 base; typedef void (T::*MemberSignature)(P1,P2,P3,A1) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _ConstTessMemberResultCallback_3_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) { } virtual void Run(A1 a1) { if (!del) { (object_->*member_)(p1_,p2_,p3_,a1); } else { (object_->*member_)(p1_,p2_,p3_,a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_3_1::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _ConstTessMemberResultCallback_3_1(obj, member, p1, p2, p3); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_3_1::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _ConstTessMemberResultCallback_3_1(obj, member, p1, p2, p3); } #endif template class _TessMemberResultCallback_3_1 : public TessResultCallback1 { public: typedef TessResultCallback1 base; typedef R (T::*MemberSignature)(P1,P2,P3,A1) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _TessMemberResultCallback_3_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) { } virtual R Run(A1 a1) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,a1); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_3_1 : public TessCallback1 { public: typedef TessCallback1 base; typedef void (T::*MemberSignature)(P1,P2,P3,A1) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _TessMemberResultCallback_3_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) { } virtual void Run(A1 a1) { if (!del) { (object_->*member_)(p1_,p2_,p3_,a1); } else { (object_->*member_)(p1_,p2_,p3_,a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_3_1::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,A1) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _TessMemberResultCallback_3_1(obj, member, p1, p2, p3); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_3_1::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,A1) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _TessMemberResultCallback_3_1(obj, member, p1, p2, p3); } #endif template class _TessFunctionResultCallback_3_1 : public TessResultCallback1 { public: typedef TessResultCallback1 base; typedef R (*FunctionSignature)(P1,P2,P3,A1); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _TessFunctionResultCallback_3_1(FunctionSignature function, P1 p1, P2 p2, P3 p3) : function_(function), p1_(p1), p2_(p2), p3_(p3) { } virtual R Run(A1 a1) { if (!del) { R result = (*function_)(p1_,p2_,p3_,a1); return result; } else { R result = (*function_)(p1_,p2_,p3_,a1); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_3_1 : public TessCallback1 { public: typedef TessCallback1 base; typedef void (*FunctionSignature)(P1,P2,P3,A1); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _TessFunctionResultCallback_3_1(FunctionSignature function, P1 p1, P2 p2, P3 p3) : function_(function), p1_(p1), p2_(p2), p3_(p3) { } virtual void Run(A1 a1) { if (!del) { (*function_)(p1_,p2_,p3_,a1); } else { (*function_)(p1_,p2_,p3_,a1); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_3_1::base* NewTessCallback(R (*function)(P1,P2,P3,A1), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _TessFunctionResultCallback_3_1(function, p1, p2, p3); } template inline typename _TessFunctionResultCallback_3_1::base* NewPermanentTessCallback(R (*function)(P1,P2,P3,A1), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _TessFunctionResultCallback_3_1(function, p1, p2, p3); } template class _ConstTessMemberResultCallback_4_1 : public TessResultCallback1 { public: typedef TessResultCallback1 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _ConstTessMemberResultCallback_4_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual R Run(A1 a1) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_4_1 : public TessCallback1 { public: typedef TessCallback1 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _ConstTessMemberResultCallback_4_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual void Run(A1 a1) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,a1); } else { (object_->*member_)(p1_,p2_,p3_,p4_,a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_4_1::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _ConstTessMemberResultCallback_4_1(obj, member, p1, p2, p3, p4); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_4_1::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _ConstTessMemberResultCallback_4_1(obj, member, p1, p2, p3, p4); } #endif template class _TessMemberResultCallback_4_1 : public TessResultCallback1 { public: typedef TessResultCallback1 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _TessMemberResultCallback_4_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual R Run(A1 a1) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_4_1 : public TessCallback1 { public: typedef TessCallback1 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _TessMemberResultCallback_4_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual void Run(A1 a1) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,a1); } else { (object_->*member_)(p1_,p2_,p3_,p4_,a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_4_1::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,A1) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _TessMemberResultCallback_4_1(obj, member, p1, p2, p3, p4); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_4_1::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,A1) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _TessMemberResultCallback_4_1(obj, member, p1, p2, p3, p4); } #endif template class _TessFunctionResultCallback_4_1 : public TessResultCallback1 { public: typedef TessResultCallback1 base; typedef R (*FunctionSignature)(P1,P2,P3,P4,A1); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _TessFunctionResultCallback_4_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual R Run(A1 a1) { if (!del) { R result = (*function_)(p1_,p2_,p3_,p4_,a1); return result; } else { R result = (*function_)(p1_,p2_,p3_,p4_,a1); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_4_1 : public TessCallback1 { public: typedef TessCallback1 base; typedef void (*FunctionSignature)(P1,P2,P3,P4,A1); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _TessFunctionResultCallback_4_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual void Run(A1 a1) { if (!del) { (*function_)(p1_,p2_,p3_,p4_,a1); } else { (*function_)(p1_,p2_,p3_,p4_,a1); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_4_1::base* NewTessCallback(R (*function)(P1,P2,P3,P4,A1), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _TessFunctionResultCallback_4_1(function, p1, p2, p3, p4); } template inline typename _TessFunctionResultCallback_4_1::base* NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,A1), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _TessFunctionResultCallback_4_1(function, p1, p2, p3, p4); } template class _ConstTessMemberResultCallback_5_1 : public TessResultCallback1 { public: typedef TessResultCallback1 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _ConstTessMemberResultCallback_5_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual R Run(A1 a1) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_5_1 : public TessCallback1 { public: typedef TessCallback1 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _ConstTessMemberResultCallback_5_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual void Run(A1 a1) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1); } else { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_5_1::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _ConstTessMemberResultCallback_5_1(obj, member, p1, p2, p3, p4, p5); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_5_1::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _ConstTessMemberResultCallback_5_1(obj, member, p1, p2, p3, p4, p5); } #endif template class _TessMemberResultCallback_5_1 : public TessResultCallback1 { public: typedef TessResultCallback1 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _TessMemberResultCallback_5_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual R Run(A1 a1) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_5_1 : public TessCallback1 { public: typedef TessCallback1 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _TessMemberResultCallback_5_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual void Run(A1 a1) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1); } else { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_5_1::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _TessMemberResultCallback_5_1(obj, member, p1, p2, p3, p4, p5); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_5_1::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _TessMemberResultCallback_5_1(obj, member, p1, p2, p3, p4, p5); } #endif template class _TessFunctionResultCallback_5_1 : public TessResultCallback1 { public: typedef TessResultCallback1 base; typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,A1); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _TessFunctionResultCallback_5_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual R Run(A1 a1) { if (!del) { R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1); return result; } else { R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_5_1 : public TessCallback1 { public: typedef TessCallback1 base; typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,A1); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _TessFunctionResultCallback_5_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual void Run(A1 a1) { if (!del) { (*function_)(p1_,p2_,p3_,p4_,p5_,a1); } else { (*function_)(p1_,p2_,p3_,p4_,p5_,a1); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_5_1::base* NewTessCallback(R (*function)(P1,P2,P3,P4,P5,A1), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _TessFunctionResultCallback_5_1(function, p1, p2, p3, p4, p5); } template inline typename _TessFunctionResultCallback_5_1::base* NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,A1), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _TessFunctionResultCallback_5_1(function, p1, p2, p3, p4, p5); } template class _ConstTessMemberResultCallback_6_1 : public TessResultCallback1 { public: typedef TessResultCallback1 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _ConstTessMemberResultCallback_6_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual R Run(A1 a1) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_6_1 : public TessCallback1 { public: typedef TessCallback1 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _ConstTessMemberResultCallback_6_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual void Run(A1 a1) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1); } else { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_6_1::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _ConstTessMemberResultCallback_6_1(obj, member, p1, p2, p3, p4, p5, p6); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_6_1::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _ConstTessMemberResultCallback_6_1(obj, member, p1, p2, p3, p4, p5, p6); } #endif template class _TessMemberResultCallback_6_1 : public TessResultCallback1 { public: typedef TessResultCallback1 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _TessMemberResultCallback_6_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual R Run(A1 a1) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_6_1 : public TessCallback1 { public: typedef TessCallback1 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _TessMemberResultCallback_6_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual void Run(A1 a1) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1); } else { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_6_1::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _TessMemberResultCallback_6_1(obj, member, p1, p2, p3, p4, p5, p6); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_6_1::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _TessMemberResultCallback_6_1(obj, member, p1, p2, p3, p4, p5, p6); } #endif template class _TessFunctionResultCallback_6_1 : public TessResultCallback1 { public: typedef TessResultCallback1 base; typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _TessFunctionResultCallback_6_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual R Run(A1 a1) { if (!del) { R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1); return result; } else { R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_6_1 : public TessCallback1 { public: typedef TessCallback1 base; typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _TessFunctionResultCallback_6_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual void Run(A1 a1) { if (!del) { (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1); } else { (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_6_1::base* NewTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _TessFunctionResultCallback_6_1(function, p1, p2, p3, p4, p5, p6); } template inline typename _TessFunctionResultCallback_6_1::base* NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _TessFunctionResultCallback_6_1(function, p1, p2, p3, p4, p5, p6); } template class _ConstTessMemberResultCallback_0_2 : public TessResultCallback2 { public: typedef TessResultCallback2 base; typedef R (T::*MemberSignature)(A1,A2) const; private: const T* object_; MemberSignature member_; public: inline _ConstTessMemberResultCallback_0_2( const T* object, MemberSignature member) : object_(object), member_(member) { } virtual R Run(A1 a1,A2 a2) { if (!del) { R result = (object_->*member_)(a1,a2); return result; } else { R result = (object_->*member_)(a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_0_2 : public TessCallback2 { public: typedef TessCallback2 base; typedef void (T::*MemberSignature)(A1,A2) const; private: const T* object_; MemberSignature member_; public: inline _ConstTessMemberResultCallback_0_2( const T* object, MemberSignature member) : object_(object), member_(member) { } virtual void Run(A1 a1,A2 a2) { if (!del) { (object_->*member_)(a1,a2); } else { (object_->*member_)(a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_0_2::base* NewTessCallback( const T1* obj, R (T2::*member)(A1,A2) const) { return new _ConstTessMemberResultCallback_0_2( obj, member); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_0_2::base* NewPermanentTessCallback( const T1* obj, R (T2::*member)(A1,A2) const) { return new _ConstTessMemberResultCallback_0_2( obj, member); } #endif template class _TessMemberResultCallback_0_2 : public TessResultCallback2 { public: typedef TessResultCallback2 base; typedef R (T::*MemberSignature)(A1,A2) ; private: T* object_; MemberSignature member_; public: inline _TessMemberResultCallback_0_2( T* object, MemberSignature member) : object_(object), member_(member) { } virtual R Run(A1 a1,A2 a2) { if (!del) { R result = (object_->*member_)(a1,a2); return result; } else { R result = (object_->*member_)(a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_0_2 : public TessCallback2 { public: typedef TessCallback2 base; typedef void (T::*MemberSignature)(A1,A2) ; private: T* object_; MemberSignature member_; public: inline _TessMemberResultCallback_0_2( T* object, MemberSignature member) : object_(object), member_(member) { } virtual void Run(A1 a1,A2 a2) { if (!del) { (object_->*member_)(a1,a2); } else { (object_->*member_)(a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_0_2::base* NewTessCallback( T1* obj, R (T2::*member)(A1,A2) ) { return new _TessMemberResultCallback_0_2( obj, member); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_0_2::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(A1,A2) ) { return new _TessMemberResultCallback_0_2( obj, member); } #endif template class _TessFunctionResultCallback_0_2 : public TessResultCallback2 { public: typedef TessResultCallback2 base; typedef R (*FunctionSignature)(A1,A2); private: FunctionSignature function_; public: inline _TessFunctionResultCallback_0_2( FunctionSignature function) : function_(function) { } virtual R Run(A1 a1,A2 a2) { if (!del) { R result = (*function_)(a1,a2); return result; } else { R result = (*function_)(a1,a2); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_0_2 : public TessCallback2 { public: typedef TessCallback2 base; typedef void (*FunctionSignature)(A1,A2); private: FunctionSignature function_; public: inline _TessFunctionResultCallback_0_2( FunctionSignature function) : function_(function) { } virtual void Run(A1 a1,A2 a2) { if (!del) { (*function_)(a1,a2); } else { (*function_)(a1,a2); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_0_2::base* NewTessCallback(R (*function)(A1,A2)) { return new _TessFunctionResultCallback_0_2(function); } template inline typename _TessFunctionResultCallback_0_2::base* NewPermanentTessCallback(R (*function)(A1,A2)) { return new _TessFunctionResultCallback_0_2(function); } template class _ConstTessMemberResultCallback_1_2 : public TessResultCallback2 { public: typedef TessResultCallback2 base; typedef R (T::*MemberSignature)(P1,A1,A2) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; public: inline _ConstTessMemberResultCallback_1_2(const T* object, MemberSignature member, P1 p1) : object_(object), member_(member), p1_(p1) { } virtual R Run(A1 a1,A2 a2) { if (!del) { R result = (object_->*member_)(p1_,a1,a2); return result; } else { R result = (object_->*member_)(p1_,a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_1_2 : public TessCallback2 { public: typedef TessCallback2 base; typedef void (T::*MemberSignature)(P1,A1,A2) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; public: inline _ConstTessMemberResultCallback_1_2(const T* object, MemberSignature member, P1 p1) : object_(object), member_(member), p1_(p1) { } virtual void Run(A1 a1,A2 a2) { if (!del) { (object_->*member_)(p1_,a1,a2); } else { (object_->*member_)(p1_,a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_1_2::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,A1,A2) const, typename Identity::type p1) { return new _ConstTessMemberResultCallback_1_2(obj, member, p1); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_1_2::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,A1,A2) const, typename Identity::type p1) { return new _ConstTessMemberResultCallback_1_2(obj, member, p1); } #endif template class _TessMemberResultCallback_1_2 : public TessResultCallback2 { public: typedef TessResultCallback2 base; typedef R (T::*MemberSignature)(P1,A1,A2) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; public: inline _TessMemberResultCallback_1_2( T* object, MemberSignature member, P1 p1) : object_(object), member_(member), p1_(p1) { } virtual R Run(A1 a1,A2 a2) { if (!del) { R result = (object_->*member_)(p1_,a1,a2); return result; } else { R result = (object_->*member_)(p1_,a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_1_2 : public TessCallback2 { public: typedef TessCallback2 base; typedef void (T::*MemberSignature)(P1,A1,A2) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; public: inline _TessMemberResultCallback_1_2( T* object, MemberSignature member, P1 p1) : object_(object), member_(member), p1_(p1) { } virtual void Run(A1 a1,A2 a2) { if (!del) { (object_->*member_)(p1_,a1,a2); } else { (object_->*member_)(p1_,a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_1_2::base* NewTessCallback( T1* obj, R (T2::*member)(P1,A1,A2) , typename Identity::type p1) { return new _TessMemberResultCallback_1_2(obj, member, p1); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_1_2::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,A1,A2) , typename Identity::type p1) { return new _TessMemberResultCallback_1_2(obj, member, p1); } #endif template class _TessFunctionResultCallback_1_2 : public TessResultCallback2 { public: typedef TessResultCallback2 base; typedef R (*FunctionSignature)(P1,A1,A2); private: FunctionSignature function_; typename remove_reference::type p1_; public: inline _TessFunctionResultCallback_1_2(FunctionSignature function, P1 p1) : function_(function), p1_(p1) { } virtual R Run(A1 a1,A2 a2) { if (!del) { R result = (*function_)(p1_,a1,a2); return result; } else { R result = (*function_)(p1_,a1,a2); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_1_2 : public TessCallback2 { public: typedef TessCallback2 base; typedef void (*FunctionSignature)(P1,A1,A2); private: FunctionSignature function_; typename remove_reference::type p1_; public: inline _TessFunctionResultCallback_1_2(FunctionSignature function, P1 p1) : function_(function), p1_(p1) { } virtual void Run(A1 a1,A2 a2) { if (!del) { (*function_)(p1_,a1,a2); } else { (*function_)(p1_,a1,a2); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_1_2::base* NewTessCallback(R (*function)(P1,A1,A2), typename Identity::type p1) { return new _TessFunctionResultCallback_1_2(function, p1); } template inline typename _TessFunctionResultCallback_1_2::base* NewPermanentTessCallback(R (*function)(P1,A1,A2), typename Identity::type p1) { return new _TessFunctionResultCallback_1_2(function, p1); } template class _ConstTessMemberResultCallback_2_2 : public TessResultCallback2 { public: typedef TessResultCallback2 base; typedef R (T::*MemberSignature)(P1,P2,A1,A2) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _ConstTessMemberResultCallback_2_2(const T* object, MemberSignature member, P1 p1, P2 p2) : object_(object), member_(member), p1_(p1), p2_(p2) { } virtual R Run(A1 a1,A2 a2) { if (!del) { R result = (object_->*member_)(p1_,p2_,a1,a2); return result; } else { R result = (object_->*member_)(p1_,p2_,a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_2_2 : public TessCallback2 { public: typedef TessCallback2 base; typedef void (T::*MemberSignature)(P1,P2,A1,A2) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _ConstTessMemberResultCallback_2_2(const T* object, MemberSignature member, P1 p1, P2 p2) : object_(object), member_(member), p1_(p1), p2_(p2) { } virtual void Run(A1 a1,A2 a2) { if (!del) { (object_->*member_)(p1_,p2_,a1,a2); } else { (object_->*member_)(p1_,p2_,a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_2_2::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2) const, typename Identity::type p1, typename Identity::type p2) { return new _ConstTessMemberResultCallback_2_2(obj, member, p1, p2); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_2_2::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2) const, typename Identity::type p1, typename Identity::type p2) { return new _ConstTessMemberResultCallback_2_2(obj, member, p1, p2); } #endif template class _TessMemberResultCallback_2_2 : public TessResultCallback2 { public: typedef TessResultCallback2 base; typedef R (T::*MemberSignature)(P1,P2,A1,A2) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _TessMemberResultCallback_2_2( T* object, MemberSignature member, P1 p1, P2 p2) : object_(object), member_(member), p1_(p1), p2_(p2) { } virtual R Run(A1 a1,A2 a2) { if (!del) { R result = (object_->*member_)(p1_,p2_,a1,a2); return result; } else { R result = (object_->*member_)(p1_,p2_,a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_2_2 : public TessCallback2 { public: typedef TessCallback2 base; typedef void (T::*MemberSignature)(P1,P2,A1,A2) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _TessMemberResultCallback_2_2( T* object, MemberSignature member, P1 p1, P2 p2) : object_(object), member_(member), p1_(p1), p2_(p2) { } virtual void Run(A1 a1,A2 a2) { if (!del) { (object_->*member_)(p1_,p2_,a1,a2); } else { (object_->*member_)(p1_,p2_,a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_2_2::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,A1,A2) , typename Identity::type p1, typename Identity::type p2) { return new _TessMemberResultCallback_2_2(obj, member, p1, p2); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_2_2::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,A1,A2) , typename Identity::type p1, typename Identity::type p2) { return new _TessMemberResultCallback_2_2(obj, member, p1, p2); } #endif template class _TessFunctionResultCallback_2_2 : public TessResultCallback2 { public: typedef TessResultCallback2 base; typedef R (*FunctionSignature)(P1,P2,A1,A2); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _TessFunctionResultCallback_2_2(FunctionSignature function, P1 p1, P2 p2) : function_(function), p1_(p1), p2_(p2) { } virtual R Run(A1 a1,A2 a2) { if (!del) { R result = (*function_)(p1_,p2_,a1,a2); return result; } else { R result = (*function_)(p1_,p2_,a1,a2); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_2_2 : public TessCallback2 { public: typedef TessCallback2 base; typedef void (*FunctionSignature)(P1,P2,A1,A2); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _TessFunctionResultCallback_2_2(FunctionSignature function, P1 p1, P2 p2) : function_(function), p1_(p1), p2_(p2) { } virtual void Run(A1 a1,A2 a2) { if (!del) { (*function_)(p1_,p2_,a1,a2); } else { (*function_)(p1_,p2_,a1,a2); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_2_2::base* NewTessCallback(R (*function)(P1,P2,A1,A2), typename Identity::type p1, typename Identity::type p2) { return new _TessFunctionResultCallback_2_2(function, p1, p2); } template inline typename _TessFunctionResultCallback_2_2::base* NewPermanentTessCallback(R (*function)(P1,P2,A1,A2), typename Identity::type p1, typename Identity::type p2) { return new _TessFunctionResultCallback_2_2(function, p1, p2); } template class _ConstTessMemberResultCallback_3_2 : public TessResultCallback2 { public: typedef TessResultCallback2 base; typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _ConstTessMemberResultCallback_3_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) { } virtual R Run(A1 a1,A2 a2) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,a1,a2); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_3_2 : public TessCallback2 { public: typedef TessCallback2 base; typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _ConstTessMemberResultCallback_3_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) { } virtual void Run(A1 a1,A2 a2) { if (!del) { (object_->*member_)(p1_,p2_,p3_,a1,a2); } else { (object_->*member_)(p1_,p2_,p3_,a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_3_2::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1,A2) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _ConstTessMemberResultCallback_3_2(obj, member, p1, p2, p3); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_3_2::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1,A2) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _ConstTessMemberResultCallback_3_2(obj, member, p1, p2, p3); } #endif template class _TessMemberResultCallback_3_2 : public TessResultCallback2 { public: typedef TessResultCallback2 base; typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _TessMemberResultCallback_3_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) { } virtual R Run(A1 a1,A2 a2) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,a1,a2); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_3_2 : public TessCallback2 { public: typedef TessCallback2 base; typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _TessMemberResultCallback_3_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) { } virtual void Run(A1 a1,A2 a2) { if (!del) { (object_->*member_)(p1_,p2_,p3_,a1,a2); } else { (object_->*member_)(p1_,p2_,p3_,a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_3_2::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,A1,A2) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _TessMemberResultCallback_3_2(obj, member, p1, p2, p3); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_3_2::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,A1,A2) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _TessMemberResultCallback_3_2(obj, member, p1, p2, p3); } #endif template class _TessFunctionResultCallback_3_2 : public TessResultCallback2 { public: typedef TessResultCallback2 base; typedef R (*FunctionSignature)(P1,P2,P3,A1,A2); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _TessFunctionResultCallback_3_2(FunctionSignature function, P1 p1, P2 p2, P3 p3) : function_(function), p1_(p1), p2_(p2), p3_(p3) { } virtual R Run(A1 a1,A2 a2) { if (!del) { R result = (*function_)(p1_,p2_,p3_,a1,a2); return result; } else { R result = (*function_)(p1_,p2_,p3_,a1,a2); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_3_2 : public TessCallback2 { public: typedef TessCallback2 base; typedef void (*FunctionSignature)(P1,P2,P3,A1,A2); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _TessFunctionResultCallback_3_2(FunctionSignature function, P1 p1, P2 p2, P3 p3) : function_(function), p1_(p1), p2_(p2), p3_(p3) { } virtual void Run(A1 a1,A2 a2) { if (!del) { (*function_)(p1_,p2_,p3_,a1,a2); } else { (*function_)(p1_,p2_,p3_,a1,a2); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_3_2::base* NewTessCallback(R (*function)(P1,P2,P3,A1,A2), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _TessFunctionResultCallback_3_2(function, p1, p2, p3); } template inline typename _TessFunctionResultCallback_3_2::base* NewPermanentTessCallback(R (*function)(P1,P2,P3,A1,A2), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _TessFunctionResultCallback_3_2(function, p1, p2, p3); } template class _ConstTessMemberResultCallback_4_2 : public TessResultCallback2 { public: typedef TessResultCallback2 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _ConstTessMemberResultCallback_4_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual R Run(A1 a1,A2 a2) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_4_2 : public TessCallback2 { public: typedef TessCallback2 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _ConstTessMemberResultCallback_4_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual void Run(A1 a1,A2 a2) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2); } else { (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_4_2::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _ConstTessMemberResultCallback_4_2(obj, member, p1, p2, p3, p4); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_4_2::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _ConstTessMemberResultCallback_4_2(obj, member, p1, p2, p3, p4); } #endif template class _TessMemberResultCallback_4_2 : public TessResultCallback2 { public: typedef TessResultCallback2 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _TessMemberResultCallback_4_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual R Run(A1 a1,A2 a2) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_4_2 : public TessCallback2 { public: typedef TessCallback2 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _TessMemberResultCallback_4_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual void Run(A1 a1,A2 a2) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2); } else { (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_4_2::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _TessMemberResultCallback_4_2(obj, member, p1, p2, p3, p4); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_4_2::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _TessMemberResultCallback_4_2(obj, member, p1, p2, p3, p4); } #endif template class _TessFunctionResultCallback_4_2 : public TessResultCallback2 { public: typedef TessResultCallback2 base; typedef R (*FunctionSignature)(P1,P2,P3,P4,A1,A2); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _TessFunctionResultCallback_4_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual R Run(A1 a1,A2 a2) { if (!del) { R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2); return result; } else { R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_4_2 : public TessCallback2 { public: typedef TessCallback2 base; typedef void (*FunctionSignature)(P1,P2,P3,P4,A1,A2); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _TessFunctionResultCallback_4_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual void Run(A1 a1,A2 a2) { if (!del) { (*function_)(p1_,p2_,p3_,p4_,a1,a2); } else { (*function_)(p1_,p2_,p3_,p4_,a1,a2); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_4_2::base* NewTessCallback(R (*function)(P1,P2,P3,P4,A1,A2), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _TessFunctionResultCallback_4_2(function, p1, p2, p3, p4); } template inline typename _TessFunctionResultCallback_4_2::base* NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,A1,A2), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _TessFunctionResultCallback_4_2(function, p1, p2, p3, p4); } template class _ConstTessMemberResultCallback_5_2 : public TessResultCallback2 { public: typedef TessResultCallback2 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _ConstTessMemberResultCallback_5_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual R Run(A1 a1,A2 a2) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_5_2 : public TessCallback2 { public: typedef TessCallback2 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _ConstTessMemberResultCallback_5_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual void Run(A1 a1,A2 a2) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2); } else { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_5_2::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _ConstTessMemberResultCallback_5_2(obj, member, p1, p2, p3, p4, p5); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_5_2::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _ConstTessMemberResultCallback_5_2(obj, member, p1, p2, p3, p4, p5); } #endif template class _TessMemberResultCallback_5_2 : public TessResultCallback2 { public: typedef TessResultCallback2 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _TessMemberResultCallback_5_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual R Run(A1 a1,A2 a2) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_5_2 : public TessCallback2 { public: typedef TessCallback2 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _TessMemberResultCallback_5_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual void Run(A1 a1,A2 a2) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2); } else { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_5_2::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _TessMemberResultCallback_5_2(obj, member, p1, p2, p3, p4, p5); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_5_2::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _TessMemberResultCallback_5_2(obj, member, p1, p2, p3, p4, p5); } #endif template class _TessFunctionResultCallback_5_2 : public TessResultCallback2 { public: typedef TessResultCallback2 base; typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _TessFunctionResultCallback_5_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual R Run(A1 a1,A2 a2) { if (!del) { R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2); return result; } else { R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_5_2 : public TessCallback2 { public: typedef TessCallback2 base; typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _TessFunctionResultCallback_5_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual void Run(A1 a1,A2 a2) { if (!del) { (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2); } else { (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_5_2::base* NewTessCallback(R (*function)(P1,P2,P3,P4,P5,A1,A2), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _TessFunctionResultCallback_5_2(function, p1, p2, p3, p4, p5); } template inline typename _TessFunctionResultCallback_5_2::base* NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,A1,A2), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _TessFunctionResultCallback_5_2(function, p1, p2, p3, p4, p5); } template class _ConstTessMemberResultCallback_6_2 : public TessResultCallback2 { public: typedef TessResultCallback2 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _ConstTessMemberResultCallback_6_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual R Run(A1 a1,A2 a2) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_6_2 : public TessCallback2 { public: typedef TessCallback2 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _ConstTessMemberResultCallback_6_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual void Run(A1 a1,A2 a2) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2); } else { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_6_2::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _ConstTessMemberResultCallback_6_2(obj, member, p1, p2, p3, p4, p5, p6); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_6_2::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _ConstTessMemberResultCallback_6_2(obj, member, p1, p2, p3, p4, p5, p6); } #endif template class _TessMemberResultCallback_6_2 : public TessResultCallback2 { public: typedef TessResultCallback2 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _TessMemberResultCallback_6_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual R Run(A1 a1,A2 a2) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_6_2 : public TessCallback2 { public: typedef TessCallback2 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _TessMemberResultCallback_6_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual void Run(A1 a1,A2 a2) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2); } else { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_6_2::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _TessMemberResultCallback_6_2(obj, member, p1, p2, p3, p4, p5, p6); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_6_2::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _TessMemberResultCallback_6_2(obj, member, p1, p2, p3, p4, p5, p6); } #endif template class _TessFunctionResultCallback_6_2 : public TessResultCallback2 { public: typedef TessResultCallback2 base; typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _TessFunctionResultCallback_6_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual R Run(A1 a1,A2 a2) { if (!del) { R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2); return result; } else { R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_6_2 : public TessCallback2 { public: typedef TessCallback2 base; typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _TessFunctionResultCallback_6_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual void Run(A1 a1,A2 a2) { if (!del) { (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2); } else { (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_6_2::base* NewTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1,A2), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _TessFunctionResultCallback_6_2(function, p1, p2, p3, p4, p5, p6); } template inline typename _TessFunctionResultCallback_6_2::base* NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1,A2), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _TessFunctionResultCallback_6_2(function, p1, p2, p3, p4, p5, p6); } template class _ConstTessMemberResultCallback_0_3 : public TessResultCallback3 { public: typedef TessResultCallback3 base; typedef R (T::*MemberSignature)(A1,A2,A3) const; private: const T* object_; MemberSignature member_; public: inline _ConstTessMemberResultCallback_0_3( const T* object, MemberSignature member) : object_(object), member_(member) { } virtual R Run(A1 a1,A2 a2,A3 a3) { if (!del) { R result = (object_->*member_)(a1,a2,a3); return result; } else { R result = (object_->*member_)(a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_0_3 : public TessCallback3 { public: typedef TessCallback3 base; typedef void (T::*MemberSignature)(A1,A2,A3) const; private: const T* object_; MemberSignature member_; public: inline _ConstTessMemberResultCallback_0_3( const T* object, MemberSignature member) : object_(object), member_(member) { } virtual void Run(A1 a1,A2 a2,A3 a3) { if (!del) { (object_->*member_)(a1,a2,a3); } else { (object_->*member_)(a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_0_3::base* NewTessCallback( const T1* obj, R (T2::*member)(A1,A2,A3) const) { return new _ConstTessMemberResultCallback_0_3( obj, member); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_0_3::base* NewPermanentTessCallback( const T1* obj, R (T2::*member)(A1,A2,A3) const) { return new _ConstTessMemberResultCallback_0_3( obj, member); } #endif template class _TessMemberResultCallback_0_3 : public TessResultCallback3 { public: typedef TessResultCallback3 base; typedef R (T::*MemberSignature)(A1,A2,A3) ; private: T* object_; MemberSignature member_; public: inline _TessMemberResultCallback_0_3( T* object, MemberSignature member) : object_(object), member_(member) { } virtual R Run(A1 a1,A2 a2,A3 a3) { if (!del) { R result = (object_->*member_)(a1,a2,a3); return result; } else { R result = (object_->*member_)(a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_0_3 : public TessCallback3 { public: typedef TessCallback3 base; typedef void (T::*MemberSignature)(A1,A2,A3) ; private: T* object_; MemberSignature member_; public: inline _TessMemberResultCallback_0_3( T* object, MemberSignature member) : object_(object), member_(member) { } virtual void Run(A1 a1,A2 a2,A3 a3) { if (!del) { (object_->*member_)(a1,a2,a3); } else { (object_->*member_)(a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_0_3::base* NewTessCallback( T1* obj, R (T2::*member)(A1,A2,A3) ) { return new _TessMemberResultCallback_0_3( obj, member); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_0_3::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(A1,A2,A3) ) { return new _TessMemberResultCallback_0_3( obj, member); } #endif template class _TessFunctionResultCallback_0_3 : public TessResultCallback3 { public: typedef TessResultCallback3 base; typedef R (*FunctionSignature)(A1,A2,A3); private: FunctionSignature function_; public: inline _TessFunctionResultCallback_0_3( FunctionSignature function) : function_(function) { } virtual R Run(A1 a1,A2 a2,A3 a3) { if (!del) { R result = (*function_)(a1,a2,a3); return result; } else { R result = (*function_)(a1,a2,a3); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_0_3 : public TessCallback3 { public: typedef TessCallback3 base; typedef void (*FunctionSignature)(A1,A2,A3); private: FunctionSignature function_; public: inline _TessFunctionResultCallback_0_3( FunctionSignature function) : function_(function) { } virtual void Run(A1 a1,A2 a2,A3 a3) { if (!del) { (*function_)(a1,a2,a3); } else { (*function_)(a1,a2,a3); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_0_3::base* NewTessCallback(R (*function)(A1,A2,A3)) { return new _TessFunctionResultCallback_0_3(function); } template inline typename _TessFunctionResultCallback_0_3::base* NewPermanentTessCallback(R (*function)(A1,A2,A3)) { return new _TessFunctionResultCallback_0_3(function); } template class _ConstTessMemberResultCallback_1_3 : public TessResultCallback3 { public: typedef TessResultCallback3 base; typedef R (T::*MemberSignature)(P1,A1,A2,A3) const; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; public: inline _ConstTessMemberResultCallback_1_3(T* object, MemberSignature member, P1 p1) : object_(object), member_(member), p1_(p1) { } virtual R Run(A1 a1, A2 a2, A3 a3) { if (!del) { R result = (object_->*member_)(p1_,a1,a2,a3); return result; } else { R result = (object_->*member_)(p1_,a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_1_3 : public TessCallback3 { public: typedef TessCallback3 base; typedef void (T::*MemberSignature)(P1,A1,A2,A3) const; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; public: inline _ConstTessMemberResultCallback_1_3(T* object, MemberSignature member, P1 p1) : object_(object), member_(member), p1_(p1) { } virtual void Run(A1 a1, A2 a2, A3 a3) { if (!del) { (object_->*member_)(p1_,a1,a2,a3); } else { (object_->*member_)(p1_,a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_1_3::base* NewTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3) , typename Identity::type p1) { return new _ConstTessMemberResultCallback_1_3(obj, member, p1); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_1_3::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3) , typename Identity::type p1) { return new _ConstTessMemberResultCallback_1_3(obj, member, p1); } #endif template class _TessMemberResultCallback_1_3 : public TessResultCallback3 { public: typedef TessResultCallback3 base; typedef R (T::*MemberSignature)(P1,A1,A2,A3) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; public: inline _TessMemberResultCallback_1_3(T* object, MemberSignature member, P1 p1) : object_(object), member_(member), p1_(p1) { } virtual R Run(A1 a1, A2 a2, A3 a3) { if (!del) { R result = (object_->*member_)(p1_,a1,a2,a3); return result; } else { R result = (object_->*member_)(p1_,a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_1_3 : public TessCallback3 { public: typedef TessCallback3 base; typedef void (T::*MemberSignature)(P1,A1,A2,A3) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; public: inline _TessMemberResultCallback_1_3(T* object, MemberSignature member, P1 p1) : object_(object), member_(member), p1_(p1) { } virtual void Run(A1 a1, A2 a2, A3 a3) { if (!del) { (object_->*member_)(p1_,a1,a2,a3); } else { (object_->*member_)(p1_,a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_1_3::base* NewTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3) , typename Identity::type p1) { return new _TessMemberResultCallback_1_3(obj, member, p1); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_1_3::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3) , typename Identity::type p1) { return new _TessMemberResultCallback_1_3(obj, member, p1); } #endif template class _TessFunctionResultCallback_1_3 : public TessCallback3 { public: typedef TessCallback3 base; typedef R (*FunctionSignature)(P1,A1,A2,A3); private: FunctionSignature function_; typename remove_reference::type p1_; public: inline _TessFunctionResultCallback_1_3(FunctionSignature function, P1 p1) : function_(function), p1_(p1) { } virtual R Run(A1 a1, A2 a2, A3 a3) { if (!del) { R result = (*function_)(p1_,a1,a2,a3); return result; } else { R result = (*function_)(p1_,a1,a2,a3); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_1_3 : public TessCallback3 { public: typedef TessCallback3 base; typedef void (*FunctionSignature)(P1,A1,A2,A3); private: FunctionSignature function_; typename remove_reference::type p1_; public: inline _TessFunctionResultCallback_1_3(FunctionSignature function, P1 p1) : function_(function), p1_(p1) { } virtual void Run(A1 a1, A2 a2, A3 a3) { if (!del) { (*function_)(p1_,a1,a2,a3); } else { (*function_)(p1_,a1,a2,a3); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_1_3::base* NewTessCallback(R (*function)(P1,A1,A2,A3), typename Identity::type p1) { return new _TessFunctionResultCallback_1_3(function, p1); } template inline typename _TessFunctionResultCallback_1_3::base* NewPermanentTessCallback(R (*function)(P1,A1,A2,A3), typename Identity::type p1) { return new _TessFunctionResultCallback_1_3(function, p1); } template class _ConstTessMemberResultCallback_2_3 : public TessResultCallback3 { public: typedef TessResultCallback3 base; typedef R (T::*MemberSignature)(P1,P2,A1,A2,A3) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _ConstTessMemberResultCallback_2_3(const T* object, MemberSignature member, P1 p1, P2 p2) : object_(object), member_(member), p1_(p1), p2_(p2) { } virtual R Run(A1 a1,A2 a2,A3 a3) { if (!del) { R result = (object_->*member_)(p1_,p2_,a1,a2,a3); return result; } else { R result = (object_->*member_)(p1_,p2_,a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_2_3 : public TessCallback3 { public: typedef TessCallback3 base; typedef void (T::*MemberSignature)(P1,P2,A1,A2,A3) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _ConstTessMemberResultCallback_2_3(const T* object, MemberSignature member, P1 p1, P2 p2) : object_(object), member_(member), p1_(p1), p2_(p2) { } virtual void Run(A1 a1,A2 a2,A3 a3) { if (!del) { (object_->*member_)(p1_,p2_,a1,a2,a3); } else { (object_->*member_)(p1_,p2_,a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_2_3::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2,A3) const, typename Identity::type p1, typename Identity::type p2) { return new _ConstTessMemberResultCallback_2_3(obj, member, p1, p2); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_2_3::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2,A3) const, typename Identity::type p1, typename Identity::type p2) { return new _ConstTessMemberResultCallback_2_3(obj, member, p1, p2); } #endif template class _TessMemberResultCallback_2_3 : public TessResultCallback3 { public: typedef TessResultCallback3 base; typedef R (T::*MemberSignature)(P1,P2,A1,A2,A3) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _TessMemberResultCallback_2_3( T* object, MemberSignature member, P1 p1, P2 p2) : object_(object), member_(member), p1_(p1), p2_(p2) { } virtual R Run(A1 a1,A2 a2,A3 a3) { if (!del) { R result = (object_->*member_)(p1_,p2_,a1,a2,a3); return result; } else { R result = (object_->*member_)(p1_,p2_,a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_2_3 : public TessCallback3 { public: typedef TessCallback3 base; typedef void (T::*MemberSignature)(P1,P2,A1,A2,A3) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _TessMemberResultCallback_2_3( T* object, MemberSignature member, P1 p1, P2 p2) : object_(object), member_(member), p1_(p1), p2_(p2) { } virtual void Run(A1 a1,A2 a2,A3 a3) { if (!del) { (object_->*member_)(p1_,p2_,a1,a2,a3); } else { (object_->*member_)(p1_,p2_,a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_2_3::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,A1,A2,A3) , typename Identity::type p1, typename Identity::type p2) { return new _TessMemberResultCallback_2_3(obj, member, p1, p2); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_2_3::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,A1,A2,A3) , typename Identity::type p1, typename Identity::type p2) { return new _TessMemberResultCallback_2_3(obj, member, p1, p2); } #endif template class _TessFunctionResultCallback_2_3 : public TessResultCallback3 { public: typedef TessResultCallback3 base; typedef R (*FunctionSignature)(P1,P2,A1,A2,A3); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _TessFunctionResultCallback_2_3(FunctionSignature function, P1 p1, P2 p2) : function_(function), p1_(p1), p2_(p2) { } virtual R Run(A1 a1,A2 a2,A3 a3) { if (!del) { R result = (*function_)(p1_,p2_,a1,a2,a3); return result; } else { R result = (*function_)(p1_,p2_,a1,a2,a3); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_2_3 : public TessCallback3 { public: typedef TessCallback3 base; typedef void (*FunctionSignature)(P1,P2,A1,A2,A3); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _TessFunctionResultCallback_2_3(FunctionSignature function, P1 p1, P2 p2) : function_(function), p1_(p1), p2_(p2) { } virtual void Run(A1 a1,A2 a2,A3 a3) { if (!del) { (*function_)(p1_,p2_,a1,a2,a3); } else { (*function_)(p1_,p2_,a1,a2,a3); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_2_3::base* NewTessCallback(R (*function)(P1,P2,A1,A2,A3), typename Identity::type p1, typename Identity::type p2) { return new _TessFunctionResultCallback_2_3(function, p1, p2); } template inline typename _TessFunctionResultCallback_2_3::base* NewPermanentTessCallback(R (*function)(P1,P2,A1,A2,A3), typename Identity::type p1, typename Identity::type p2) { return new _TessFunctionResultCallback_2_3(function, p1, p2); } template class _ConstTessMemberResultCallback_3_3 : public TessResultCallback3 { public: typedef TessResultCallback3 base; typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2,A3) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _ConstTessMemberResultCallback_3_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) { } virtual R Run(A1 a1,A2 a2,A3 a3) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_3_3 : public TessCallback3 { public: typedef TessCallback3 base; typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2,A3) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _ConstTessMemberResultCallback_3_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) { } virtual void Run(A1 a1,A2 a2,A3 a3) { if (!del) { (object_->*member_)(p1_,p2_,p3_,a1,a2,a3); } else { (object_->*member_)(p1_,p2_,p3_,a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_3_3::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _ConstTessMemberResultCallback_3_3(obj, member, p1, p2, p3); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_3_3::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _ConstTessMemberResultCallback_3_3(obj, member, p1, p2, p3); } #endif template class _TessMemberResultCallback_3_3 : public TessResultCallback3 { public: typedef TessResultCallback3 base; typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2,A3) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _TessMemberResultCallback_3_3( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) { } virtual R Run(A1 a1,A2 a2,A3 a3) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_3_3 : public TessCallback3 { public: typedef TessCallback3 base; typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2,A3) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _TessMemberResultCallback_3_3( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) { } virtual void Run(A1 a1,A2 a2,A3 a3) { if (!del) { (object_->*member_)(p1_,p2_,p3_,a1,a2,a3); } else { (object_->*member_)(p1_,p2_,p3_,a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_3_3::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _TessMemberResultCallback_3_3(obj, member, p1, p2, p3); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_3_3::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _TessMemberResultCallback_3_3(obj, member, p1, p2, p3); } #endif template class _TessFunctionResultCallback_3_3 : public TessResultCallback3 { public: typedef TessResultCallback3 base; typedef R (*FunctionSignature)(P1,P2,P3,A1,A2,A3); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _TessFunctionResultCallback_3_3(FunctionSignature function, P1 p1, P2 p2, P3 p3) : function_(function), p1_(p1), p2_(p2), p3_(p3) { } virtual R Run(A1 a1,A2 a2,A3 a3) { if (!del) { R result = (*function_)(p1_,p2_,p3_,a1,a2,a3); return result; } else { R result = (*function_)(p1_,p2_,p3_,a1,a2,a3); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_3_3 : public TessCallback3 { public: typedef TessCallback3 base; typedef void (*FunctionSignature)(P1,P2,P3,A1,A2,A3); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _TessFunctionResultCallback_3_3(FunctionSignature function, P1 p1, P2 p2, P3 p3) : function_(function), p1_(p1), p2_(p2), p3_(p3) { } virtual void Run(A1 a1,A2 a2,A3 a3) { if (!del) { (*function_)(p1_,p2_,p3_,a1,a2,a3); } else { (*function_)(p1_,p2_,p3_,a1,a2,a3); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_3_3::base* NewTessCallback(R (*function)(P1,P2,P3,A1,A2,A3), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _TessFunctionResultCallback_3_3(function, p1, p2, p3); } template inline typename _TessFunctionResultCallback_3_3::base* NewPermanentTessCallback(R (*function)(P1,P2,P3,A1,A2,A3), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _TessFunctionResultCallback_3_3(function, p1, p2, p3); } template class _ConstTessMemberResultCallback_4_3 : public TessResultCallback3 { public: typedef TessResultCallback3 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _ConstTessMemberResultCallback_4_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual R Run(A1 a1,A2 a2,A3 a3) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_4_3 : public TessCallback3 { public: typedef TessCallback3 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _ConstTessMemberResultCallback_4_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual void Run(A1 a1,A2 a2,A3 a3) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3); } else { (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_4_3::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _ConstTessMemberResultCallback_4_3(obj, member, p1, p2, p3, p4); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_4_3::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _ConstTessMemberResultCallback_4_3(obj, member, p1, p2, p3, p4); } #endif template class _TessMemberResultCallback_4_3 : public TessResultCallback3 { public: typedef TessResultCallback3 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _TessMemberResultCallback_4_3( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual R Run(A1 a1,A2 a2,A3 a3) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_4_3 : public TessCallback3 { public: typedef TessCallback3 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _TessMemberResultCallback_4_3( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual void Run(A1 a1,A2 a2,A3 a3) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3); } else { (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_4_3::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _TessMemberResultCallback_4_3(obj, member, p1, p2, p3, p4); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_4_3::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _TessMemberResultCallback_4_3(obj, member, p1, p2, p3, p4); } #endif template class _TessFunctionResultCallback_4_3 : public TessResultCallback3 { public: typedef TessResultCallback3 base; typedef R (*FunctionSignature)(P1,P2,P3,P4,A1,A2,A3); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _TessFunctionResultCallback_4_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual R Run(A1 a1,A2 a2,A3 a3) { if (!del) { R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3); return result; } else { R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_4_3 : public TessCallback3 { public: typedef TessCallback3 base; typedef void (*FunctionSignature)(P1,P2,P3,P4,A1,A2,A3); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _TessFunctionResultCallback_4_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual void Run(A1 a1,A2 a2,A3 a3) { if (!del) { (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3); } else { (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_4_3::base* NewTessCallback(R (*function)(P1,P2,P3,P4,A1,A2,A3), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _TessFunctionResultCallback_4_3(function, p1, p2, p3, p4); } template inline typename _TessFunctionResultCallback_4_3::base* NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,A1,A2,A3), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _TessFunctionResultCallback_4_3(function, p1, p2, p3, p4); } template class _ConstTessMemberResultCallback_5_3 : public TessResultCallback3 { public: typedef TessResultCallback3 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _ConstTessMemberResultCallback_5_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual R Run(A1 a1,A2 a2,A3 a3) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_5_3 : public TessCallback3 { public: typedef TessCallback3 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _ConstTessMemberResultCallback_5_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual void Run(A1 a1,A2 a2,A3 a3) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3); } else { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_5_3::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _ConstTessMemberResultCallback_5_3(obj, member, p1, p2, p3, p4, p5); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_5_3::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _ConstTessMemberResultCallback_5_3(obj, member, p1, p2, p3, p4, p5); } #endif template class _TessMemberResultCallback_5_3 : public TessResultCallback3 { public: typedef TessResultCallback3 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _TessMemberResultCallback_5_3( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual R Run(A1 a1,A2 a2,A3 a3) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_5_3 : public TessCallback3 { public: typedef TessCallback3 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _TessMemberResultCallback_5_3( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual void Run(A1 a1,A2 a2,A3 a3) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3); } else { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_5_3::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _TessMemberResultCallback_5_3(obj, member, p1, p2, p3, p4, p5); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_5_3::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _TessMemberResultCallback_5_3(obj, member, p1, p2, p3, p4, p5); } #endif template class _TessFunctionResultCallback_5_3 : public TessResultCallback3 { public: typedef TessResultCallback3 base; typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2,A3); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _TessFunctionResultCallback_5_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual R Run(A1 a1,A2 a2,A3 a3) { if (!del) { R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3); return result; } else { R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_5_3 : public TessCallback3 { public: typedef TessCallback3 base; typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2,A3); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _TessFunctionResultCallback_5_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual void Run(A1 a1,A2 a2,A3 a3) { if (!del) { (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3); } else { (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_5_3::base* NewTessCallback(R (*function)(P1,P2,P3,P4,P5,A1,A2,A3), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _TessFunctionResultCallback_5_3(function, p1, p2, p3, p4, p5); } template inline typename _TessFunctionResultCallback_5_3::base* NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,A1,A2,A3), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _TessFunctionResultCallback_5_3(function, p1, p2, p3, p4, p5); } template class _ConstTessMemberResultCallback_6_3 : public TessResultCallback3 { public: typedef TessResultCallback3 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _ConstTessMemberResultCallback_6_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual R Run(A1 a1,A2 a2,A3 a3) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_6_3 : public TessCallback3 { public: typedef TessCallback3 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _ConstTessMemberResultCallback_6_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual void Run(A1 a1,A2 a2,A3 a3) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3); } else { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_6_3::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _ConstTessMemberResultCallback_6_3(obj, member, p1, p2, p3, p4, p5, p6); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_6_3::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _ConstTessMemberResultCallback_6_3(obj, member, p1, p2, p3, p4, p5, p6); } #endif template class _TessMemberResultCallback_6_3 : public TessResultCallback3 { public: typedef TessResultCallback3 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _TessMemberResultCallback_6_3( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual R Run(A1 a1,A2 a2,A3 a3) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_6_3 : public TessCallback3 { public: typedef TessCallback3 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _TessMemberResultCallback_6_3( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual void Run(A1 a1,A2 a2,A3 a3) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3); } else { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_6_3::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _TessMemberResultCallback_6_3(obj, member, p1, p2, p3, p4, p5, p6); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_6_3::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _TessMemberResultCallback_6_3(obj, member, p1, p2, p3, p4, p5, p6); } #endif template class _TessFunctionResultCallback_6_3 : public TessResultCallback3 { public: typedef TessResultCallback3 base; typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _TessFunctionResultCallback_6_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual R Run(A1 a1,A2 a2,A3 a3) { if (!del) { R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3); return result; } else { R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_6_3 : public TessCallback3 { public: typedef TessCallback3 base; typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _TessFunctionResultCallback_6_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual void Run(A1 a1,A2 a2,A3 a3) { if (!del) { (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3); } else { (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_6_3::base* NewTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1,A2,A3), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _TessFunctionResultCallback_6_3(function, p1, p2, p3, p4, p5, p6); } template inline typename _TessFunctionResultCallback_6_3::base* NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1,A2,A3), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _TessFunctionResultCallback_6_3(function, p1, p2, p3, p4, p5, p6); } template class _ConstTessMemberResultCallback_0_4 : public TessResultCallback4 { public: typedef TessResultCallback4 base; typedef R (T::*MemberSignature)(A1,A2,A3,A4) const; private: const T* object_; MemberSignature member_; public: inline _ConstTessMemberResultCallback_0_4(const T* object, MemberSignature member) : object_(object), member_(member) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { R result = (object_->*member_)(a1,a2,a3,a4); return result; } else { R result = (object_->*member_)(a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_0_4 : public TessCallback4 { public: typedef TessCallback4 base; typedef void (T::*MemberSignature)(A1,A2,A3,A4) const; private: const T* object_; MemberSignature member_; public: inline _ConstTessMemberResultCallback_0_4(const T* object, MemberSignature member) : object_(object), member_(member) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { (object_->*member_)(a1,a2,a3,a4); } else { (object_->*member_)(a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_0_4::base* NewTessCallback(const T1* obj, R (T2::*member)(A1,A2,A3,A4) const) { return new _ConstTessMemberResultCallback_0_4(obj, member); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_0_4::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(A1,A2,A3,A4) const) { return new _ConstTessMemberResultCallback_0_4(obj, member); } #endif template class _TessMemberResultCallback_0_4 : public TessResultCallback4 { public: typedef TessResultCallback4 base; typedef R (T::*MemberSignature)(A1,A2,A3,A4) ; private: T* object_; MemberSignature member_; public: inline _TessMemberResultCallback_0_4( T* object, MemberSignature member) : object_(object), member_(member) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { R result = (object_->*member_)(a1,a2,a3,a4); return result; } else { R result = (object_->*member_)(a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_0_4 : public TessCallback4 { public: typedef TessCallback4 base; typedef void (T::*MemberSignature)(A1,A2,A3,A4) ; private: T* object_; MemberSignature member_; public: inline _TessMemberResultCallback_0_4( T* object, MemberSignature member) : object_(object), member_(member) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { (object_->*member_)(a1,a2,a3,a4); } else { (object_->*member_)(a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_0_4::base* NewTessCallback( T1* obj, R (T2::*member)(A1,A2,A3,A4) ) { return new _TessMemberResultCallback_0_4(obj, member); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_0_4::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(A1,A2,A3,A4) ) { return new _TessMemberResultCallback_0_4(obj, member); } #endif template class _TessFunctionResultCallback_0_4 : public TessResultCallback4 { public: typedef TessResultCallback4 base; typedef R (*FunctionSignature)(A1,A2,A3,A4); private: FunctionSignature function_; public: inline _TessFunctionResultCallback_0_4(FunctionSignature function) : function_(function) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { R result = (*function_)(a1,a2,a3,a4); return result; } else { R result = (*function_)(a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_0_4 : public TessCallback4 { public: typedef TessCallback4 base; typedef void (*FunctionSignature)(A1,A2,A3,A4); private: FunctionSignature function_; public: inline _TessFunctionResultCallback_0_4(FunctionSignature function) : function_(function) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { (*function_)(a1,a2,a3,a4); } else { (*function_)(a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_0_4::base* NewTessCallback(R (*function)(A1,A2,A3,A4)) { return new _TessFunctionResultCallback_0_4(function); } template inline typename _TessFunctionResultCallback_0_4::base* NewPermanentTessCallback(R (*function)(A1,A2,A3,A4)) { return new _TessFunctionResultCallback_0_4(function); } template class _ConstTessMemberResultCallback_1_4 : public TessResultCallback4 { public: typedef TessResultCallback4 base; typedef R (T::*MemberSignature)(P1,A1,A2,A3,A4) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; public: inline _ConstTessMemberResultCallback_1_4(const T* object, MemberSignature member, P1 p1) : object_(object), member_(member), p1_(p1) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { R result = (object_->*member_)(p1_,a1,a2,a3,a4); return result; } else { R result = (object_->*member_)(p1_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_1_4 : public TessCallback4 { public: typedef TessCallback4 base; typedef void (T::*MemberSignature)(P1,A1,A2,A3,A4) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; public: inline _ConstTessMemberResultCallback_1_4(const T* object, MemberSignature member, P1 p1) : object_(object), member_(member), p1_(p1) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { (object_->*member_)(p1_,a1,a2,a3,a4); } else { (object_->*member_)(p1_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_1_4::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,A1,A2,A3,A4) const, typename Identity::type p1) { return new _ConstTessMemberResultCallback_1_4(obj, member, p1); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_1_4::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,A1,A2,A3,A4) const, typename Identity::type p1) { return new _ConstTessMemberResultCallback_1_4(obj, member, p1); } #endif template class _TessMemberResultCallback_1_4 : public TessResultCallback4 { public: typedef TessResultCallback4 base; typedef R (T::*MemberSignature)(P1,A1,A2,A3,A4) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; public: inline _TessMemberResultCallback_1_4( T* object, MemberSignature member, P1 p1) : object_(object), member_(member), p1_(p1) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { R result = (object_->*member_)(p1_,a1,a2,a3,a4); return result; } else { R result = (object_->*member_)(p1_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_1_4 : public TessCallback4 { public: typedef TessCallback4 base; typedef void (T::*MemberSignature)(P1,A1,A2,A3,A4) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; public: inline _TessMemberResultCallback_1_4( T* object, MemberSignature member, P1 p1) : object_(object), member_(member), p1_(p1) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { (object_->*member_)(p1_,a1,a2,a3,a4); } else { (object_->*member_)(p1_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_1_4::base* NewTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3,A4) , typename Identity::type p1) { return new _TessMemberResultCallback_1_4(obj, member, p1); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_1_4::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3,A4) , typename Identity::type p1) { return new _TessMemberResultCallback_1_4(obj, member, p1); } #endif template class _TessFunctionResultCallback_1_4 : public TessResultCallback4 { public: typedef TessResultCallback4 base; typedef R (*FunctionSignature)(P1,A1,A2,A3,A4); private: FunctionSignature function_; typename remove_reference::type p1_; public: inline _TessFunctionResultCallback_1_4(FunctionSignature function, P1 p1) : function_(function), p1_(p1) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { R result = (*function_)(p1_,a1,a2,a3,a4); return result; } else { R result = (*function_)(p1_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_1_4 : public TessCallback4 { public: typedef TessCallback4 base; typedef void (*FunctionSignature)(P1,A1,A2,A3,A4); private: FunctionSignature function_; typename remove_reference::type p1_; public: inline _TessFunctionResultCallback_1_4(FunctionSignature function, P1 p1) : function_(function), p1_(p1) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { (*function_)(p1_,a1,a2,a3,a4); } else { (*function_)(p1_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_1_4::base* NewTessCallback(R (*function)(P1,A1,A2,A3,A4), typename Identity::type p1) { return new _TessFunctionResultCallback_1_4(function, p1); } template inline typename _TessFunctionResultCallback_1_4::base* NewPermanentTessCallback(R (*function)(P1,A1,A2,A3,A4), typename Identity::type p1) { return new _TessFunctionResultCallback_1_4(function, p1); } template class _ConstTessMemberResultCallback_2_4 : public TessResultCallback4 { public: typedef TessResultCallback4 base; typedef R (T::*MemberSignature)(P1,P2,A1,A2,A3,A4) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _ConstTessMemberResultCallback_2_4(const T* object, MemberSignature member, P1 p1, P2 p2) : object_(object), member_(member), p1_(p1), p2_(p2) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4); return result; } else { R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_2_4 : public TessCallback4 { public: typedef TessCallback4 base; typedef void (T::*MemberSignature)(P1,P2,A1,A2,A3,A4) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _ConstTessMemberResultCallback_2_4(const T* object, MemberSignature member, P1 p1, P2 p2) : object_(object), member_(member), p1_(p1), p2_(p2) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { (object_->*member_)(p1_,p2_,a1,a2,a3,a4); } else { (object_->*member_)(p1_,p2_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_2_4::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4) const, typename Identity::type p1, typename Identity::type p2) { return new _ConstTessMemberResultCallback_2_4(obj, member, p1, p2); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_2_4::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4) const, typename Identity::type p1, typename Identity::type p2) { return new _ConstTessMemberResultCallback_2_4(obj, member, p1, p2); } #endif template class _TessMemberResultCallback_2_4 : public TessResultCallback4 { public: typedef TessResultCallback4 base; typedef R (T::*MemberSignature)(P1,P2,A1,A2,A3,A4) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _TessMemberResultCallback_2_4( T* object, MemberSignature member, P1 p1, P2 p2) : object_(object), member_(member), p1_(p1), p2_(p2) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4); return result; } else { R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_2_4 : public TessCallback4 { public: typedef TessCallback4 base; typedef void (T::*MemberSignature)(P1,P2,A1,A2,A3,A4) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _TessMemberResultCallback_2_4( T* object, MemberSignature member, P1 p1, P2 p2) : object_(object), member_(member), p1_(p1), p2_(p2) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { (object_->*member_)(p1_,p2_,a1,a2,a3,a4); } else { (object_->*member_)(p1_,p2_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_2_4::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4) , typename Identity::type p1, typename Identity::type p2) { return new _TessMemberResultCallback_2_4(obj, member, p1, p2); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_2_4::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4) , typename Identity::type p1, typename Identity::type p2) { return new _TessMemberResultCallback_2_4(obj, member, p1, p2); } #endif template class _TessFunctionResultCallback_2_4 : public TessResultCallback4 { public: typedef TessResultCallback4 base; typedef R (*FunctionSignature)(P1,P2,A1,A2,A3,A4); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _TessFunctionResultCallback_2_4(FunctionSignature function, P1 p1, P2 p2) : function_(function), p1_(p1), p2_(p2) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { R result = (*function_)(p1_,p2_,a1,a2,a3,a4); return result; } else { R result = (*function_)(p1_,p2_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_2_4 : public TessCallback4 { public: typedef TessCallback4 base; typedef void (*FunctionSignature)(P1,P2,A1,A2,A3,A4); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _TessFunctionResultCallback_2_4(FunctionSignature function, P1 p1, P2 p2) : function_(function), p1_(p1), p2_(p2) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { (*function_)(p1_,p2_,a1,a2,a3,a4); } else { (*function_)(p1_,p2_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_2_4::base* NewTessCallback(R (*function)(P1,P2,A1,A2,A3,A4), typename Identity::type p1, typename Identity::type p2) { return new _TessFunctionResultCallback_2_4(function, p1, p2); } template inline typename _TessFunctionResultCallback_2_4::base* NewPermanentTessCallback(R (*function)(P1,P2,A1,A2,A3,A4), typename Identity::type p1, typename Identity::type p2) { return new _TessFunctionResultCallback_2_4(function, p1, p2); } template class _ConstTessMemberResultCallback_3_4 : public TessResultCallback4 { public: typedef TessResultCallback4 base; typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _ConstTessMemberResultCallback_3_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_3_4 : public TessCallback4 { public: typedef TessCallback4 base; typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _ConstTessMemberResultCallback_3_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4); } else { (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_3_4::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3,A4) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _ConstTessMemberResultCallback_3_4(obj, member, p1, p2, p3); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_3_4::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3,A4) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _ConstTessMemberResultCallback_3_4(obj, member, p1, p2, p3); } #endif template class _TessMemberResultCallback_3_4 : public TessResultCallback4 { public: typedef TessResultCallback4 base; typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _TessMemberResultCallback_3_4( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_3_4 : public TessCallback4 { public: typedef TessCallback4 base; typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _TessMemberResultCallback_3_4( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4); } else { (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_3_4::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3,A4) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _TessMemberResultCallback_3_4(obj, member, p1, p2, p3); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_3_4::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3,A4) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _TessMemberResultCallback_3_4(obj, member, p1, p2, p3); } #endif template class _TessFunctionResultCallback_3_4 : public TessResultCallback4 { public: typedef TessResultCallback4 base; typedef R (*FunctionSignature)(P1,P2,P3,A1,A2,A3,A4); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _TessFunctionResultCallback_3_4(FunctionSignature function, P1 p1, P2 p2, P3 p3) : function_(function), p1_(p1), p2_(p2), p3_(p3) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { R result = (*function_)(p1_,p2_,p3_,a1,a2,a3,a4); return result; } else { R result = (*function_)(p1_,p2_,p3_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_3_4 : public TessCallback4 { public: typedef TessCallback4 base; typedef void (*FunctionSignature)(P1,P2,P3,A1,A2,A3,A4); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _TessFunctionResultCallback_3_4(FunctionSignature function, P1 p1, P2 p2, P3 p3) : function_(function), p1_(p1), p2_(p2), p3_(p3) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { (*function_)(p1_,p2_,p3_,a1,a2,a3,a4); } else { (*function_)(p1_,p2_,p3_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_3_4::base* NewTessCallback(R (*function)(P1,P2,P3,A1,A2,A3,A4), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _TessFunctionResultCallback_3_4(function, p1, p2, p3); } template inline typename _TessFunctionResultCallback_3_4::base* NewPermanentTessCallback(R (*function)(P1,P2,P3,A1,A2,A3,A4), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _TessFunctionResultCallback_3_4(function, p1, p2, p3); } template class _ConstTessMemberResultCallback_4_4 : public TessResultCallback4 { public: typedef TessResultCallback4 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _ConstTessMemberResultCallback_4_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_4_4 : public TessCallback4 { public: typedef TessCallback4 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _ConstTessMemberResultCallback_4_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4); } else { (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_4_4::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3,A4) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _ConstTessMemberResultCallback_4_4(obj, member, p1, p2, p3, p4); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_4_4::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3,A4) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _ConstTessMemberResultCallback_4_4(obj, member, p1, p2, p3, p4); } #endif template class _TessMemberResultCallback_4_4 : public TessResultCallback4 { public: typedef TessResultCallback4 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _TessMemberResultCallback_4_4( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_4_4 : public TessCallback4 { public: typedef TessCallback4 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _TessMemberResultCallback_4_4( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4); } else { (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_4_4::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3,A4) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _TessMemberResultCallback_4_4(obj, member, p1, p2, p3, p4); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_4_4::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3,A4) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _TessMemberResultCallback_4_4(obj, member, p1, p2, p3, p4); } #endif template class _TessFunctionResultCallback_4_4 : public TessResultCallback4 { public: typedef TessResultCallback4 base; typedef R (*FunctionSignature)(P1,P2,P3,P4,A1,A2,A3,A4); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _TessFunctionResultCallback_4_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4); return result; } else { R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_4_4 : public TessCallback4 { public: typedef TessCallback4 base; typedef void (*FunctionSignature)(P1,P2,P3,P4,A1,A2,A3,A4); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _TessFunctionResultCallback_4_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4); } else { (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_4_4::base* NewTessCallback(R (*function)(P1,P2,P3,P4,A1,A2,A3,A4), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _TessFunctionResultCallback_4_4(function, p1, p2, p3, p4); } template inline typename _TessFunctionResultCallback_4_4::base* NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,A1,A2,A3,A4), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _TessFunctionResultCallback_4_4(function, p1, p2, p3, p4); } template class _ConstTessMemberResultCallback_5_4 : public TessResultCallback4 { public: typedef TessResultCallback4 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _ConstTessMemberResultCallback_5_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_5_4 : public TessCallback4 { public: typedef TessCallback4 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _ConstTessMemberResultCallback_5_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4); } else { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_5_4::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3,A4) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _ConstTessMemberResultCallback_5_4(obj, member, p1, p2, p3, p4, p5); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_5_4::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3,A4) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _ConstTessMemberResultCallback_5_4(obj, member, p1, p2, p3, p4, p5); } #endif template class _TessMemberResultCallback_5_4 : public TessResultCallback4 { public: typedef TessResultCallback4 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _TessMemberResultCallback_5_4( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_5_4 : public TessCallback4 { public: typedef TessCallback4 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _TessMemberResultCallback_5_4( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4); } else { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_5_4::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3,A4) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _TessMemberResultCallback_5_4(obj, member, p1, p2, p3, p4, p5); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_5_4::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3,A4) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _TessMemberResultCallback_5_4(obj, member, p1, p2, p3, p4, p5); } #endif template class _TessFunctionResultCallback_5_4 : public TessResultCallback4 { public: typedef TessResultCallback4 base; typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _TessFunctionResultCallback_5_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4); return result; } else { R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_5_4 : public TessCallback4 { public: typedef TessCallback4 base; typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _TessFunctionResultCallback_5_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4); } else { (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_5_4::base* NewTessCallback(R (*function)(P1,P2,P3,P4,P5,A1,A2,A3,A4), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _TessFunctionResultCallback_5_4(function, p1, p2, p3, p4, p5); } template inline typename _TessFunctionResultCallback_5_4::base* NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,A1,A2,A3,A4), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _TessFunctionResultCallback_5_4(function, p1, p2, p3, p4, p5); } template class _ConstTessMemberResultCallback_6_4 : public TessResultCallback4 { public: typedef TessResultCallback4 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _ConstTessMemberResultCallback_6_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_6_4 : public TessCallback4 { public: typedef TessCallback4 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _ConstTessMemberResultCallback_6_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4); } else { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_6_4::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _ConstTessMemberResultCallback_6_4(obj, member, p1, p2, p3, p4, p5, p6); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_6_4::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _ConstTessMemberResultCallback_6_4(obj, member, p1, p2, p3, p4, p5, p6); } #endif template class _TessMemberResultCallback_6_4 : public TessResultCallback4 { public: typedef TessResultCallback4 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _TessMemberResultCallback_6_4( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_6_4 : public TessCallback4 { public: typedef TessCallback4 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _TessMemberResultCallback_6_4( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4); } else { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_6_4::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _TessMemberResultCallback_6_4(obj, member, p1, p2, p3, p4, p5, p6); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_6_4::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _TessMemberResultCallback_6_4(obj, member, p1, p2, p3, p4, p5, p6); } #endif template class _TessFunctionResultCallback_6_4 : public TessResultCallback4 { public: typedef TessResultCallback4 base; typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _TessFunctionResultCallback_6_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4); return result; } else { R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_6_4 : public TessCallback4 { public: typedef TessCallback4 base; typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _TessFunctionResultCallback_6_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) { if (!del) { (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4); } else { (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_6_4::base* NewTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _TessFunctionResultCallback_6_4(function, p1, p2, p3, p4, p5, p6); } template inline typename _TessFunctionResultCallback_6_4::base* NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _TessFunctionResultCallback_6_4(function, p1, p2, p3, p4, p5, p6); } template class TessCallback5 { public: virtual ~TessCallback5() { } virtual void Run(A1,A2,A3,A4,A5) = 0; }; template class TessResultCallback5 { public: virtual ~TessResultCallback5() { } virtual R Run(A1,A2,A3,A4,A5) = 0; }; template class _ConstTessMemberResultCallback_0_5 : public TessResultCallback5 { public: typedef TessResultCallback5 base; typedef R (T::*MemberSignature)(A1,A2,A3,A4,A5) const; private: const T* object_; MemberSignature member_; public: inline _ConstTessMemberResultCallback_0_5(const T* object, MemberSignature member) : object_(object), member_(member) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { R result = (object_->*member_)(a1,a2,a3,a4,a5); return result; } else { R result = (object_->*member_)(a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_0_5 : public TessCallback5 { public: typedef TessCallback5 base; typedef void (T::*MemberSignature)(A1,A2,A3,A4,A5) const; private: const T* object_; MemberSignature member_; public: inline _ConstTessMemberResultCallback_0_5(const T* object, MemberSignature member) : object_(object), member_(member) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { (object_->*member_)(a1,a2,a3,a4,a5); } else { (object_->*member_)(a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_0_5::base* NewTessCallback(const T1* obj, R (T2::*member)(A1,A2,A3,A4,A5) const) { return new _ConstTessMemberResultCallback_0_5(obj, member); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_0_5::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(A1,A2,A3,A4,A5) const) { return new _ConstTessMemberResultCallback_0_5(obj, member); } #endif template class _TessMemberResultCallback_0_5 : public TessResultCallback5 { public: typedef TessResultCallback5 base; typedef R (T::*MemberSignature)(A1,A2,A3,A4,A5) ; private: T* object_; MemberSignature member_; public: inline _TessMemberResultCallback_0_5( T* object, MemberSignature member) : object_(object), member_(member) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { R result = (object_->*member_)(a1,a2,a3,a4,a5); return result; } else { R result = (object_->*member_)(a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_0_5 : public TessCallback5 { public: typedef TessCallback5 base; typedef void (T::*MemberSignature)(A1,A2,A3,A4,A5) ; private: T* object_; MemberSignature member_; public: inline _TessMemberResultCallback_0_5( T* object, MemberSignature member) : object_(object), member_(member) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { (object_->*member_)(a1,a2,a3,a4,a5); } else { (object_->*member_)(a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_0_5::base* NewTessCallback( T1* obj, R (T2::*member)(A1,A2,A3,A4,A5) ) { return new _TessMemberResultCallback_0_5(obj, member); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_0_5::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(A1,A2,A3,A4,A5) ) { return new _TessMemberResultCallback_0_5(obj, member); } #endif template class _TessFunctionResultCallback_0_5 : public TessResultCallback5 { public: typedef TessResultCallback5 base; typedef R (*FunctionSignature)(A1,A2,A3,A4,A5); private: FunctionSignature function_; public: inline _TessFunctionResultCallback_0_5(FunctionSignature function) : function_(function) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { R result = (*function_)(a1,a2,a3,a4,a5); return result; } else { R result = (*function_)(a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_0_5 : public TessCallback5 { public: typedef TessCallback5 base; typedef void (*FunctionSignature)(A1,A2,A3,A4,A5); private: FunctionSignature function_; public: inline _TessFunctionResultCallback_0_5(FunctionSignature function) : function_(function) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { (*function_)(a1,a2,a3,a4,a5); } else { (*function_)(a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_0_5::base* NewTessCallback(R (*function)(A1,A2,A3,A4,A5)) { return new _TessFunctionResultCallback_0_5(function); } template inline typename _TessFunctionResultCallback_0_5::base* NewPermanentTessCallback(R (*function)(A1,A2,A3,A4,A5)) { return new _TessFunctionResultCallback_0_5(function); } template class _ConstTessMemberResultCallback_1_5 : public TessResultCallback5 { public: typedef TessResultCallback5 base; typedef R (T::*MemberSignature)(P1,A1,A2,A3,A4,A5) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; public: inline _ConstTessMemberResultCallback_1_5(const T* object, MemberSignature member, P1 p1) : object_(object), member_(member), p1_(p1) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { R result = (object_->*member_)(p1_,a1,a2,a3,a4,a5); return result; } else { R result = (object_->*member_)(p1_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_1_5 : public TessCallback5 { public: typedef TessCallback5 base; typedef void (T::*MemberSignature)(P1,A1,A2,A3,A4,A5) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; public: inline _ConstTessMemberResultCallback_1_5(const T* object, MemberSignature member, P1 p1) : object_(object), member_(member), p1_(p1) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { (object_->*member_)(p1_,a1,a2,a3,a4,a5); } else { (object_->*member_)(p1_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_1_5::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,A1,A2,A3,A4,A5) const, typename Identity::type p1) { return new _ConstTessMemberResultCallback_1_5(obj, member, p1); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_1_5::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,A1,A2,A3,A4,A5) const, typename Identity::type p1) { return new _ConstTessMemberResultCallback_1_5(obj, member, p1); } #endif template class _TessMemberResultCallback_1_5 : public TessResultCallback5 { public: typedef TessResultCallback5 base; typedef R (T::*MemberSignature)(P1,A1,A2,A3,A4,A5) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; public: inline _TessMemberResultCallback_1_5( T* object, MemberSignature member, P1 p1) : object_(object), member_(member), p1_(p1) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { R result = (object_->*member_)(p1_,a1,a2,a3,a4,a5); return result; } else { R result = (object_->*member_)(p1_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_1_5 : public TessCallback5 { public: typedef TessCallback5 base; typedef void (T::*MemberSignature)(P1,A1,A2,A3,A4,A5) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; public: inline _TessMemberResultCallback_1_5( T* object, MemberSignature member, P1 p1) : object_(object), member_(member), p1_(p1) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { (object_->*member_)(p1_,a1,a2,a3,a4,a5); } else { (object_->*member_)(p1_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_1_5::base* NewTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3,A4,A5) , typename Identity::type p1) { return new _TessMemberResultCallback_1_5(obj, member, p1); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_1_5::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3,A4,A5) , typename Identity::type p1) { return new _TessMemberResultCallback_1_5(obj, member, p1); } #endif template class _TessFunctionResultCallback_1_5 : public TessResultCallback5 { public: typedef TessResultCallback5 base; typedef R (*FunctionSignature)(P1,A1,A2,A3,A4,A5); private: FunctionSignature function_; typename remove_reference::type p1_; public: inline _TessFunctionResultCallback_1_5(FunctionSignature function, P1 p1) : function_(function), p1_(p1) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { R result = (*function_)(p1_,a1,a2,a3,a4,a5); return result; } else { R result = (*function_)(p1_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_1_5 : public TessCallback5 { public: typedef TessCallback5 base; typedef void (*FunctionSignature)(P1,A1,A2,A3,A4,A5); private: FunctionSignature function_; typename remove_reference::type p1_; public: inline _TessFunctionResultCallback_1_5(FunctionSignature function, P1 p1) : function_(function), p1_(p1) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { (*function_)(p1_,a1,a2,a3,a4,a5); } else { (*function_)(p1_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_1_5::base* NewTessCallback(R (*function)(P1,A1,A2,A3,A4,A5), typename Identity::type p1) { return new _TessFunctionResultCallback_1_5(function, p1); } template inline typename _TessFunctionResultCallback_1_5::base* NewPermanentTessCallback(R (*function)(P1,A1,A2,A3,A4,A5), typename Identity::type p1) { return new _TessFunctionResultCallback_1_5(function, p1); } template class _ConstTessMemberResultCallback_2_5 : public TessResultCallback5 { public: typedef TessResultCallback5 base; typedef R (T::*MemberSignature)(P1,P2,A1,A2,A3,A4,A5) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _ConstTessMemberResultCallback_2_5(const T* object, MemberSignature member, P1 p1, P2 p2) : object_(object), member_(member), p1_(p1), p2_(p2) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5); return result; } else { R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_2_5 : public TessCallback5 { public: typedef TessCallback5 base; typedef void (T::*MemberSignature)(P1,P2,A1,A2,A3,A4,A5) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _ConstTessMemberResultCallback_2_5(const T* object, MemberSignature member, P1 p1, P2 p2) : object_(object), member_(member), p1_(p1), p2_(p2) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5); } else { (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_2_5::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4,A5) const, typename Identity::type p1, typename Identity::type p2) { return new _ConstTessMemberResultCallback_2_5(obj, member, p1, p2); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_2_5::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4,A5) const, typename Identity::type p1, typename Identity::type p2) { return new _ConstTessMemberResultCallback_2_5(obj, member, p1, p2); } #endif template class _TessMemberResultCallback_2_5 : public TessResultCallback5 { public: typedef TessResultCallback5 base; typedef R (T::*MemberSignature)(P1,P2,A1,A2,A3,A4,A5) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _TessMemberResultCallback_2_5( T* object, MemberSignature member, P1 p1, P2 p2) : object_(object), member_(member), p1_(p1), p2_(p2) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5); return result; } else { R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_2_5 : public TessCallback5 { public: typedef TessCallback5 base; typedef void (T::*MemberSignature)(P1,P2,A1,A2,A3,A4,A5) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _TessMemberResultCallback_2_5( T* object, MemberSignature member, P1 p1, P2 p2) : object_(object), member_(member), p1_(p1), p2_(p2) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5); } else { (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_2_5::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4,A5) , typename Identity::type p1, typename Identity::type p2) { return new _TessMemberResultCallback_2_5(obj, member, p1, p2); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_2_5::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4,A5) , typename Identity::type p1, typename Identity::type p2) { return new _TessMemberResultCallback_2_5(obj, member, p1, p2); } #endif template class _TessFunctionResultCallback_2_5 : public TessResultCallback5 { public: typedef TessResultCallback5 base; typedef R (*FunctionSignature)(P1,P2,A1,A2,A3,A4,A5); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _TessFunctionResultCallback_2_5(FunctionSignature function, P1 p1, P2 p2) : function_(function), p1_(p1), p2_(p2) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { R result = (*function_)(p1_,p2_,a1,a2,a3,a4,a5); return result; } else { R result = (*function_)(p1_,p2_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_2_5 : public TessCallback5 { public: typedef TessCallback5 base; typedef void (*FunctionSignature)(P1,P2,A1,A2,A3,A4,A5); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; public: inline _TessFunctionResultCallback_2_5(FunctionSignature function, P1 p1, P2 p2) : function_(function), p1_(p1), p2_(p2) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { (*function_)(p1_,p2_,a1,a2,a3,a4,a5); } else { (*function_)(p1_,p2_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_2_5::base* NewTessCallback(R (*function)(P1,P2,A1,A2,A3,A4,A5), typename Identity::type p1, typename Identity::type p2) { return new _TessFunctionResultCallback_2_5(function, p1, p2); } template inline typename _TessFunctionResultCallback_2_5::base* NewPermanentTessCallback(R (*function)(P1,P2,A1,A2,A3,A4,A5), typename Identity::type p1, typename Identity::type p2) { return new _TessFunctionResultCallback_2_5(function, p1, p2); } template class _ConstTessMemberResultCallback_3_5 : public TessResultCallback5 { public: typedef TessResultCallback5 base; typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4,A5) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _ConstTessMemberResultCallback_3_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_3_5 : public TessCallback5 { public: typedef TessCallback5 base; typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4,A5) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _ConstTessMemberResultCallback_3_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5); } else { (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_3_5::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3,A4,A5) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _ConstTessMemberResultCallback_3_5(obj, member, p1, p2, p3); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_3_5::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3,A4,A5) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _ConstTessMemberResultCallback_3_5(obj, member, p1, p2, p3); } #endif template class _TessMemberResultCallback_3_5 : public TessResultCallback5 { public: typedef TessResultCallback5 base; typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4,A5) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _TessMemberResultCallback_3_5( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_3_5 : public TessCallback5 { public: typedef TessCallback5 base; typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4,A5) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _TessMemberResultCallback_3_5( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5); } else { (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_3_5::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3,A4,A5) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _TessMemberResultCallback_3_5(obj, member, p1, p2, p3); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_3_5::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3,A4,A5) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _TessMemberResultCallback_3_5(obj, member, p1, p2, p3); } #endif template class _TessFunctionResultCallback_3_5 : public TessResultCallback5 { public: typedef TessResultCallback5 base; typedef R (*FunctionSignature)(P1,P2,P3,A1,A2,A3,A4,A5); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _TessFunctionResultCallback_3_5(FunctionSignature function, P1 p1, P2 p2, P3 p3) : function_(function), p1_(p1), p2_(p2), p3_(p3) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { R result = (*function_)(p1_,p2_,p3_,a1,a2,a3,a4,a5); return result; } else { R result = (*function_)(p1_,p2_,p3_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_3_5 : public TessCallback5 { public: typedef TessCallback5 base; typedef void (*FunctionSignature)(P1,P2,P3,A1,A2,A3,A4,A5); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; public: inline _TessFunctionResultCallback_3_5(FunctionSignature function, P1 p1, P2 p2, P3 p3) : function_(function), p1_(p1), p2_(p2), p3_(p3) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { (*function_)(p1_,p2_,p3_,a1,a2,a3,a4,a5); } else { (*function_)(p1_,p2_,p3_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_3_5::base* NewTessCallback(R (*function)(P1,P2,P3,A1,A2,A3,A4,A5), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _TessFunctionResultCallback_3_5(function, p1, p2, p3); } template inline typename _TessFunctionResultCallback_3_5::base* NewPermanentTessCallback(R (*function)(P1,P2,P3,A1,A2,A3,A4,A5), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) { return new _TessFunctionResultCallback_3_5(function, p1, p2, p3); } template class _ConstTessMemberResultCallback_4_5 : public TessResultCallback5 { public: typedef TessResultCallback5 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4,A5) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _ConstTessMemberResultCallback_4_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_4_5 : public TessCallback5 { public: typedef TessCallback5 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4,A5) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _ConstTessMemberResultCallback_4_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5); } else { (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_4_5::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3,A4,A5) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _ConstTessMemberResultCallback_4_5(obj, member, p1, p2, p3, p4); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_4_5::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3,A4,A5) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _ConstTessMemberResultCallback_4_5(obj, member, p1, p2, p3, p4); } #endif template class _TessMemberResultCallback_4_5 : public TessResultCallback5 { public: typedef TessResultCallback5 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4,A5) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _TessMemberResultCallback_4_5( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_4_5 : public TessCallback5 { public: typedef TessCallback5 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4,A5) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _TessMemberResultCallback_4_5( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5); } else { (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_4_5::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3,A4,A5) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _TessMemberResultCallback_4_5(obj, member, p1, p2, p3, p4); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_4_5::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3,A4,A5) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _TessMemberResultCallback_4_5(obj, member, p1, p2, p3, p4); } #endif template class _TessFunctionResultCallback_4_5 : public TessResultCallback5 { public: typedef TessResultCallback5 base; typedef R (*FunctionSignature)(P1,P2,P3,P4,A1,A2,A3,A4,A5); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _TessFunctionResultCallback_4_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5); return result; } else { R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_4_5 : public TessCallback5 { public: typedef TessCallback5 base; typedef void (*FunctionSignature)(P1,P2,P3,P4,A1,A2,A3,A4,A5); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; public: inline _TessFunctionResultCallback_4_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5); } else { (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_4_5::base* NewTessCallback(R (*function)(P1,P2,P3,P4,A1,A2,A3,A4,A5), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _TessFunctionResultCallback_4_5(function, p1, p2, p3, p4); } template inline typename _TessFunctionResultCallback_4_5::base* NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,A1,A2,A3,A4,A5), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) { return new _TessFunctionResultCallback_4_5(function, p1, p2, p3, p4); } template class _ConstTessMemberResultCallback_5_5 : public TessResultCallback5 { public: typedef TessResultCallback5 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _ConstTessMemberResultCallback_5_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_5_5 : public TessCallback5 { public: typedef TessCallback5 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _ConstTessMemberResultCallback_5_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5); } else { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_5_5::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _ConstTessMemberResultCallback_5_5(obj, member, p1, p2, p3, p4, p5); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_5_5::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _ConstTessMemberResultCallback_5_5(obj, member, p1, p2, p3, p4, p5); } #endif template class _TessMemberResultCallback_5_5 : public TessResultCallback5 { public: typedef TessResultCallback5 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _TessMemberResultCallback_5_5( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_5_5 : public TessCallback5 { public: typedef TessCallback5 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _TessMemberResultCallback_5_5( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5); } else { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_5_5::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _TessMemberResultCallback_5_5(obj, member, p1, p2, p3, p4, p5); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_5_5::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _TessMemberResultCallback_5_5(obj, member, p1, p2, p3, p4, p5); } #endif template class _TessFunctionResultCallback_5_5 : public TessResultCallback5 { public: typedef TessResultCallback5 base; typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _TessFunctionResultCallback_5_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5); return result; } else { R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_5_5 : public TessCallback5 { public: typedef TessCallback5 base; typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; public: inline _TessFunctionResultCallback_5_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5); } else { (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_5_5::base* NewTessCallback(R (*function)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _TessFunctionResultCallback_5_5(function, p1, p2, p3, p4, p5); } template inline typename _TessFunctionResultCallback_5_5::base* NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) { return new _TessFunctionResultCallback_5_5(function, p1, p2, p3, p4, p5); } template class _ConstTessMemberResultCallback_6_5 : public TessResultCallback5 { public: typedef TessResultCallback5 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _ConstTessMemberResultCallback_6_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _ConstTessMemberResultCallback_6_5 : public TessCallback5 { public: typedef TessCallback5 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) const; private: const T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _ConstTessMemberResultCallback_6_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5); } else { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _ConstTessMemberResultCallback_6_5::base* NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _ConstTessMemberResultCallback_6_5(obj, member, p1, p2, p3, p4, p5, p6); } #endif #ifndef SWIG template inline typename _ConstTessMemberResultCallback_6_5::base* NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _ConstTessMemberResultCallback_6_5(obj, member, p1, p2, p3, p4, p5, p6); } #endif template class _TessMemberResultCallback_6_5 : public TessResultCallback5 { public: typedef TessResultCallback5 base; typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _TessMemberResultCallback_6_5( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5); return result; } else { R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; return result; } } }; template class _TessMemberResultCallback_6_5 : public TessCallback5 { public: typedef TessCallback5 base; typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) ; private: T* object_; MemberSignature member_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _TessMemberResultCallback_6_5( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : object_(object), member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5); } else { (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again member_ = NULL; delete this; } } }; #ifndef SWIG template inline typename _TessMemberResultCallback_6_5::base* NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _TessMemberResultCallback_6_5(obj, member, p1, p2, p3, p4, p5, p6); } #endif #ifndef SWIG template inline typename _TessMemberResultCallback_6_5::base* NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _TessMemberResultCallback_6_5(obj, member, p1, p2, p3, p4, p5, p6); } #endif template class _TessFunctionResultCallback_6_5 : public TessResultCallback5 { public: typedef TessResultCallback5 base; typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _TessFunctionResultCallback_6_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5); return result; } else { R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; return result; } } }; template class _TessFunctionResultCallback_6_5 : public TessCallback5 { public: typedef TessCallback5 base; typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5); private: FunctionSignature function_; typename remove_reference::type p1_; typename remove_reference::type p2_; typename remove_reference::type p3_; typename remove_reference::type p4_; typename remove_reference::type p5_; typename remove_reference::type p6_; public: inline _TessFunctionResultCallback_6_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { } virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) { if (!del) { (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5); } else { (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5); // zero out the pointer to ensure segfault if used again function_ = NULL; delete this; } } }; template inline typename _TessFunctionResultCallback_6_5::base* NewTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _TessFunctionResultCallback_6_5(function, p1, p2, p3, p4, p5, p6); } template inline typename _TessFunctionResultCallback_6_5::base* NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) { return new _TessFunctionResultCallback_6_5(function, p1, p2, p3, p4, p5, p6); } #endif // TESS_CALLBACK_SPECIALIZATIONS_H_