dvander@541: // FastDelegate.h dvander@541: // Efficient delegates in C++ that generate only two lines of asm code! dvander@541: // Documentation is found at http://www.codeproject.com/cpp/FastDelegate.asp dvander@541: // dvander@541: // - Don Clugston, Mar 2004. dvander@541: // Major contributions were made by Jody Hagins. dvander@541: // History: dvander@541: // 24-Apr-04 1.0 * Submitted to CodeProject. dvander@541: // 28-Apr-04 1.1 * Prevent most unsafe uses of evil static function hack. dvander@541: // * Improved syntax for horrible_cast (thanks Paul Bludov). dvander@541: // * Tested on Metrowerks MWCC and Intel ICL (IA32) dvander@541: // * Compiled, but not run, on Comeau C++ and Intel Itanium ICL. dvander@541: // 27-Jun-04 1.2 * Now works on Borland C++ Builder 5.5 dvander@541: // * Now works on /clr "managed C++" code on VC7, VC7.1 dvander@541: // * Comeau C++ now compiles without warnings. dvander@541: // * Prevent the virtual inheritance case from being used on dvander@541: // VC6 and earlier, which generate incorrect code. dvander@541: // * Improved warning and error messages. Non-standard hacks dvander@541: // now have compile-time checks to make them safer. dvander@541: // * implicit_cast used instead of static_cast in many cases. dvander@541: // * If calling a const member function, a const class pointer can be used. dvander@541: // * MakeDelegate() global helper function added to simplify pass-by-value. dvander@541: // * Added fastdelegate.clear() dvander@541: // 16-Jul-04 1.2.1* Workaround for gcc bug (const member function pointers in templates) dvander@541: // 30-Oct-04 1.3 * Support for (non-void) return values. dvander@541: // * No more workarounds in client code! dvander@541: // MSVC and Intel now use a clever hack invented by John Dlugosz: dvander@541: // - The FASTDELEGATEDECLARE workaround is no longer necessary. dvander@541: // - No more warning messages for VC6 dvander@541: // * Less use of macros. Error messages should be more comprehensible. dvander@541: // * Added include guards dvander@541: // * Added FastDelegate::empty() to test if invocation is safe (Thanks Neville Franks). dvander@541: // * Now tested on VS 2005 Express Beta, PGI C++ dvander@541: // 24-Dec-04 1.4 * Added DelegateMemento, to allow collections of disparate delegates. dvander@541: // * <,>,<=,>= comparison operators to allow storage in ordered containers. dvander@541: // * Substantial reduction of code size, especially the 'Closure' class. dvander@541: // * Standardised all the compiler-specific workarounds. dvander@541: // * MFP conversion now works for CodePlay (but not yet supported in the full code). dvander@541: // * Now compiles without warnings on _any_ supported compiler, including BCC 5.5.1 dvander@541: // * New syntax: FastDelegate< int (char *, double) >. dvander@541: // 14-Feb-05 1.4.1* Now treats =0 as equivalent to .clear(), ==0 as equivalent to .empty(). (Thanks elfric). dvander@541: // * Now tested on Intel ICL for AMD64, VS2005 Beta for AMD64 and Itanium. dvander@541: // 30-Mar-05 1.5 * Safebool idiom: "if (dg)" is now equivalent to "if (!dg.empty())" dvander@541: // * Fully supported by CodePlay VectorC dvander@541: // * Bugfix for Metrowerks: empty() was buggy because a valid MFP can be 0 on MWCC! dvander@541: // * More optimal assignment,== and != operators for static function pointers. dvander@541: dvander@541: #ifndef FASTDELEGATE_H dvander@541: #define FASTDELEGATE_H dvander@541: dvander@541: #ifdef _MSC_VER dvander@541: # if _MSC_VER > 1000 dvander@541: # pragma once dvander@541: # endif // _MSC_VER > 1000 dvander@541: #endif // #ifdef _MSC_VER dvander@541: dvander@541: #include // to allow <,> comparisons dvander@541: dvander@541: //////////////////////////////////////////////////////////////////////////////// dvander@541: // Configuration options dvander@541: // dvander@541: //////////////////////////////////////////////////////////////////////////////// dvander@541: dvander@541: // Uncomment the following #define for optimally-sized delegates. dvander@541: // In this case, the generated asm code is almost identical to the code you'd get dvander@541: // if the compiler had native support for delegates. dvander@541: // It will not work on systems where sizeof(dataptr) < sizeof(codeptr). dvander@541: // Thus, it will not work for DOS compilers using the medium model. dvander@541: // It will also probably fail on some DSP systems. dvander@541: #define FASTDELEGATE_USESTATICFUNCTIONHACK dvander@541: dvander@541: // Uncomment the next line to allow function declarator syntax. dvander@541: // It is automatically enabled for those compilers where it is known to work. dvander@541: //#define FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX dvander@541: dvander@541: //////////////////////////////////////////////////////////////////////////////// dvander@541: // Compiler identification for workarounds dvander@541: // dvander@541: //////////////////////////////////////////////////////////////////////////////// dvander@541: dvander@541: // Compiler identification. It's not easy to identify Visual C++ because dvander@541: // many vendors fraudulently define Microsoft's identifiers. dvander@541: #if defined(_MSC_VER) && !defined(__MWERKS__) && !defined(__VECTOR_C) && !defined(__ICL) && !defined(__BORLANDC__) dvander@541: #define FASTDLGT_ISMSVC dvander@541: dvander@541: #if (_MSC_VER <1300) // Many workarounds are required for VC6. dvander@541: #define FASTDLGT_VC6 dvander@541: #pragma warning(disable:4786) // disable this ridiculous warning dvander@541: #endif dvander@541: dvander@541: #endif dvander@541: dvander@541: // Does the compiler uses Microsoft's member function pointer structure? dvander@541: // If so, it needs special treatment. dvander@541: // Metrowerks CodeWarrior, Intel, and CodePlay fraudulently define Microsoft's dvander@541: // identifier, _MSC_VER. We need to filter Metrowerks out. dvander@541: #if defined(_MSC_VER) && !defined(__MWERKS__) dvander@541: #define FASTDLGT_MICROSOFT_MFP dvander@541: dvander@541: #if !defined(__VECTOR_C) dvander@541: // CodePlay doesn't have the __single/multi/virtual_inheritance keywords dvander@541: #define FASTDLGT_HASINHERITANCE_KEYWORDS dvander@541: #endif dvander@541: #endif dvander@541: dvander@541: // Does it allow function declarator syntax? The following compilers are known to work: dvander@541: #if defined(FASTDLGT_ISMSVC) && (_MSC_VER >=1310) // VC 7.1 dvander@541: #define FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX dvander@541: #endif dvander@541: dvander@541: // Gcc(2.95+), and versions of Digital Mars, Intel and Comeau in common use. dvander@541: #if defined (__DMC__) || defined(__GNUC__) || defined(__ICL) || defined(__COMO__) dvander@541: #define FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX dvander@541: #endif dvander@541: dvander@541: // It works on Metrowerks MWCC 3.2.2. From boost.Config it should work on earlier ones too. dvander@541: #if defined (__MWERKS__) dvander@541: #define FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX dvander@541: #endif dvander@541: dvander@541: #ifdef __GNUC__ // Workaround GCC bug #8271 dvander@541: // At present, GCC doesn't recognize constness of MFPs in templates dvander@541: #define FASTDELEGATE_GCC_BUG_8271 dvander@541: #endif dvander@541: dvander@541: dvander@541: dvander@541: //////////////////////////////////////////////////////////////////////////////// dvander@541: // General tricks used in this code dvander@541: // dvander@541: // (a) Error messages are generated by typdefing an array of negative size to dvander@541: // generate compile-time errors. dvander@541: // (b) Warning messages on MSVC are generated by declaring unused variables, and dvander@541: // enabling the "variable XXX is never used" warning. dvander@541: // (c) Unions are used in a few compiler-specific cases to perform illegal casts. dvander@541: // (d) For Microsoft and Intel, when adjusting the 'this' pointer, it's cast to dvander@541: // (char *) first to ensure that the correct number of *bytes* are added. dvander@541: // dvander@541: //////////////////////////////////////////////////////////////////////////////// dvander@541: // Helper templates dvander@541: // dvander@541: //////////////////////////////////////////////////////////////////////////////// dvander@541: dvander@541: dvander@541: namespace fastdelegate { dvander@541: namespace detail { // we'll hide the implementation details in a nested namespace. dvander@541: dvander@541: // implicit_cast< > dvander@541: // I believe this was originally going to be in the C++ standard but dvander@541: // was left out by accident. It's even milder than static_cast. dvander@541: // I use it instead of static_cast<> to emphasize that I'm not doing dvander@541: // anything nasty. dvander@541: // Usage is identical to static_cast<> dvander@541: template dvander@541: inline OutputClass implicit_cast(InputClass input){ dvander@541: return input; dvander@541: } dvander@541: dvander@541: // horrible_cast< > dvander@541: // This is truly evil. It completely subverts C++'s type system, allowing you dvander@541: // to cast from any class to any other class. Technically, using a union dvander@541: // to perform the cast is undefined behaviour (even in C). But we can see if dvander@541: // it is OK by checking that the union is the same size as each of its members. dvander@541: // horrible_cast<> should only be used for compiler-specific workarounds. dvander@541: // Usage is identical to reinterpret_cast<>. dvander@541: dvander@541: // This union is declared outside the horrible_cast because BCC 5.5.1 dvander@541: // can't inline a function with a nested class, and gives a warning. dvander@541: template dvander@541: union horrible_union{ dvander@541: OutputClass out; dvander@541: InputClass in; dvander@541: }; dvander@541: dvander@541: template dvander@541: inline OutputClass horrible_cast(const InputClass input){ dvander@541: horrible_union u; dvander@541: // Cause a compile-time error if in, out and u are not the same size. dvander@541: // If the compile fails here, it means the compiler has peculiar dvander@541: // unions which would prevent the cast from working. dvander@541: typedef int ERROR_CantUseHorrible_cast[sizeof(InputClass)==sizeof(u) dvander@541: && sizeof(InputClass)==sizeof(OutputClass) ? 1 : -1]; dvander@541: u.in = input; dvander@541: return u.out; dvander@541: } dvander@541: dvander@541: //////////////////////////////////////////////////////////////////////////////// dvander@541: // Workarounds dvander@541: // dvander@541: //////////////////////////////////////////////////////////////////////////////// dvander@541: dvander@541: // Backwards compatibility: This macro used to be necessary in the virtual inheritance dvander@541: // case for Intel and Microsoft. Now it just forward-declares the class. dvander@541: #define FASTDELEGATEDECLARE(CLASSNAME) class CLASSNAME; dvander@541: dvander@541: // Prevent use of the static function hack with the DOS medium model. dvander@541: #ifdef __MEDIUM__ dvander@541: #undef FASTDELEGATE_USESTATICFUNCTIONHACK dvander@541: #endif dvander@541: dvander@541: // DefaultVoid - a workaround for 'void' templates in VC6. dvander@541: // dvander@541: // (1) VC6 and earlier do not allow 'void' as a default template argument. dvander@541: // (2) They also doesn't allow you to return 'void' from a function. dvander@541: // dvander@541: // Workaround for (1): Declare a dummy type 'DefaultVoid' which we use dvander@541: // when we'd like to use 'void'. We convert it into 'void' and back dvander@541: // using the templates DefaultVoidToVoid<> and VoidToDefaultVoid<>. dvander@541: // Workaround for (2): On VC6, the code for calling a void function is dvander@541: // identical to the code for calling a non-void function in which the dvander@541: // return value is never used, provided the return value is returned dvander@541: // in the EAX register, rather than on the stack. dvander@541: // This is true for most fundamental types such as int, enum, void *. dvander@541: // Const void * is the safest option since it doesn't participate dvander@541: // in any automatic conversions. But on a 16-bit compiler it might dvander@541: // cause extra code to be generated, so we disable it for all compilers dvander@541: // except for VC6 (and VC5). dvander@541: #ifdef FASTDLGT_VC6 dvander@541: // VC6 workaround dvander@541: typedef const void * DefaultVoid; dvander@541: #else dvander@541: // On any other compiler, just use a normal void. dvander@541: typedef void DefaultVoid; dvander@541: #endif dvander@541: dvander@541: // Translate from 'DefaultVoid' to 'void'. dvander@541: // Everything else is unchanged dvander@541: template dvander@541: struct DefaultVoidToVoid { typedef T type; }; dvander@541: dvander@541: template <> dvander@541: struct DefaultVoidToVoid { typedef void type; }; dvander@541: dvander@541: // Translate from 'void' into 'DefaultVoid' dvander@541: // Everything else is unchanged dvander@541: template dvander@541: struct VoidToDefaultVoid { typedef T type; }; dvander@541: dvander@541: template <> dvander@541: struct VoidToDefaultVoid { typedef DefaultVoid type; }; dvander@541: dvander@541: dvander@541: dvander@541: //////////////////////////////////////////////////////////////////////////////// dvander@541: // Fast Delegates, part 1: dvander@541: // dvander@541: // Conversion of member function pointer to a standard form dvander@541: // dvander@541: //////////////////////////////////////////////////////////////////////////////// dvander@541: dvander@541: // GenericClass is a fake class, ONLY used to provide a type. dvander@541: // It is vitally important that it is never defined, so that the compiler doesn't dvander@541: // think it can optimize the invocation. For example, Borland generates simpler dvander@541: // code if it knows the class only uses single inheritance. dvander@541: dvander@541: // Compilers using Microsoft's structure need to be treated as a special case. dvander@541: #ifdef FASTDLGT_MICROSOFT_MFP dvander@541: dvander@541: #ifdef FASTDLGT_HASINHERITANCE_KEYWORDS dvander@541: // For Microsoft and Intel, we want to ensure that it's the most efficient type of MFP dvander@541: // (4 bytes), even when the /vmg option is used. Declaring an empty class dvander@541: // would give 16 byte pointers in this case.... dvander@541: class __single_inheritance GenericClass; dvander@541: #endif dvander@541: // ...but for Codeplay, an empty class *always* gives 4 byte pointers. dvander@541: // If compiled with the /clr option ("managed C++"), the JIT compiler thinks dvander@541: // it needs to load GenericClass before it can call any of its functions, dvander@541: // (compiles OK but crashes at runtime!), so we need to declare an dvander@541: // empty class to make it happy. dvander@541: // Codeplay and VC4 can't cope with the unknown_inheritance case either. dvander@541: class GenericClass {}; dvander@541: #else dvander@541: class GenericClass; dvander@541: #endif dvander@541: dvander@541: // The size of a single inheritance member function pointer. dvander@541: const int SINGLE_MEMFUNCPTR_SIZE = sizeof(void (GenericClass::*)()); dvander@541: dvander@541: // SimplifyMemFunc< >::Convert() dvander@541: // dvander@541: // A template function that converts an arbitrary member function pointer into the dvander@541: // simplest possible form of member function pointer, using a supplied 'this' pointer. dvander@541: // According to the standard, this can be done legally with reinterpret_cast<>. dvander@541: // For (non-standard) compilers which use member function pointers which vary in size dvander@541: // depending on the class, we need to use knowledge of the internal structure of a dvander@541: // member function pointer, as used by the compiler. Template specialization is used dvander@541: // to distinguish between the sizes. Because some compilers don't support partial dvander@541: // template specialisation, I use full specialisation of a wrapper struct. dvander@541: dvander@541: // general case -- don't know how to convert it. Force a compile failure dvander@541: template dvander@541: struct SimplifyMemFunc { dvander@541: template dvander@541: inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind, dvander@541: GenericMemFuncType &bound_func) { dvander@541: // Unsupported member function type -- force a compile failure. dvander@541: // (it's illegal to have a array with negative size). dvander@541: typedef char ERROR_Unsupported_member_function_pointer_on_this_compiler[N-100]; dvander@541: return 0; dvander@541: } dvander@541: }; dvander@541: dvander@541: // For compilers where all member func ptrs are the same size, everything goes here. dvander@541: // For non-standard compilers, only single_inheritance classes go here. dvander@541: template <> dvander@541: struct SimplifyMemFunc { dvander@541: template dvander@541: inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind, dvander@541: GenericMemFuncType &bound_func) { dvander@541: #if defined __DMC__ dvander@541: // Digital Mars doesn't allow you to cast between abitrary PMF's, dvander@541: // even though the standard says you can. The 32-bit compiler lets you dvander@541: // static_cast through an int, but the DOS compiler doesn't. dvander@541: bound_func = horrible_cast(function_to_bind); dvander@541: #else dvander@541: bound_func = reinterpret_cast(function_to_bind); dvander@541: #endif dvander@541: return reinterpret_cast(pthis); dvander@541: } dvander@541: }; dvander@541: dvander@541: //////////////////////////////////////////////////////////////////////////////// dvander@541: // Fast Delegates, part 1b: dvander@541: // dvander@541: // Workarounds for Microsoft and Intel dvander@541: // dvander@541: //////////////////////////////////////////////////////////////////////////////// dvander@541: dvander@541: dvander@541: // Compilers with member function pointers which violate the standard (MSVC, Intel, Codeplay), dvander@541: // need to be treated as a special case. dvander@541: #ifdef FASTDLGT_MICROSOFT_MFP dvander@541: dvander@541: // We use unions to perform horrible_casts. I would like to use #pragma pack(push, 1) dvander@541: // at the start of each function for extra safety, but VC6 seems to ICE dvander@541: // intermittently if you do this inside a template. dvander@541: dvander@541: // __multiple_inheritance classes go here dvander@541: // Nasty hack for Microsoft and Intel (IA32 and Itanium) dvander@541: template<> dvander@541: struct SimplifyMemFunc< SINGLE_MEMFUNCPTR_SIZE + sizeof(int) > { dvander@541: template dvander@541: inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind, dvander@541: GenericMemFuncType &bound_func) { dvander@541: // We need to use a horrible_cast to do this conversion. dvander@541: // In MSVC, a multiple inheritance member pointer is internally defined as: dvander@541: union { dvander@541: XFuncType func; dvander@541: struct { dvander@541: GenericMemFuncType funcaddress; // points to the actual member function dvander@541: int delta; // #BYTES to be added to the 'this' pointer dvander@541: }s; dvander@541: } u; dvander@541: // Check that the horrible_cast will work dvander@541: typedef int ERROR_CantUsehorrible_cast[sizeof(function_to_bind)==sizeof(u.s)? 1 : -1]; dvander@541: u.func = function_to_bind; dvander@541: bound_func = u.s.funcaddress; dvander@541: return reinterpret_cast(reinterpret_cast(pthis) + u.s.delta); dvander@541: } dvander@541: }; dvander@541: dvander@541: // virtual inheritance is a real nuisance. It's inefficient and complicated. dvander@541: // On MSVC and Intel, there isn't enough information in the pointer itself to dvander@541: // enable conversion to a closure pointer. Earlier versions of this code didn't dvander@541: // work for all cases, and generated a compile-time error instead. dvander@541: // But a very clever hack invented by John M. Dlugosz solves this problem. dvander@541: // My code is somewhat different to his: I have no asm code, and I make no dvander@541: // assumptions about the calling convention that is used. dvander@541: dvander@541: // In VC++ and ICL, a virtual_inheritance member pointer dvander@541: // is internally defined as: dvander@541: struct MicrosoftVirtualMFP { dvander@541: void (GenericClass::*codeptr)(); // points to the actual member function dvander@541: int delta; // #bytes to be added to the 'this' pointer dvander@541: int vtable_index; // or 0 if no virtual inheritance dvander@541: }; dvander@541: // The CRUCIAL feature of Microsoft/Intel MFPs which we exploit is that the dvander@541: // m_codeptr member is *always* called, regardless of the values of the other dvander@541: // members. (This is *not* true for other compilers, eg GCC, which obtain the dvander@541: // function address from the vtable if a virtual function is being called). dvander@541: // Dlugosz's trick is to make the codeptr point to a probe function which dvander@541: // returns the 'this' pointer that was used. dvander@541: dvander@541: // Define a generic class that uses virtual inheritance. dvander@541: // It has a trival member function that returns the value of the 'this' pointer. dvander@541: struct GenericVirtualClass : virtual public GenericClass dvander@541: { dvander@541: typedef GenericVirtualClass * (GenericVirtualClass::*ProbePtrType)(); dvander@541: GenericVirtualClass * GetThis() { return this; } dvander@541: }; dvander@541: dvander@541: // __virtual_inheritance classes go here dvander@541: template <> dvander@541: struct SimplifyMemFunc dvander@541: { dvander@541: dvander@541: template dvander@541: inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind, dvander@541: GenericMemFuncType &bound_func) { dvander@541: union { dvander@541: XFuncType func; dvander@541: GenericClass* (X::*ProbeFunc)(); dvander@541: MicrosoftVirtualMFP s; dvander@541: } u; dvander@541: u.func = function_to_bind; dvander@541: bound_func = reinterpret_cast(u.s.codeptr); dvander@541: union { dvander@541: GenericVirtualClass::ProbePtrType virtfunc; dvander@541: MicrosoftVirtualMFP s; dvander@541: } u2; dvander@541: // Check that the horrible_cast<>s will work dvander@541: typedef int ERROR_CantUsehorrible_cast[sizeof(function_to_bind)==sizeof(u.s) dvander@541: && sizeof(function_to_bind)==sizeof(u.ProbeFunc) dvander@541: && sizeof(u2.virtfunc)==sizeof(u2.s) ? 1 : -1]; dvander@541: // Unfortunately, taking the address of a MF prevents it from being inlined, so dvander@541: // this next line can't be completely optimised away by the compiler. dvander@541: u2.virtfunc = &GenericVirtualClass::GetThis; dvander@541: u.s.codeptr = u2.s.codeptr; dvander@541: return (pthis->*u.ProbeFunc)(); dvander@541: } dvander@541: }; dvander@541: dvander@541: #if (_MSC_VER <1300) dvander@541: dvander@541: // Nasty hack for Microsoft Visual C++ 6.0 dvander@541: // unknown_inheritance classes go here dvander@541: // There is a compiler bug in MSVC6 which generates incorrect code in this case!! dvander@541: template <> dvander@541: struct SimplifyMemFunc dvander@541: { dvander@541: template dvander@541: inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind, dvander@541: GenericMemFuncType &bound_func) { dvander@541: // There is an apalling but obscure compiler bug in MSVC6 and earlier: dvander@541: // vtable_index and 'vtordisp' are always set to 0 in the dvander@541: // unknown_inheritance case! dvander@541: // This means that an incorrect function could be called!!! dvander@541: // Compiling with the /vmg option leads to potentially incorrect code. dvander@541: // This is probably the reason that the IDE has a user interface for specifying dvander@541: // the /vmg option, but it is disabled - you can only specify /vmg on dvander@541: // the command line. In VC1.5 and earlier, the compiler would ICE if it ever dvander@541: // encountered this situation. dvander@541: // It is OK to use the /vmg option if /vmm or /vms is specified. dvander@541: dvander@541: // Fortunately, the wrong function is only called in very obscure cases. dvander@541: // It only occurs when a derived class overrides a virtual function declared dvander@541: // in a virtual base class, and the member function dvander@541: // points to the *Derived* version of that function. The problem can be dvander@541: // completely averted in 100% of cases by using the *Base class* for the dvander@541: // member fpointer. Ie, if you use the base class as an interface, you'll dvander@541: // stay out of trouble. dvander@541: // Occasionally, you might want to point directly to a derived class function dvander@541: // that isn't an override of a base class. In this case, both vtable_index dvander@541: // and 'vtordisp' are zero, but a virtual_inheritance pointer will be generated. dvander@541: // We can generate correct code in this case. To prevent an incorrect call from dvander@541: // ever being made, on MSVC6 we generate a warning, and call a function to dvander@541: // make the program crash instantly. dvander@541: typedef char ERROR_VC6CompilerBug[-100]; dvander@541: return 0; dvander@541: } dvander@541: }; dvander@541: dvander@541: dvander@541: #else dvander@541: dvander@541: // Nasty hack for Microsoft and Intel (IA32 and Itanium) dvander@541: // unknown_inheritance classes go here dvander@541: // This is probably the ugliest bit of code I've ever written. Look at the casts! dvander@541: // There is a compiler bug in MSVC6 which prevents it from using this code. dvander@541: template <> dvander@541: struct SimplifyMemFunc dvander@541: { dvander@541: template dvander@541: inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind, dvander@541: GenericMemFuncType &bound_func) { dvander@541: // The member function pointer is 16 bytes long. We can't use a normal cast, but dvander@541: // we can use a union to do the conversion. dvander@541: union { dvander@541: XFuncType func; dvander@541: // In VC++ and ICL, an unknown_inheritance member pointer dvander@541: // is internally defined as: dvander@541: struct { dvander@541: GenericMemFuncType m_funcaddress; // points to the actual member function dvander@541: int delta; // #bytes to be added to the 'this' pointer dvander@541: int vtordisp; // #bytes to add to 'this' to find the vtable dvander@541: int vtable_index; // or 0 if no virtual inheritance dvander@541: } s; dvander@541: } u; dvander@541: // Check that the horrible_cast will work dvander@541: typedef int ERROR_CantUsehorrible_cast[sizeof(XFuncType)==sizeof(u.s)? 1 : -1]; dvander@541: u.func = function_to_bind; dvander@541: bound_func = u.s.funcaddress; dvander@541: int virtual_delta = 0; dvander@541: if (u.s.vtable_index) { // Virtual inheritance is used dvander@541: // First, get to the vtable. dvander@541: // It is 'vtordisp' bytes from the start of the class. dvander@541: const int * vtable = *reinterpret_cast( dvander@541: reinterpret_cast(pthis) + u.s.vtordisp ); dvander@541: dvander@541: // 'vtable_index' tells us where in the table we should be looking. dvander@541: virtual_delta = u.s.vtordisp + *reinterpret_cast( dvander@541: reinterpret_cast(vtable) + u.s.vtable_index); dvander@541: } dvander@541: // The int at 'virtual_delta' gives us the amount to add to 'this'. dvander@541: // Finally we can add the three components together. Phew! dvander@541: return reinterpret_cast( dvander@541: reinterpret_cast(pthis) + u.s.delta + virtual_delta); dvander@541: }; dvander@541: }; dvander@541: #endif // MSVC 7 and greater dvander@541: dvander@541: #endif // MS/Intel hacks dvander@541: dvander@541: } // namespace detail dvander@541: dvander@541: //////////////////////////////////////////////////////////////////////////////// dvander@541: // Fast Delegates, part 2: dvander@541: // dvander@541: // Define the delegate storage, and cope with static functions dvander@541: // dvander@541: //////////////////////////////////////////////////////////////////////////////// dvander@541: dvander@541: // DelegateMemento -- an opaque structure which can hold an arbitary delegate. dvander@541: // It knows nothing about the calling convention or number of arguments used by dvander@541: // the function pointed to. dvander@541: // It supplies comparison operators so that it can be stored in STL collections. dvander@541: // It cannot be set to anything other than null, nor invoked directly: dvander@541: // it must be converted to a specific delegate. dvander@541: dvander@541: // Implementation: dvander@541: // There are two possible implementations: the Safe method and the Evil method. dvander@541: // DelegateMemento - Safe version dvander@541: // dvander@541: // This implementation is standard-compliant, but a bit tricky. dvander@541: // A static function pointer is stored inside the class. dvander@541: // Here are the valid values: dvander@541: // +-- Static pointer --+--pThis --+-- pMemFunc-+-- Meaning------+ dvander@541: // | 0 | 0 | 0 | Empty | dvander@541: // | !=0 |(dontcare)| Invoker | Static function| dvander@541: // | 0 | !=0 | !=0* | Method call | dvander@541: // +--------------------+----------+------------+----------------+ dvander@541: // * For Metrowerks, this can be 0. (first virtual function in a dvander@541: // single_inheritance class). dvander@541: // When stored stored inside a specific delegate, the 'dontcare' entries are replaced dvander@541: // with a reference to the delegate itself. This complicates the = and == operators dvander@541: // for the delegate class. dvander@541: dvander@541: // DelegateMemento - Evil version dvander@541: // dvander@541: // For compilers where data pointers are at least as big as code pointers, it is dvander@541: // possible to store the function pointer in the this pointer, using another dvander@541: // horrible_cast. In this case the DelegateMemento implementation is simple: dvander@541: // +--pThis --+-- pMemFunc-+-- Meaning---------------------+ dvander@541: // | 0 | 0 | Empty | dvander@541: // | !=0 | !=0* | Static function or method call| dvander@541: // +----------+------------+-------------------------------+ dvander@541: // * For Metrowerks, this can be 0. (first virtual function in a dvander@541: // single_inheritance class). dvander@541: // Note that the Sun C++ and MSVC documentation explicitly state that they dvander@541: // support static_cast between void * and function pointers. dvander@541: dvander@541: class DelegateMemento { dvander@541: protected: dvander@541: // the data is protected, not private, because many dvander@541: // compilers have problems with template friends. dvander@541: typedef void (detail::GenericClass::*GenericMemFuncType)(); // arbitrary MFP. dvander@541: detail::GenericClass *m_pthis; dvander@541: GenericMemFuncType m_pFunction; dvander@541: dvander@541: #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK) dvander@541: typedef void (*GenericFuncPtr)(); // arbitrary code pointer dvander@541: GenericFuncPtr m_pStaticFunction; dvander@541: #endif dvander@541: dvander@541: public: dvander@541: #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK) dvander@541: DelegateMemento() : m_pthis(0), m_pFunction(0), m_pStaticFunction(0) {}; dvander@541: void clear() { dvander@541: m_pthis=0; m_pFunction=0; m_pStaticFunction=0; dvander@541: } dvander@541: #else dvander@541: DelegateMemento() : m_pthis(0), m_pFunction(0) {}; dvander@541: void clear() { m_pthis=0; m_pFunction=0; } dvander@541: #endif dvander@541: public: dvander@541: #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK) dvander@541: inline bool IsEqual (const DelegateMemento &x) const{ dvander@541: // We have to cope with the static function pointers as a special case dvander@541: if (m_pFunction!=x.m_pFunction) return false; dvander@541: // the static function ptrs must either both be equal, or both be 0. dvander@541: if (m_pStaticFunction!=x.m_pStaticFunction) return false; dvander@541: if (m_pStaticFunction!=0) return m_pthis==x.m_pthis; dvander@541: else return true; dvander@541: } dvander@541: #else // Evil Method dvander@541: inline bool IsEqual (const DelegateMemento &x) const{ dvander@541: return m_pthis==x.m_pthis && m_pFunction==x.m_pFunction; dvander@541: } dvander@541: #endif dvander@541: // Provide a strict weak ordering for DelegateMementos. dvander@541: inline bool IsLess(const DelegateMemento &right) const { dvander@541: // deal with static function pointers first dvander@541: #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK) dvander@541: if (m_pStaticFunction !=0 || right.m_pStaticFunction!=0) dvander@541: return m_pStaticFunction < right.m_pStaticFunction; dvander@541: #endif dvander@541: if (m_pthis !=right.m_pthis) return m_pthis < right.m_pthis; dvander@541: // There are no ordering operators for member function pointers, dvander@541: // but we can fake one by comparing each byte. The resulting ordering is dvander@541: // arbitrary (and compiler-dependent), but it permits storage in ordered STL containers. dvander@541: return memcmp(&m_pFunction, &right.m_pFunction, sizeof(m_pFunction)) < 0; dvander@541: dvander@541: } dvander@541: // BUGFIX (Mar 2005): dvander@541: // We can't just compare m_pFunction because on Metrowerks, dvander@541: // m_pFunction can be zero even if the delegate is not empty! dvander@541: inline bool operator ! () const // Is it bound to anything? dvander@541: { return m_pthis==0 && m_pFunction==0; } dvander@541: inline bool empty() const // Is it bound to anything? dvander@541: { return m_pthis==0 && m_pFunction==0; } dvander@541: public: dvander@541: DelegateMemento & operator = (const DelegateMemento &right) { dvander@541: SetMementoFrom(right); dvander@541: return *this; dvander@541: } dvander@541: inline bool operator <(const DelegateMemento &right) { dvander@541: return IsLess(right); dvander@541: } dvander@541: inline bool operator >(const DelegateMemento &right) { dvander@541: return right.IsLess(*this); dvander@541: } dvander@541: DelegateMemento (const DelegateMemento &right) : dvander@541: m_pthis(right.m_pthis), m_pFunction(right.m_pFunction) dvander@541: #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK) dvander@541: , m_pStaticFunction (right.m_pStaticFunction) dvander@541: #endif dvander@541: {} dvander@541: protected: dvander@541: void SetMementoFrom(const DelegateMemento &right) { dvander@541: m_pFunction = right.m_pFunction; dvander@541: m_pthis = right.m_pthis; dvander@541: #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK) dvander@541: m_pStaticFunction = right.m_pStaticFunction; dvander@541: #endif dvander@541: } dvander@541: }; dvander@541: dvander@541: dvander@541: // ClosurePtr<> dvander@541: // dvander@541: // A private wrapper class that adds function signatures to DelegateMemento. dvander@541: // It's the class that does most of the actual work. dvander@541: // The signatures are specified by: dvander@541: // GenericMemFunc: must be a type of GenericClass member function pointer. dvander@541: // StaticFuncPtr: must be a type of function pointer with the same signature dvander@541: // as GenericMemFunc. dvander@541: // UnvoidStaticFuncPtr: is the same as StaticFuncPtr, except on VC6 dvander@541: // where it never returns void (returns DefaultVoid instead). dvander@541: dvander@541: // An outer class, FastDelegateN<>, handles the invoking and creates the dvander@541: // necessary typedefs. dvander@541: // This class does everything else. dvander@541: dvander@541: namespace detail { dvander@541: dvander@541: template < class GenericMemFunc, class StaticFuncPtr, class UnvoidStaticFuncPtr> dvander@541: class ClosurePtr : public DelegateMemento { dvander@541: public: dvander@541: // These functions are for setting the delegate to a member function. dvander@541: dvander@541: // Here's the clever bit: we convert an arbitrary member function into a dvander@541: // standard form. XMemFunc should be a member function of class X, but I can't dvander@541: // enforce that here. It needs to be enforced by the wrapper class. dvander@541: template < class X, class XMemFunc > dvander@541: inline void bindmemfunc(X *pthis, XMemFunc function_to_bind ) { dvander@541: m_pthis = SimplifyMemFunc< sizeof(function_to_bind) > dvander@541: ::Convert(pthis, function_to_bind, m_pFunction); dvander@541: #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK) dvander@541: m_pStaticFunction = 0; dvander@541: #endif dvander@541: } dvander@541: // For const member functions, we only need a const class pointer. dvander@541: // Since we know that the member function is const, it's safe to dvander@541: // remove the const qualifier from the 'this' pointer with a const_cast. dvander@541: // VC6 has problems if we just overload 'bindmemfunc', so we give it a different name. dvander@541: template < class X, class XMemFunc> dvander@541: inline void bindconstmemfunc(const X *pthis, XMemFunc function_to_bind) { dvander@541: m_pthis= SimplifyMemFunc< sizeof(function_to_bind) > dvander@541: ::Convert(const_cast(pthis), function_to_bind, m_pFunction); dvander@541: #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK) dvander@541: m_pStaticFunction = 0; dvander@541: #endif dvander@541: } dvander@541: #ifdef FASTDELEGATE_GCC_BUG_8271 // At present, GCC doesn't recognize constness of MFPs in templates dvander@541: template < class X, class XMemFunc> dvander@541: inline void bindmemfunc(const X *pthis, XMemFunc function_to_bind) { dvander@541: bindconstmemfunc(pthis, function_to_bind); dvander@541: #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK) dvander@541: m_pStaticFunction = 0; dvander@541: #endif dvander@541: } dvander@541: #endif dvander@541: // These functions are required for invoking the stored function dvander@541: inline GenericClass *GetClosureThis() const { return m_pthis; } dvander@541: inline GenericMemFunc GetClosureMemPtr() const { return reinterpret_cast(m_pFunction); } dvander@541: dvander@541: // There are a few ways of dealing with static function pointers. dvander@541: // There's a standard-compliant, but tricky method. dvander@541: // There's also a straightforward hack, that won't work on DOS compilers using the dvander@541: // medium memory model. It's so evil that I can't recommend it, but I've dvander@541: // implemented it anyway because it produces very nice asm code. dvander@541: dvander@541: #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK) dvander@541: dvander@541: // ClosurePtr<> - Safe version dvander@541: // dvander@541: // This implementation is standard-compliant, but a bit tricky. dvander@541: // I store the function pointer inside the class, and the delegate then dvander@541: // points to itself. Whenever the delegate is copied, these self-references dvander@541: // must be transformed, and this complicates the = and == operators. dvander@541: public: dvander@541: // The next two functions are for operator ==, =, and the copy constructor. dvander@541: // We may need to convert the m_pthis pointers, so that dvander@541: // they remain as self-references. dvander@541: template< class DerivedClass > dvander@541: inline void CopyFrom (DerivedClass *pParent, const DelegateMemento &x) { dvander@541: SetMementoFrom(x); dvander@541: if (m_pStaticFunction!=0) { dvander@541: // transform self references... dvander@541: m_pthis=reinterpret_cast(pParent); dvander@541: } dvander@541: } dvander@541: // For static functions, the 'static_function_invoker' class in the parent dvander@541: // will be called. The parent then needs to call GetStaticFunction() to find out dvander@541: // the actual function to invoke. dvander@541: template < class DerivedClass, class ParentInvokerSig > dvander@541: inline void bindstaticfunc(DerivedClass *pParent, ParentInvokerSig static_function_invoker, dvander@541: StaticFuncPtr function_to_bind ) { dvander@541: if (function_to_bind==0) { // cope with assignment to 0 dvander@541: m_pFunction=0; dvander@541: } else { dvander@541: bindmemfunc(pParent, static_function_invoker); dvander@541: } dvander@541: m_pStaticFunction=reinterpret_cast(function_to_bind); dvander@541: } dvander@541: inline UnvoidStaticFuncPtr GetStaticFunction() const { dvander@541: return reinterpret_cast(m_pStaticFunction); dvander@541: } dvander@541: #else dvander@541: dvander@541: // ClosurePtr<> - Evil version dvander@541: // dvander@541: // For compilers where data pointers are at least as big as code pointers, it is dvander@541: // possible to store the function pointer in the this pointer, using another dvander@541: // horrible_cast. Invocation isn't any faster, but it saves 4 bytes, and dvander@541: // speeds up comparison and assignment. If C++ provided direct language support dvander@541: // for delegates, they would produce asm code that was almost identical to this. dvander@541: // Note that the Sun C++ and MSVC documentation explicitly state that they dvander@541: // support static_cast between void * and function pointers. dvander@541: dvander@541: template< class DerivedClass > dvander@541: inline void CopyFrom (DerivedClass *pParent, const DelegateMemento &right) { dvander@541: SetMementoFrom(right); dvander@541: } dvander@541: // For static functions, the 'static_function_invoker' class in the parent dvander@541: // will be called. The parent then needs to call GetStaticFunction() to find out dvander@541: // the actual function to invoke. dvander@541: // ******** EVIL, EVIL CODE! ******* dvander@541: template < class DerivedClass, class ParentInvokerSig> dvander@541: inline void bindstaticfunc(DerivedClass *pParent, ParentInvokerSig static_function_invoker, dvander@541: StaticFuncPtr function_to_bind) { dvander@541: if (function_to_bind==0) { // cope with assignment to 0 dvander@541: m_pFunction=0; dvander@541: } else { dvander@541: // We'll be ignoring the 'this' pointer, but we need to make sure we pass dvander@541: // a valid value to bindmemfunc(). dvander@541: bindmemfunc(pParent, static_function_invoker); dvander@541: } dvander@541: dvander@541: // WARNING! Evil hack. We store the function in the 'this' pointer! dvander@541: // Ensure that there's a compilation failure if function pointers dvander@541: // and data pointers have different sizes. dvander@541: // If you get this error, you need to #undef FASTDELEGATE_USESTATICFUNCTIONHACK. dvander@541: typedef int ERROR_CantUseEvilMethod[sizeof(GenericClass *)==sizeof(function_to_bind) ? 1 : -1]; dvander@541: m_pthis = horrible_cast(function_to_bind); dvander@541: // MSVC, SunC++ and DMC accept the following (non-standard) code: dvander@541: // m_pthis = static_cast(static_cast(function_to_bind)); dvander@541: // BCC32, Comeau and DMC accept this method. MSVC7.1 needs __int64 instead of long dvander@541: // m_pthis = reinterpret_cast(reinterpret_cast(function_to_bind)); dvander@541: } dvander@541: // ******** EVIL, EVIL CODE! ******* dvander@541: // This function will be called with an invalid 'this' pointer!! dvander@541: // We're just returning the 'this' pointer, converted into dvander@541: // a function pointer! dvander@541: inline UnvoidStaticFuncPtr GetStaticFunction() const { dvander@541: // Ensure that there's a compilation failure if function pointers dvander@541: // and data pointers have different sizes. dvander@541: // If you get this error, you need to #undef FASTDELEGATE_USESTATICFUNCTIONHACK. dvander@541: typedef int ERROR_CantUseEvilMethod[sizeof(UnvoidStaticFuncPtr)==sizeof(this) ? 1 : -1]; dvander@541: return horrible_cast(this); dvander@541: } dvander@541: #endif // !defined(FASTDELEGATE_USESTATICFUNCTIONHACK) dvander@541: dvander@541: // Does the closure contain this static function? dvander@541: inline bool IsEqualToStaticFuncPtr(StaticFuncPtr funcptr){ dvander@541: if (funcptr==0) return empty(); dvander@541: // For the Evil method, if it doesn't actually contain a static function, this will return an arbitrary dvander@541: // value that is not equal to any valid function pointer. dvander@541: else return funcptr==reinterpret_cast(GetStaticFunction()); dvander@541: } dvander@541: }; dvander@541: dvander@541: dvander@541: } // namespace detail dvander@541: dvander@541: //////////////////////////////////////////////////////////////////////////////// dvander@541: // Fast Delegates, part 3: dvander@541: // dvander@541: // Wrapper classes to ensure type safety dvander@541: // dvander@541: //////////////////////////////////////////////////////////////////////////////// dvander@541: dvander@541: dvander@541: // Once we have the member function conversion templates, it's easy to make the dvander@541: // wrapper classes. So that they will work with as many compilers as possible, dvander@541: // the classes are of the form dvander@541: // FastDelegate3 dvander@541: // They can cope with any combination of parameters. The max number of parameters dvander@541: // allowed is 8, but it is trivial to increase this limit. dvander@541: // Note that we need to treat const member functions seperately. dvander@541: // All this class does is to enforce type safety, and invoke the delegate with dvander@541: // the correct list of parameters. dvander@541: dvander@541: // Because of the weird rule about the class of derived member function pointers, dvander@541: // you sometimes need to apply a downcast to the 'this' pointer. dvander@541: // This is the reason for the use of "implicit_cast(pthis)" in the code below. dvander@541: // If CDerivedClass is derived from CBaseClass, but doesn't override SimpleVirtualFunction, dvander@541: // without this trick you'd need to write: dvander@541: // MyDelegate(static_cast(&d), &CDerivedClass::SimpleVirtualFunction); dvander@541: // but with the trick you can write dvander@541: // MyDelegate(&d, &CDerivedClass::SimpleVirtualFunction); dvander@541: dvander@541: // RetType is the type the compiler uses in compiling the template. For VC6, dvander@541: // it cannot be void. DesiredRetType is the real type which is returned from dvander@541: // all of the functions. It can be void. dvander@541: dvander@541: // Implicit conversion to "bool" is achieved using the safe_bool idiom, dvander@541: // using member data pointers (MDP). This allows "if (dg)..." syntax dvander@541: // Because some compilers (eg codeplay) don't have a unique value for a zero dvander@541: // MDP, an extra padding member is added to the SafeBool struct. dvander@541: // Some compilers (eg VC6) won't implicitly convert from 0 to an MDP, so dvander@541: // in that case the static function constructor is not made explicit; this dvander@541: // allows "if (dg==0) ..." to compile. dvander@541: dvander@541: //N=0 dvander@541: template dvander@541: class FastDelegate0 { dvander@541: private: dvander@541: typedef typename detail::DefaultVoidToVoid::type DesiredRetType; dvander@541: typedef DesiredRetType (*StaticFunctionPtr)(); dvander@541: typedef RetType (*UnvoidStaticFunctionPtr)(); dvander@541: typedef RetType (detail::GenericClass::*GenericMemFn)(); dvander@541: typedef detail::ClosurePtr ClosureType; dvander@541: ClosureType m_Closure; dvander@541: public: dvander@541: // Typedefs to aid generic programming dvander@541: typedef FastDelegate0 type; dvander@541: dvander@541: // Construction and comparison functions dvander@541: FastDelegate0() { clear(); } dvander@541: FastDelegate0(const FastDelegate0 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: void operator = (const FastDelegate0 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: bool operator ==(const FastDelegate0 &x) const { dvander@541: return m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator !=(const FastDelegate0 &x) const { dvander@541: return !m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator <(const FastDelegate0 &x) const { dvander@541: return m_Closure.IsLess(x.m_Closure); } dvander@541: bool operator >(const FastDelegate0 &x) const { dvander@541: return x.m_Closure.IsLess(m_Closure); } dvander@541: // Binding to non-const member functions dvander@541: template < class X, class Y > dvander@541: FastDelegate0(Y *pthis, DesiredRetType (X::* function_to_bind)() ) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)()) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Binding to const member functions. dvander@541: template < class X, class Y > dvander@541: FastDelegate0(const Y *pthis, DesiredRetType (X::* function_to_bind)() const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)() const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Static functions. We convert them into a member function call. dvander@541: // This constructor also provides implicit conversion dvander@541: FastDelegate0(DesiredRetType (*function_to_bind)() ) { dvander@541: bind(function_to_bind); } dvander@541: // for efficiency, prevent creation of a temporary dvander@541: void operator = (DesiredRetType (*function_to_bind)() ) { dvander@541: bind(function_to_bind); } dvander@541: inline void bind(DesiredRetType (*function_to_bind)()) { dvander@541: m_Closure.bindstaticfunc(this, &FastDelegate0::InvokeStaticFunction, dvander@541: function_to_bind); } dvander@541: // Invoke the delegate dvander@541: RetType operator() () const { dvander@541: return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(); } dvander@541: // Implicit conversion to "bool" using the safe_bool idiom dvander@541: private: dvander@541: typedef struct SafeBoolStruct { dvander@541: int a_data_pointer_to_this_is_0_on_buggy_compilers; dvander@541: StaticFunctionPtr m_nonzero; dvander@541: } UselessTypedef; dvander@541: typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type; dvander@541: public: dvander@541: operator unspecified_bool_type() const { dvander@541: return empty()? 0: &SafeBoolStruct::m_nonzero; dvander@541: } dvander@541: // necessary to allow ==0 to work despite the safe_bool idiom dvander@541: inline bool operator==(StaticFunctionPtr funcptr) { dvander@541: return m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator!=(StaticFunctionPtr funcptr) { dvander@541: return !m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator ! () const { // Is it bound to anything? dvander@541: return !m_Closure; } dvander@541: inline bool empty() const { dvander@541: return !m_Closure; } dvander@541: void clear() { m_Closure.clear();} dvander@541: // Conversion to and from the DelegateMemento storage class dvander@541: const DelegateMemento & GetMemento() { return m_Closure; } dvander@541: void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); } dvander@541: dvander@541: private: // Invoker for static functions dvander@541: RetType InvokeStaticFunction() const { dvander@541: return (*(m_Closure.GetStaticFunction()))(); } dvander@541: }; dvander@541: dvander@541: //N=1 dvander@541: template dvander@541: class FastDelegate1 { dvander@541: private: dvander@541: typedef typename detail::DefaultVoidToVoid::type DesiredRetType; dvander@541: typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1); dvander@541: typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1); dvander@541: typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1); dvander@541: typedef detail::ClosurePtr ClosureType; dvander@541: ClosureType m_Closure; dvander@541: public: dvander@541: // Typedefs to aid generic programming dvander@541: typedef FastDelegate1 type; dvander@541: dvander@541: // Construction and comparison functions dvander@541: FastDelegate1() { clear(); } dvander@541: FastDelegate1(const FastDelegate1 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: void operator = (const FastDelegate1 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: bool operator ==(const FastDelegate1 &x) const { dvander@541: return m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator !=(const FastDelegate1 &x) const { dvander@541: return !m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator <(const FastDelegate1 &x) const { dvander@541: return m_Closure.IsLess(x.m_Closure); } dvander@541: bool operator >(const FastDelegate1 &x) const { dvander@541: return x.m_Closure.IsLess(m_Closure); } dvander@541: // Binding to non-const member functions dvander@541: template < class X, class Y > dvander@541: FastDelegate1(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1) ) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1)) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Binding to const member functions. dvander@541: template < class X, class Y > dvander@541: FastDelegate1(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Static functions. We convert them into a member function call. dvander@541: // This constructor also provides implicit conversion dvander@541: FastDelegate1(DesiredRetType (*function_to_bind)(Param1 p1) ) { dvander@541: bind(function_to_bind); } dvander@541: // for efficiency, prevent creation of a temporary dvander@541: void operator = (DesiredRetType (*function_to_bind)(Param1 p1) ) { dvander@541: bind(function_to_bind); } dvander@541: inline void bind(DesiredRetType (*function_to_bind)(Param1 p1)) { dvander@541: m_Closure.bindstaticfunc(this, &FastDelegate1::InvokeStaticFunction, dvander@541: function_to_bind); } dvander@541: // Invoke the delegate dvander@541: RetType operator() (Param1 p1) const { dvander@541: return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1); } dvander@541: // Implicit conversion to "bool" using the safe_bool idiom dvander@541: private: dvander@541: typedef struct SafeBoolStruct { dvander@541: int a_data_pointer_to_this_is_0_on_buggy_compilers; dvander@541: StaticFunctionPtr m_nonzero; dvander@541: } UselessTypedef; dvander@541: typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type; dvander@541: public: dvander@541: operator unspecified_bool_type() const { dvander@541: return empty()? 0: &SafeBoolStruct::m_nonzero; dvander@541: } dvander@541: // necessary to allow ==0 to work despite the safe_bool idiom dvander@541: inline bool operator==(StaticFunctionPtr funcptr) { dvander@541: return m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator!=(StaticFunctionPtr funcptr) { dvander@541: return !m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator ! () const { // Is it bound to anything? dvander@541: return !m_Closure; } dvander@541: inline bool empty() const { dvander@541: return !m_Closure; } dvander@541: void clear() { m_Closure.clear();} dvander@541: // Conversion to and from the DelegateMemento storage class dvander@541: const DelegateMemento & GetMemento() { return m_Closure; } dvander@541: void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); } dvander@541: dvander@541: private: // Invoker for static functions dvander@541: RetType InvokeStaticFunction(Param1 p1) const { dvander@541: return (*(m_Closure.GetStaticFunction()))(p1); } dvander@541: }; dvander@541: dvander@541: //N=2 dvander@541: template dvander@541: class FastDelegate2 { dvander@541: private: dvander@541: typedef typename detail::DefaultVoidToVoid::type DesiredRetType; dvander@541: typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2); dvander@541: typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2); dvander@541: typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2); dvander@541: typedef detail::ClosurePtr ClosureType; dvander@541: ClosureType m_Closure; dvander@541: public: dvander@541: // Typedefs to aid generic programming dvander@541: typedef FastDelegate2 type; dvander@541: dvander@541: // Construction and comparison functions dvander@541: FastDelegate2() { clear(); } dvander@541: FastDelegate2(const FastDelegate2 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: void operator = (const FastDelegate2 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: bool operator ==(const FastDelegate2 &x) const { dvander@541: return m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator !=(const FastDelegate2 &x) const { dvander@541: return !m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator <(const FastDelegate2 &x) const { dvander@541: return m_Closure.IsLess(x.m_Closure); } dvander@541: bool operator >(const FastDelegate2 &x) const { dvander@541: return x.m_Closure.IsLess(m_Closure); } dvander@541: // Binding to non-const member functions dvander@541: template < class X, class Y > dvander@541: FastDelegate2(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2) ) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2)) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Binding to const member functions. dvander@541: template < class X, class Y > dvander@541: FastDelegate2(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Static functions. We convert them into a member function call. dvander@541: // This constructor also provides implicit conversion dvander@541: FastDelegate2(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2) ) { dvander@541: bind(function_to_bind); } dvander@541: // for efficiency, prevent creation of a temporary dvander@541: void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2) ) { dvander@541: bind(function_to_bind); } dvander@541: inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2)) { dvander@541: m_Closure.bindstaticfunc(this, &FastDelegate2::InvokeStaticFunction, dvander@541: function_to_bind); } dvander@541: // Invoke the delegate dvander@541: RetType operator() (Param1 p1, Param2 p2) const { dvander@541: return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2); } dvander@541: // Implicit conversion to "bool" using the safe_bool idiom dvander@541: private: dvander@541: typedef struct SafeBoolStruct { dvander@541: int a_data_pointer_to_this_is_0_on_buggy_compilers; dvander@541: StaticFunctionPtr m_nonzero; dvander@541: } UselessTypedef; dvander@541: typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type; dvander@541: public: dvander@541: operator unspecified_bool_type() const { dvander@541: return empty()? 0: &SafeBoolStruct::m_nonzero; dvander@541: } dvander@541: // necessary to allow ==0 to work despite the safe_bool idiom dvander@541: inline bool operator==(StaticFunctionPtr funcptr) { dvander@541: return m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator!=(StaticFunctionPtr funcptr) { dvander@541: return !m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator ! () const { // Is it bound to anything? dvander@541: return !m_Closure; } dvander@541: inline bool empty() const { dvander@541: return !m_Closure; } dvander@541: void clear() { m_Closure.clear();} dvander@541: // Conversion to and from the DelegateMemento storage class dvander@541: const DelegateMemento & GetMemento() { return m_Closure; } dvander@541: void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); } dvander@541: dvander@541: private: // Invoker for static functions dvander@541: RetType InvokeStaticFunction(Param1 p1, Param2 p2) const { dvander@541: return (*(m_Closure.GetStaticFunction()))(p1, p2); } dvander@541: }; dvander@541: dvander@541: //N=3 dvander@541: template dvander@541: class FastDelegate3 { dvander@541: private: dvander@541: typedef typename detail::DefaultVoidToVoid::type DesiredRetType; dvander@541: typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3); dvander@541: typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3); dvander@541: typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3); dvander@541: typedef detail::ClosurePtr ClosureType; dvander@541: ClosureType m_Closure; dvander@541: public: dvander@541: // Typedefs to aid generic programming dvander@541: typedef FastDelegate3 type; dvander@541: dvander@541: // Construction and comparison functions dvander@541: FastDelegate3() { clear(); } dvander@541: FastDelegate3(const FastDelegate3 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: void operator = (const FastDelegate3 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: bool operator ==(const FastDelegate3 &x) const { dvander@541: return m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator !=(const FastDelegate3 &x) const { dvander@541: return !m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator <(const FastDelegate3 &x) const { dvander@541: return m_Closure.IsLess(x.m_Closure); } dvander@541: bool operator >(const FastDelegate3 &x) const { dvander@541: return x.m_Closure.IsLess(m_Closure); } dvander@541: // Binding to non-const member functions dvander@541: template < class X, class Y > dvander@541: FastDelegate3(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3) ) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3)) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Binding to const member functions. dvander@541: template < class X, class Y > dvander@541: FastDelegate3(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Static functions. We convert them into a member function call. dvander@541: // This constructor also provides implicit conversion dvander@541: FastDelegate3(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3) ) { dvander@541: bind(function_to_bind); } dvander@541: // for efficiency, prevent creation of a temporary dvander@541: void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3) ) { dvander@541: bind(function_to_bind); } dvander@541: inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3)) { dvander@541: m_Closure.bindstaticfunc(this, &FastDelegate3::InvokeStaticFunction, dvander@541: function_to_bind); } dvander@541: // Invoke the delegate dvander@541: RetType operator() (Param1 p1, Param2 p2, Param3 p3) const { dvander@541: return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3); } dvander@541: // Implicit conversion to "bool" using the safe_bool idiom dvander@541: private: dvander@541: typedef struct SafeBoolStruct { dvander@541: int a_data_pointer_to_this_is_0_on_buggy_compilers; dvander@541: StaticFunctionPtr m_nonzero; dvander@541: } UselessTypedef; dvander@541: typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type; dvander@541: public: dvander@541: operator unspecified_bool_type() const { dvander@541: return empty()? 0: &SafeBoolStruct::m_nonzero; dvander@541: } dvander@541: // necessary to allow ==0 to work despite the safe_bool idiom dvander@541: inline bool operator==(StaticFunctionPtr funcptr) { dvander@541: return m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator!=(StaticFunctionPtr funcptr) { dvander@541: return !m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator ! () const { // Is it bound to anything? dvander@541: return !m_Closure; } dvander@541: inline bool empty() const { dvander@541: return !m_Closure; } dvander@541: void clear() { m_Closure.clear();} dvander@541: // Conversion to and from the DelegateMemento storage class dvander@541: const DelegateMemento & GetMemento() { return m_Closure; } dvander@541: void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); } dvander@541: dvander@541: private: // Invoker for static functions dvander@541: RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3) const { dvander@541: return (*(m_Closure.GetStaticFunction()))(p1, p2, p3); } dvander@541: }; dvander@541: dvander@541: //N=4 dvander@541: template dvander@541: class FastDelegate4 { dvander@541: private: dvander@541: typedef typename detail::DefaultVoidToVoid::type DesiredRetType; dvander@541: typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4); dvander@541: typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4); dvander@541: typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4); dvander@541: typedef detail::ClosurePtr ClosureType; dvander@541: ClosureType m_Closure; dvander@541: public: dvander@541: // Typedefs to aid generic programming dvander@541: typedef FastDelegate4 type; dvander@541: dvander@541: // Construction and comparison functions dvander@541: FastDelegate4() { clear(); } dvander@541: FastDelegate4(const FastDelegate4 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: void operator = (const FastDelegate4 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: bool operator ==(const FastDelegate4 &x) const { dvander@541: return m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator !=(const FastDelegate4 &x) const { dvander@541: return !m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator <(const FastDelegate4 &x) const { dvander@541: return m_Closure.IsLess(x.m_Closure); } dvander@541: bool operator >(const FastDelegate4 &x) const { dvander@541: return x.m_Closure.IsLess(m_Closure); } dvander@541: // Binding to non-const member functions dvander@541: template < class X, class Y > dvander@541: FastDelegate4(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4) ) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4)) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Binding to const member functions. dvander@541: template < class X, class Y > dvander@541: FastDelegate4(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Static functions. We convert them into a member function call. dvander@541: // This constructor also provides implicit conversion dvander@541: FastDelegate4(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4) ) { dvander@541: bind(function_to_bind); } dvander@541: // for efficiency, prevent creation of a temporary dvander@541: void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4) ) { dvander@541: bind(function_to_bind); } dvander@541: inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4)) { dvander@541: m_Closure.bindstaticfunc(this, &FastDelegate4::InvokeStaticFunction, dvander@541: function_to_bind); } dvander@541: // Invoke the delegate dvander@541: RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4) const { dvander@541: return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4); } dvander@541: // Implicit conversion to "bool" using the safe_bool idiom dvander@541: private: dvander@541: typedef struct SafeBoolStruct { dvander@541: int a_data_pointer_to_this_is_0_on_buggy_compilers; dvander@541: StaticFunctionPtr m_nonzero; dvander@541: } UselessTypedef; dvander@541: typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type; dvander@541: public: dvander@541: operator unspecified_bool_type() const { dvander@541: return empty()? 0: &SafeBoolStruct::m_nonzero; dvander@541: } dvander@541: // necessary to allow ==0 to work despite the safe_bool idiom dvander@541: inline bool operator==(StaticFunctionPtr funcptr) { dvander@541: return m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator!=(StaticFunctionPtr funcptr) { dvander@541: return !m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator ! () const { // Is it bound to anything? dvander@541: return !m_Closure; } dvander@541: inline bool empty() const { dvander@541: return !m_Closure; } dvander@541: void clear() { m_Closure.clear();} dvander@541: // Conversion to and from the DelegateMemento storage class dvander@541: const DelegateMemento & GetMemento() { return m_Closure; } dvander@541: void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); } dvander@541: dvander@541: private: // Invoker for static functions dvander@541: RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const { dvander@541: return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4); } dvander@541: }; dvander@541: dvander@541: //N=5 dvander@541: template dvander@541: class FastDelegate5 { dvander@541: private: dvander@541: typedef typename detail::DefaultVoidToVoid::type DesiredRetType; dvander@541: typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5); dvander@541: typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5); dvander@541: typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5); dvander@541: typedef detail::ClosurePtr ClosureType; dvander@541: ClosureType m_Closure; dvander@541: public: dvander@541: // Typedefs to aid generic programming dvander@541: typedef FastDelegate5 type; dvander@541: dvander@541: // Construction and comparison functions dvander@541: FastDelegate5() { clear(); } dvander@541: FastDelegate5(const FastDelegate5 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: void operator = (const FastDelegate5 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: bool operator ==(const FastDelegate5 &x) const { dvander@541: return m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator !=(const FastDelegate5 &x) const { dvander@541: return !m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator <(const FastDelegate5 &x) const { dvander@541: return m_Closure.IsLess(x.m_Closure); } dvander@541: bool operator >(const FastDelegate5 &x) const { dvander@541: return x.m_Closure.IsLess(m_Closure); } dvander@541: // Binding to non-const member functions dvander@541: template < class X, class Y > dvander@541: FastDelegate5(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) ) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5)) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Binding to const member functions. dvander@541: template < class X, class Y > dvander@541: FastDelegate5(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Static functions. We convert them into a member function call. dvander@541: // This constructor also provides implicit conversion dvander@541: FastDelegate5(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) ) { dvander@541: bind(function_to_bind); } dvander@541: // for efficiency, prevent creation of a temporary dvander@541: void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) ) { dvander@541: bind(function_to_bind); } dvander@541: inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5)) { dvander@541: m_Closure.bindstaticfunc(this, &FastDelegate5::InvokeStaticFunction, dvander@541: function_to_bind); } dvander@541: // Invoke the delegate dvander@541: RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const { dvander@541: return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5); } dvander@541: // Implicit conversion to "bool" using the safe_bool idiom dvander@541: private: dvander@541: typedef struct SafeBoolStruct { dvander@541: int a_data_pointer_to_this_is_0_on_buggy_compilers; dvander@541: StaticFunctionPtr m_nonzero; dvander@541: } UselessTypedef; dvander@541: typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type; dvander@541: public: dvander@541: operator unspecified_bool_type() const { dvander@541: return empty()? 0: &SafeBoolStruct::m_nonzero; dvander@541: } dvander@541: // necessary to allow ==0 to work despite the safe_bool idiom dvander@541: inline bool operator==(StaticFunctionPtr funcptr) { dvander@541: return m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator!=(StaticFunctionPtr funcptr) { dvander@541: return !m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator ! () const { // Is it bound to anything? dvander@541: return !m_Closure; } dvander@541: inline bool empty() const { dvander@541: return !m_Closure; } dvander@541: void clear() { m_Closure.clear();} dvander@541: // Conversion to and from the DelegateMemento storage class dvander@541: const DelegateMemento & GetMemento() { return m_Closure; } dvander@541: void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); } dvander@541: dvander@541: private: // Invoker for static functions dvander@541: RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const { dvander@541: return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5); } dvander@541: }; dvander@541: dvander@541: //N=6 dvander@541: template dvander@541: class FastDelegate6 { dvander@541: private: dvander@541: typedef typename detail::DefaultVoidToVoid::type DesiredRetType; dvander@541: typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6); dvander@541: typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6); dvander@541: typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6); dvander@541: typedef detail::ClosurePtr ClosureType; dvander@541: ClosureType m_Closure; dvander@541: public: dvander@541: // Typedefs to aid generic programming dvander@541: typedef FastDelegate6 type; dvander@541: dvander@541: // Construction and comparison functions dvander@541: FastDelegate6() { clear(); } dvander@541: FastDelegate6(const FastDelegate6 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: void operator = (const FastDelegate6 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: bool operator ==(const FastDelegate6 &x) const { dvander@541: return m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator !=(const FastDelegate6 &x) const { dvander@541: return !m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator <(const FastDelegate6 &x) const { dvander@541: return m_Closure.IsLess(x.m_Closure); } dvander@541: bool operator >(const FastDelegate6 &x) const { dvander@541: return x.m_Closure.IsLess(m_Closure); } dvander@541: // Binding to non-const member functions dvander@541: template < class X, class Y > dvander@541: FastDelegate6(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) ) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6)) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Binding to const member functions. dvander@541: template < class X, class Y > dvander@541: FastDelegate6(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Static functions. We convert them into a member function call. dvander@541: // This constructor also provides implicit conversion dvander@541: FastDelegate6(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) ) { dvander@541: bind(function_to_bind); } dvander@541: // for efficiency, prevent creation of a temporary dvander@541: void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) ) { dvander@541: bind(function_to_bind); } dvander@541: inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6)) { dvander@541: m_Closure.bindstaticfunc(this, &FastDelegate6::InvokeStaticFunction, dvander@541: function_to_bind); } dvander@541: // Invoke the delegate dvander@541: RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const { dvander@541: return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6); } dvander@541: // Implicit conversion to "bool" using the safe_bool idiom dvander@541: private: dvander@541: typedef struct SafeBoolStruct { dvander@541: int a_data_pointer_to_this_is_0_on_buggy_compilers; dvander@541: StaticFunctionPtr m_nonzero; dvander@541: } UselessTypedef; dvander@541: typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type; dvander@541: public: dvander@541: operator unspecified_bool_type() const { dvander@541: return empty()? 0: &SafeBoolStruct::m_nonzero; dvander@541: } dvander@541: // necessary to allow ==0 to work despite the safe_bool idiom dvander@541: inline bool operator==(StaticFunctionPtr funcptr) { dvander@541: return m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator!=(StaticFunctionPtr funcptr) { dvander@541: return !m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator ! () const { // Is it bound to anything? dvander@541: return !m_Closure; } dvander@541: inline bool empty() const { dvander@541: return !m_Closure; } dvander@541: void clear() { m_Closure.clear();} dvander@541: // Conversion to and from the DelegateMemento storage class dvander@541: const DelegateMemento & GetMemento() { return m_Closure; } dvander@541: void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); } dvander@541: dvander@541: private: // Invoker for static functions dvander@541: RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const { dvander@541: return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6); } dvander@541: }; dvander@541: dvander@541: //N=7 dvander@541: template dvander@541: class FastDelegate7 { dvander@541: private: dvander@541: typedef typename detail::DefaultVoidToVoid::type DesiredRetType; dvander@541: typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7); dvander@541: typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7); dvander@541: typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7); dvander@541: typedef detail::ClosurePtr ClosureType; dvander@541: ClosureType m_Closure; dvander@541: public: dvander@541: // Typedefs to aid generic programming dvander@541: typedef FastDelegate7 type; dvander@541: dvander@541: // Construction and comparison functions dvander@541: FastDelegate7() { clear(); } dvander@541: FastDelegate7(const FastDelegate7 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: void operator = (const FastDelegate7 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: bool operator ==(const FastDelegate7 &x) const { dvander@541: return m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator !=(const FastDelegate7 &x) const { dvander@541: return !m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator <(const FastDelegate7 &x) const { dvander@541: return m_Closure.IsLess(x.m_Closure); } dvander@541: bool operator >(const FastDelegate7 &x) const { dvander@541: return x.m_Closure.IsLess(m_Closure); } dvander@541: // Binding to non-const member functions dvander@541: template < class X, class Y > dvander@541: FastDelegate7(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) ) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7)) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Binding to const member functions. dvander@541: template < class X, class Y > dvander@541: FastDelegate7(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Static functions. We convert them into a member function call. dvander@541: // This constructor also provides implicit conversion dvander@541: FastDelegate7(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) ) { dvander@541: bind(function_to_bind); } dvander@541: // for efficiency, prevent creation of a temporary dvander@541: void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) ) { dvander@541: bind(function_to_bind); } dvander@541: inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7)) { dvander@541: m_Closure.bindstaticfunc(this, &FastDelegate7::InvokeStaticFunction, dvander@541: function_to_bind); } dvander@541: // Invoke the delegate dvander@541: RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const { dvander@541: return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7); } dvander@541: // Implicit conversion to "bool" using the safe_bool idiom dvander@541: private: dvander@541: typedef struct SafeBoolStruct { dvander@541: int a_data_pointer_to_this_is_0_on_buggy_compilers; dvander@541: StaticFunctionPtr m_nonzero; dvander@541: } UselessTypedef; dvander@541: typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type; dvander@541: public: dvander@541: operator unspecified_bool_type() const { dvander@541: return empty()? 0: &SafeBoolStruct::m_nonzero; dvander@541: } dvander@541: // necessary to allow ==0 to work despite the safe_bool idiom dvander@541: inline bool operator==(StaticFunctionPtr funcptr) { dvander@541: return m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator!=(StaticFunctionPtr funcptr) { dvander@541: return !m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator ! () const { // Is it bound to anything? dvander@541: return !m_Closure; } dvander@541: inline bool empty() const { dvander@541: return !m_Closure; } dvander@541: void clear() { m_Closure.clear();} dvander@541: // Conversion to and from the DelegateMemento storage class dvander@541: const DelegateMemento & GetMemento() { return m_Closure; } dvander@541: void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); } dvander@541: dvander@541: private: // Invoker for static functions dvander@541: RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const { dvander@541: return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7); } dvander@541: }; dvander@541: dvander@541: //N=8 dvander@541: template dvander@541: class FastDelegate8 { dvander@541: private: dvander@541: typedef typename detail::DefaultVoidToVoid::type DesiredRetType; dvander@541: typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8); dvander@541: typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8); dvander@541: typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8); dvander@541: typedef detail::ClosurePtr ClosureType; dvander@541: ClosureType m_Closure; dvander@541: public: dvander@541: // Typedefs to aid generic programming dvander@541: typedef FastDelegate8 type; dvander@541: dvander@541: // Construction and comparison functions dvander@541: FastDelegate8() { clear(); } dvander@541: FastDelegate8(const FastDelegate8 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: void operator = (const FastDelegate8 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: bool operator ==(const FastDelegate8 &x) const { dvander@541: return m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator !=(const FastDelegate8 &x) const { dvander@541: return !m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator <(const FastDelegate8 &x) const { dvander@541: return m_Closure.IsLess(x.m_Closure); } dvander@541: bool operator >(const FastDelegate8 &x) const { dvander@541: return x.m_Closure.IsLess(m_Closure); } dvander@541: // Binding to non-const member functions dvander@541: template < class X, class Y > dvander@541: FastDelegate8(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) ) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8)) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Binding to const member functions. dvander@541: template < class X, class Y > dvander@541: FastDelegate8(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Static functions. We convert them into a member function call. dvander@541: // This constructor also provides implicit conversion dvander@541: FastDelegate8(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) ) { dvander@541: bind(function_to_bind); } dvander@541: // for efficiency, prevent creation of a temporary dvander@541: void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) ) { dvander@541: bind(function_to_bind); } dvander@541: inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8)) { dvander@541: m_Closure.bindstaticfunc(this, &FastDelegate8::InvokeStaticFunction, dvander@541: function_to_bind); } dvander@541: // Invoke the delegate dvander@541: RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) const { dvander@541: return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8); } dvander@541: // Implicit conversion to "bool" using the safe_bool idiom dvander@541: private: dvander@541: typedef struct SafeBoolStruct { dvander@541: int a_data_pointer_to_this_is_0_on_buggy_compilers; dvander@541: StaticFunctionPtr m_nonzero; dvander@541: } UselessTypedef; dvander@541: typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type; dvander@541: public: dvander@541: operator unspecified_bool_type() const { dvander@541: return empty()? 0: &SafeBoolStruct::m_nonzero; dvander@541: } dvander@541: // necessary to allow ==0 to work despite the safe_bool idiom dvander@541: inline bool operator==(StaticFunctionPtr funcptr) { dvander@541: return m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator!=(StaticFunctionPtr funcptr) { dvander@541: return !m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator ! () const { // Is it bound to anything? dvander@541: return !m_Closure; } dvander@541: inline bool empty() const { dvander@541: return !m_Closure; } dvander@541: void clear() { m_Closure.clear();} dvander@541: // Conversion to and from the DelegateMemento storage class dvander@541: const DelegateMemento & GetMemento() { return m_Closure; } dvander@541: void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); } dvander@541: dvander@541: private: // Invoker for static functions dvander@541: RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) const { dvander@541: return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8); } dvander@541: }; dvander@541: dvander@541: //N=9 dvander@541: template dvander@541: class FastDelegate9 { dvander@541: private: dvander@541: typedef typename detail::DefaultVoidToVoid::type DesiredRetType; dvander@541: typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9); dvander@541: typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9); dvander@541: typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9); dvander@541: typedef detail::ClosurePtr ClosureType; dvander@541: ClosureType m_Closure; dvander@541: public: dvander@541: // Typedefs to aid generic programming dvander@541: typedef FastDelegate9 type; dvander@541: dvander@541: // Construction and comparison functions dvander@541: FastDelegate9() { clear(); } dvander@541: FastDelegate9(const FastDelegate9 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: void operator = (const FastDelegate9 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: bool operator ==(const FastDelegate9 &x) const { dvander@541: return m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator !=(const FastDelegate9 &x) const { dvander@541: return !m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator <(const FastDelegate9 &x) const { dvander@541: return m_Closure.IsLess(x.m_Closure); } dvander@541: bool operator >(const FastDelegate9 &x) const { dvander@541: return x.m_Closure.IsLess(m_Closure); } dvander@541: // Binding to non-const member functions dvander@541: template < class X, class Y > dvander@541: FastDelegate9(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9) ) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9)) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Binding to const member functions. dvander@541: template < class X, class Y > dvander@541: FastDelegate9(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Static functions. We convert them into a member function call. dvander@541: // This constructor also provides implicit conversion dvander@541: FastDelegate9(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9) ) { dvander@541: bind(function_to_bind); } dvander@541: // for efficiency, prevent creation of a temporary dvander@541: void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9) ) { dvander@541: bind(function_to_bind); } dvander@541: inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9)) { dvander@541: m_Closure.bindstaticfunc(this, &FastDelegate9::InvokeStaticFunction, dvander@541: function_to_bind); } dvander@541: // Invoke the delegate dvander@541: RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9) const { dvander@541: return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9); } dvander@541: // Implicit conversion to "bool" using the safe_bool idiom dvander@541: private: dvander@541: typedef struct SafeBoolStruct { dvander@541: int a_data_pointer_to_this_is_0_on_buggy_compilers; dvander@541: StaticFunctionPtr m_nonzero; dvander@541: } UselessTypedef; dvander@541: typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type; dvander@541: public: dvander@541: operator unspecified_bool_type() const { dvander@541: return empty()? 0: &SafeBoolStruct::m_nonzero; dvander@541: } dvander@541: // necessary to allow ==0 to work despite the safe_bool idiom dvander@541: inline bool operator==(StaticFunctionPtr funcptr) { dvander@541: return m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator!=(StaticFunctionPtr funcptr) { dvander@541: return !m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator ! () const { // Is it bound to anything? dvander@541: return !m_Closure; } dvander@541: inline bool empty() const { dvander@541: return !m_Closure; } dvander@541: void clear() { m_Closure.clear();} dvander@541: // Conversion to and from the DelegateMemento storage class dvander@541: const DelegateMemento & GetMemento() { return m_Closure; } dvander@541: void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); } dvander@541: dvander@541: private: // Invoker for static functions dvander@541: RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9) const { dvander@541: return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9); } dvander@541: }; dvander@541: dvander@541: //N=10 dvander@541: template dvander@541: class FastDelegate10 { dvander@541: private: dvander@541: typedef typename detail::DefaultVoidToVoid::type DesiredRetType; dvander@541: typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10); dvander@541: typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10); dvander@541: typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10); dvander@541: typedef detail::ClosurePtr ClosureType; dvander@541: ClosureType m_Closure; dvander@541: public: dvander@541: // Typedefs to aid generic programming dvander@541: typedef FastDelegate10 type; dvander@541: dvander@541: // Construction and comparison functions dvander@541: FastDelegate10() { clear(); } dvander@541: FastDelegate10(const FastDelegate10 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: void operator = (const FastDelegate10 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: bool operator ==(const FastDelegate10 &x) const { dvander@541: return m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator !=(const FastDelegate10 &x) const { dvander@541: return !m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator <(const FastDelegate10 &x) const { dvander@541: return m_Closure.IsLess(x.m_Closure); } dvander@541: bool operator >(const FastDelegate10 &x) const { dvander@541: return x.m_Closure.IsLess(m_Closure); } dvander@541: // Binding to non-const member functions dvander@541: template < class X, class Y > dvander@541: FastDelegate10(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10) ) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10)) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Binding to const member functions. dvander@541: template < class X, class Y > dvander@541: FastDelegate10(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Static functions. We convert them into a member function call. dvander@541: // This constructor also provides implicit conversion dvander@541: FastDelegate10(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10) ) { dvander@541: bind(function_to_bind); } dvander@541: // for efficiency, prevent creation of a temporary dvander@541: void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10) ) { dvander@541: bind(function_to_bind); } dvander@541: inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10)) { dvander@541: m_Closure.bindstaticfunc(this, &FastDelegate10::InvokeStaticFunction, dvander@541: function_to_bind); } dvander@541: // Invoke the delegate dvander@541: RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10) const { dvander@541: return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); } dvander@541: // Implicit conversion to "bool" using the safe_bool idiom dvander@541: private: dvander@541: typedef struct SafeBoolStruct { dvander@541: int a_data_pointer_to_this_is_0_on_buggy_compilers; dvander@541: StaticFunctionPtr m_nonzero; dvander@541: } UselessTypedef; dvander@541: typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type; dvander@541: public: dvander@541: operator unspecified_bool_type() const { dvander@541: return empty()? 0: &SafeBoolStruct::m_nonzero; dvander@541: } dvander@541: // necessary to allow ==0 to work despite the safe_bool idiom dvander@541: inline bool operator==(StaticFunctionPtr funcptr) { dvander@541: return m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator!=(StaticFunctionPtr funcptr) { dvander@541: return !m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator ! () const { // Is it bound to anything? dvander@541: return !m_Closure; } dvander@541: inline bool empty() const { dvander@541: return !m_Closure; } dvander@541: void clear() { m_Closure.clear();} dvander@541: // Conversion to and from the DelegateMemento storage class dvander@541: const DelegateMemento & GetMemento() { return m_Closure; } dvander@541: void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); } dvander@541: dvander@541: private: // Invoker for static functions dvander@541: RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10) const { dvander@541: return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); } dvander@541: }; dvander@541: dvander@541: //N=11 dvander@541: template dvander@541: class FastDelegate11 { dvander@541: private: dvander@541: typedef typename detail::DefaultVoidToVoid::type DesiredRetType; dvander@541: typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11); dvander@541: typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11); dvander@541: typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11); dvander@541: typedef detail::ClosurePtr ClosureType; dvander@541: ClosureType m_Closure; dvander@541: public: dvander@541: // Typedefs to aid generic programming dvander@541: typedef FastDelegate11 type; dvander@541: dvander@541: // Construction and comparison functions dvander@541: FastDelegate11() { clear(); } dvander@541: FastDelegate11(const FastDelegate11 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: void operator = (const FastDelegate11 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: bool operator ==(const FastDelegate11 &x) const { dvander@541: return m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator !=(const FastDelegate11 &x) const { dvander@541: return !m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator <(const FastDelegate11 &x) const { dvander@541: return m_Closure.IsLess(x.m_Closure); } dvander@541: bool operator >(const FastDelegate11 &x) const { dvander@541: return x.m_Closure.IsLess(m_Closure); } dvander@541: // Binding to non-const member functions dvander@541: template < class X, class Y > dvander@541: FastDelegate11(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11) ) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11)) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Binding to const member functions. dvander@541: template < class X, class Y > dvander@541: FastDelegate11(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Static functions. We convert them into a member function call. dvander@541: // This constructor also provides implicit conversion dvander@541: FastDelegate11(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11) ) { dvander@541: bind(function_to_bind); } dvander@541: // for efficiency, prevent creation of a temporary dvander@541: void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11) ) { dvander@541: bind(function_to_bind); } dvander@541: inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11)) { dvander@541: m_Closure.bindstaticfunc(this, &FastDelegate11::InvokeStaticFunction, dvander@541: function_to_bind); } dvander@541: // Invoke the delegate dvander@541: RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11) const { dvander@541: return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); } dvander@541: // Implicit conversion to "bool" using the safe_bool idiom dvander@541: private: dvander@541: typedef struct SafeBoolStruct { dvander@541: int a_data_pointer_to_this_is_0_on_buggy_compilers; dvander@541: StaticFunctionPtr m_nonzero; dvander@541: } UselessTypedef; dvander@541: typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type; dvander@541: public: dvander@541: operator unspecified_bool_type() const { dvander@541: return empty()? 0: &SafeBoolStruct::m_nonzero; dvander@541: } dvander@541: // necessary to allow ==0 to work despite the safe_bool idiom dvander@541: inline bool operator==(StaticFunctionPtr funcptr) { dvander@541: return m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator!=(StaticFunctionPtr funcptr) { dvander@541: return !m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator ! () const { // Is it bound to anything? dvander@541: return !m_Closure; } dvander@541: inline bool empty() const { dvander@541: return !m_Closure; } dvander@541: void clear() { m_Closure.clear();} dvander@541: // Conversion to and from the DelegateMemento storage class dvander@541: const DelegateMemento & GetMemento() { return m_Closure; } dvander@541: void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); } dvander@541: dvander@541: private: // Invoker for static functions dvander@541: RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11) const { dvander@541: return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); } dvander@541: }; dvander@541: dvander@541: //N=12 dvander@541: template dvander@541: class FastDelegate12 { dvander@541: private: dvander@541: typedef typename detail::DefaultVoidToVoid::type DesiredRetType; dvander@541: typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12); dvander@541: typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12); dvander@541: typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12); dvander@541: typedef detail::ClosurePtr ClosureType; dvander@541: ClosureType m_Closure; dvander@541: public: dvander@541: // Typedefs to aid generic programming dvander@541: typedef FastDelegate12 type; dvander@541: dvander@541: // Construction and comparison functions dvander@541: FastDelegate12() { clear(); } dvander@541: FastDelegate12(const FastDelegate12 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: void operator = (const FastDelegate12 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: bool operator ==(const FastDelegate12 &x) const { dvander@541: return m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator !=(const FastDelegate12 &x) const { dvander@541: return !m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator <(const FastDelegate12 &x) const { dvander@541: return m_Closure.IsLess(x.m_Closure); } dvander@541: bool operator >(const FastDelegate12 &x) const { dvander@541: return x.m_Closure.IsLess(m_Closure); } dvander@541: // Binding to non-const member functions dvander@541: template < class X, class Y > dvander@541: FastDelegate12(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12) ) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12)) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Binding to const member functions. dvander@541: template < class X, class Y > dvander@541: FastDelegate12(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Static functions. We convert them into a member function call. dvander@541: // This constructor also provides implicit conversion dvander@541: FastDelegate12(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12) ) { dvander@541: bind(function_to_bind); } dvander@541: // for efficiency, prevent creation of a temporary dvander@541: void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12) ) { dvander@541: bind(function_to_bind); } dvander@541: inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12)) { dvander@541: m_Closure.bindstaticfunc(this, &FastDelegate12::InvokeStaticFunction, dvander@541: function_to_bind); } dvander@541: // Invoke the delegate dvander@541: RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12) const { dvander@541: return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); } dvander@541: // Implicit conversion to "bool" using the safe_bool idiom dvander@541: private: dvander@541: typedef struct SafeBoolStruct { dvander@541: int a_data_pointer_to_this_is_0_on_buggy_compilers; dvander@541: StaticFunctionPtr m_nonzero; dvander@541: } UselessTypedef; dvander@541: typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type; dvander@541: public: dvander@541: operator unspecified_bool_type() const { dvander@541: return empty()? 0: &SafeBoolStruct::m_nonzero; dvander@541: } dvander@541: // necessary to allow ==0 to work despite the safe_bool idiom dvander@541: inline bool operator==(StaticFunctionPtr funcptr) { dvander@541: return m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator!=(StaticFunctionPtr funcptr) { dvander@541: return !m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator ! () const { // Is it bound to anything? dvander@541: return !m_Closure; } dvander@541: inline bool empty() const { dvander@541: return !m_Closure; } dvander@541: void clear() { m_Closure.clear();} dvander@541: // Conversion to and from the DelegateMemento storage class dvander@541: const DelegateMemento & GetMemento() { return m_Closure; } dvander@541: void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); } dvander@541: dvander@541: private: // Invoker for static functions dvander@541: RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12) const { dvander@541: return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); } dvander@541: }; dvander@541: dvander@541: //N=13 dvander@541: template dvander@541: class FastDelegate13 { dvander@541: private: dvander@541: typedef typename detail::DefaultVoidToVoid::type DesiredRetType; dvander@541: typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13); dvander@541: typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13); dvander@541: typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13); dvander@541: typedef detail::ClosurePtr ClosureType; dvander@541: ClosureType m_Closure; dvander@541: public: dvander@541: // Typedefs to aid generic programming dvander@541: typedef FastDelegate13 type; dvander@541: dvander@541: // Construction and comparison functions dvander@541: FastDelegate13() { clear(); } dvander@541: FastDelegate13(const FastDelegate13 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: void operator = (const FastDelegate13 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: bool operator ==(const FastDelegate13 &x) const { dvander@541: return m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator !=(const FastDelegate13 &x) const { dvander@541: return !m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator <(const FastDelegate13 &x) const { dvander@541: return m_Closure.IsLess(x.m_Closure); } dvander@541: bool operator >(const FastDelegate13 &x) const { dvander@541: return x.m_Closure.IsLess(m_Closure); } dvander@541: // Binding to non-const member functions dvander@541: template < class X, class Y > dvander@541: FastDelegate13(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13) ) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13)) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Binding to const member functions. dvander@541: template < class X, class Y > dvander@541: FastDelegate13(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Static functions. We convert them into a member function call. dvander@541: // This constructor also provides implicit conversion dvander@541: FastDelegate13(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13) ) { dvander@541: bind(function_to_bind); } dvander@541: // for efficiency, prevent creation of a temporary dvander@541: void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13) ) { dvander@541: bind(function_to_bind); } dvander@541: inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13)) { dvander@541: m_Closure.bindstaticfunc(this, &FastDelegate13::InvokeStaticFunction, dvander@541: function_to_bind); } dvander@541: // Invoke the delegate dvander@541: RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13) const { dvander@541: return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); } dvander@541: // Implicit conversion to "bool" using the safe_bool idiom dvander@541: private: dvander@541: typedef struct SafeBoolStruct { dvander@541: int a_data_pointer_to_this_is_0_on_buggy_compilers; dvander@541: StaticFunctionPtr m_nonzero; dvander@541: } UselessTypedef; dvander@541: typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type; dvander@541: public: dvander@541: operator unspecified_bool_type() const { dvander@541: return empty()? 0: &SafeBoolStruct::m_nonzero; dvander@541: } dvander@541: // necessary to allow ==0 to work despite the safe_bool idiom dvander@541: inline bool operator==(StaticFunctionPtr funcptr) { dvander@541: return m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator!=(StaticFunctionPtr funcptr) { dvander@541: return !m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator ! () const { // Is it bound to anything? dvander@541: return !m_Closure; } dvander@541: inline bool empty() const { dvander@541: return !m_Closure; } dvander@541: void clear() { m_Closure.clear();} dvander@541: // Conversion to and from the DelegateMemento storage class dvander@541: const DelegateMemento & GetMemento() { return m_Closure; } dvander@541: void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); } dvander@541: dvander@541: private: // Invoker for static functions dvander@541: RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13) const { dvander@541: return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); } dvander@541: }; dvander@541: dvander@541: //N=14 dvander@541: template dvander@541: class FastDelegate14 { dvander@541: private: dvander@541: typedef typename detail::DefaultVoidToVoid::type DesiredRetType; dvander@541: typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14); dvander@541: typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14); dvander@541: typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14); dvander@541: typedef detail::ClosurePtr ClosureType; dvander@541: ClosureType m_Closure; dvander@541: public: dvander@541: // Typedefs to aid generic programming dvander@541: typedef FastDelegate14 type; dvander@541: dvander@541: // Construction and comparison functions dvander@541: FastDelegate14() { clear(); } dvander@541: FastDelegate14(const FastDelegate14 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: void operator = (const FastDelegate14 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: bool operator ==(const FastDelegate14 &x) const { dvander@541: return m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator !=(const FastDelegate14 &x) const { dvander@541: return !m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator <(const FastDelegate14 &x) const { dvander@541: return m_Closure.IsLess(x.m_Closure); } dvander@541: bool operator >(const FastDelegate14 &x) const { dvander@541: return x.m_Closure.IsLess(m_Closure); } dvander@541: // Binding to non-const member functions dvander@541: template < class X, class Y > dvander@541: FastDelegate14(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14) ) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14)) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Binding to const member functions. dvander@541: template < class X, class Y > dvander@541: FastDelegate14(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Static functions. We convert them into a member function call. dvander@541: // This constructor also provides implicit conversion dvander@541: FastDelegate14(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14) ) { dvander@541: bind(function_to_bind); } dvander@541: // for efficiency, prevent creation of a temporary dvander@541: void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14) ) { dvander@541: bind(function_to_bind); } dvander@541: inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14)) { dvander@541: m_Closure.bindstaticfunc(this, &FastDelegate14::InvokeStaticFunction, dvander@541: function_to_bind); } dvander@541: // Invoke the delegate dvander@541: RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14) const { dvander@541: return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); } dvander@541: // Implicit conversion to "bool" using the safe_bool idiom dvander@541: private: dvander@541: typedef struct SafeBoolStruct { dvander@541: int a_data_pointer_to_this_is_0_on_buggy_compilers; dvander@541: StaticFunctionPtr m_nonzero; dvander@541: } UselessTypedef; dvander@541: typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type; dvander@541: public: dvander@541: operator unspecified_bool_type() const { dvander@541: return empty()? 0: &SafeBoolStruct::m_nonzero; dvander@541: } dvander@541: // necessary to allow ==0 to work despite the safe_bool idiom dvander@541: inline bool operator==(StaticFunctionPtr funcptr) { dvander@541: return m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator!=(StaticFunctionPtr funcptr) { dvander@541: return !m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator ! () const { // Is it bound to anything? dvander@541: return !m_Closure; } dvander@541: inline bool empty() const { dvander@541: return !m_Closure; } dvander@541: void clear() { m_Closure.clear();} dvander@541: // Conversion to and from the DelegateMemento storage class dvander@541: const DelegateMemento & GetMemento() { return m_Closure; } dvander@541: void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); } dvander@541: dvander@541: private: // Invoker for static functions dvander@541: RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14) const { dvander@541: return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); } dvander@541: }; dvander@541: dvander@541: //N=15 dvander@541: template dvander@541: class FastDelegate15 { dvander@541: private: dvander@541: typedef typename detail::DefaultVoidToVoid::type DesiredRetType; dvander@541: typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15); dvander@541: typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15); dvander@541: typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15); dvander@541: typedef detail::ClosurePtr ClosureType; dvander@541: ClosureType m_Closure; dvander@541: public: dvander@541: // Typedefs to aid generic programming dvander@541: typedef FastDelegate15 type; dvander@541: dvander@541: // Construction and comparison functions dvander@541: FastDelegate15() { clear(); } dvander@541: FastDelegate15(const FastDelegate15 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: void operator = (const FastDelegate15 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: bool operator ==(const FastDelegate15 &x) const { dvander@541: return m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator !=(const FastDelegate15 &x) const { dvander@541: return !m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator <(const FastDelegate15 &x) const { dvander@541: return m_Closure.IsLess(x.m_Closure); } dvander@541: bool operator >(const FastDelegate15 &x) const { dvander@541: return x.m_Closure.IsLess(m_Closure); } dvander@541: // Binding to non-const member functions dvander@541: template < class X, class Y > dvander@541: FastDelegate15(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15) ) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15)) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Binding to const member functions. dvander@541: template < class X, class Y > dvander@541: FastDelegate15(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Static functions. We convert them into a member function call. dvander@541: // This constructor also provides implicit conversion dvander@541: FastDelegate15(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15) ) { dvander@541: bind(function_to_bind); } dvander@541: // for efficiency, prevent creation of a temporary dvander@541: void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15) ) { dvander@541: bind(function_to_bind); } dvander@541: inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15)) { dvander@541: m_Closure.bindstaticfunc(this, &FastDelegate15::InvokeStaticFunction, dvander@541: function_to_bind); } dvander@541: // Invoke the delegate dvander@541: RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15) const { dvander@541: return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); } dvander@541: // Implicit conversion to "bool" using the safe_bool idiom dvander@541: private: dvander@541: typedef struct SafeBoolStruct { dvander@541: int a_data_pointer_to_this_is_0_on_buggy_compilers; dvander@541: StaticFunctionPtr m_nonzero; dvander@541: } UselessTypedef; dvander@541: typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type; dvander@541: public: dvander@541: operator unspecified_bool_type() const { dvander@541: return empty()? 0: &SafeBoolStruct::m_nonzero; dvander@541: } dvander@541: // necessary to allow ==0 to work despite the safe_bool idiom dvander@541: inline bool operator==(StaticFunctionPtr funcptr) { dvander@541: return m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator!=(StaticFunctionPtr funcptr) { dvander@541: return !m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator ! () const { // Is it bound to anything? dvander@541: return !m_Closure; } dvander@541: inline bool empty() const { dvander@541: return !m_Closure; } dvander@541: void clear() { m_Closure.clear();} dvander@541: // Conversion to and from the DelegateMemento storage class dvander@541: const DelegateMemento & GetMemento() { return m_Closure; } dvander@541: void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); } dvander@541: dvander@541: private: // Invoker for static functions dvander@541: RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15) const { dvander@541: return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); } dvander@541: }; dvander@541: dvander@541: //N=16 dvander@541: template dvander@541: class FastDelegate16 { dvander@541: private: dvander@541: typedef typename detail::DefaultVoidToVoid::type DesiredRetType; dvander@541: typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16); dvander@541: typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16); dvander@541: typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16); dvander@541: typedef detail::ClosurePtr ClosureType; dvander@541: ClosureType m_Closure; dvander@541: public: dvander@541: // Typedefs to aid generic programming dvander@541: typedef FastDelegate16 type; dvander@541: dvander@541: // Construction and comparison functions dvander@541: FastDelegate16() { clear(); } dvander@541: FastDelegate16(const FastDelegate16 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: void operator = (const FastDelegate16 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: bool operator ==(const FastDelegate16 &x) const { dvander@541: return m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator !=(const FastDelegate16 &x) const { dvander@541: return !m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator <(const FastDelegate16 &x) const { dvander@541: return m_Closure.IsLess(x.m_Closure); } dvander@541: bool operator >(const FastDelegate16 &x) const { dvander@541: return x.m_Closure.IsLess(m_Closure); } dvander@541: // Binding to non-const member functions dvander@541: template < class X, class Y > dvander@541: FastDelegate16(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16) ) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16)) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Binding to const member functions. dvander@541: template < class X, class Y > dvander@541: FastDelegate16(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Static functions. We convert them into a member function call. dvander@541: // This constructor also provides implicit conversion dvander@541: FastDelegate16(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16) ) { dvander@541: bind(function_to_bind); } dvander@541: // for efficiency, prevent creation of a temporary dvander@541: void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16) ) { dvander@541: bind(function_to_bind); } dvander@541: inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16)) { dvander@541: m_Closure.bindstaticfunc(this, &FastDelegate16::InvokeStaticFunction, dvander@541: function_to_bind); } dvander@541: // Invoke the delegate dvander@541: RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16) const { dvander@541: return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16); } dvander@541: // Implicit conversion to "bool" using the safe_bool idiom dvander@541: private: dvander@541: typedef struct SafeBoolStruct { dvander@541: int a_data_pointer_to_this_is_0_on_buggy_compilers; dvander@541: StaticFunctionPtr m_nonzero; dvander@541: } UselessTypedef; dvander@541: typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type; dvander@541: public: dvander@541: operator unspecified_bool_type() const { dvander@541: return empty()? 0: &SafeBoolStruct::m_nonzero; dvander@541: } dvander@541: // necessary to allow ==0 to work despite the safe_bool idiom dvander@541: inline bool operator==(StaticFunctionPtr funcptr) { dvander@541: return m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator!=(StaticFunctionPtr funcptr) { dvander@541: return !m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator ! () const { // Is it bound to anything? dvander@541: return !m_Closure; } dvander@541: inline bool empty() const { dvander@541: return !m_Closure; } dvander@541: void clear() { m_Closure.clear();} dvander@541: // Conversion to and from the DelegateMemento storage class dvander@541: const DelegateMemento & GetMemento() { return m_Closure; } dvander@541: void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); } dvander@541: dvander@541: private: // Invoker for static functions dvander@541: RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16) const { dvander@541: return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16); } dvander@541: }; dvander@541: dvander@541: //N=17 dvander@541: template dvander@541: class FastDelegate17 { dvander@541: private: dvander@541: typedef typename detail::DefaultVoidToVoid::type DesiredRetType; dvander@541: typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17); dvander@541: typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17); dvander@541: typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17); dvander@541: typedef detail::ClosurePtr ClosureType; dvander@541: ClosureType m_Closure; dvander@541: public: dvander@541: // Typedefs to aid generic programming dvander@541: typedef FastDelegate17 type; dvander@541: dvander@541: // Construction and comparison functions dvander@541: FastDelegate17() { clear(); } dvander@541: FastDelegate17(const FastDelegate17 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: void operator = (const FastDelegate17 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: bool operator ==(const FastDelegate17 &x) const { dvander@541: return m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator !=(const FastDelegate17 &x) const { dvander@541: return !m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator <(const FastDelegate17 &x) const { dvander@541: return m_Closure.IsLess(x.m_Closure); } dvander@541: bool operator >(const FastDelegate17 &x) const { dvander@541: return x.m_Closure.IsLess(m_Closure); } dvander@541: // Binding to non-const member functions dvander@541: template < class X, class Y > dvander@541: FastDelegate17(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17) ) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17)) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Binding to const member functions. dvander@541: template < class X, class Y > dvander@541: FastDelegate17(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Static functions. We convert them into a member function call. dvander@541: // This constructor also provides implicit conversion dvander@541: FastDelegate17(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17) ) { dvander@541: bind(function_to_bind); } dvander@541: // for efficiency, prevent creation of a temporary dvander@541: void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17) ) { dvander@541: bind(function_to_bind); } dvander@541: inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17)) { dvander@541: m_Closure.bindstaticfunc(this, &FastDelegate17::InvokeStaticFunction, dvander@541: function_to_bind); } dvander@541: // Invoke the delegate dvander@541: RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17) const { dvander@541: return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17); } dvander@541: // Implicit conversion to "bool" using the safe_bool idiom dvander@541: private: dvander@541: typedef struct SafeBoolStruct { dvander@541: int a_data_pointer_to_this_is_0_on_buggy_compilers; dvander@541: StaticFunctionPtr m_nonzero; dvander@541: } UselessTypedef; dvander@541: typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type; dvander@541: public: dvander@541: operator unspecified_bool_type() const { dvander@541: return empty()? 0: &SafeBoolStruct::m_nonzero; dvander@541: } dvander@541: // necessary to allow ==0 to work despite the safe_bool idiom dvander@541: inline bool operator==(StaticFunctionPtr funcptr) { dvander@541: return m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator!=(StaticFunctionPtr funcptr) { dvander@541: return !m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator ! () const { // Is it bound to anything? dvander@541: return !m_Closure; } dvander@541: inline bool empty() const { dvander@541: return !m_Closure; } dvander@541: void clear() { m_Closure.clear();} dvander@541: // Conversion to and from the DelegateMemento storage class dvander@541: const DelegateMemento & GetMemento() { return m_Closure; } dvander@541: void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); } dvander@541: dvander@541: private: // Invoker for static functions dvander@541: RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17) const { dvander@541: return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17); } dvander@541: }; dvander@541: dvander@541: //N=18 dvander@541: template dvander@541: class FastDelegate18 { dvander@541: private: dvander@541: typedef typename detail::DefaultVoidToVoid::type DesiredRetType; dvander@541: typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18); dvander@541: typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18); dvander@541: typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18); dvander@541: typedef detail::ClosurePtr ClosureType; dvander@541: ClosureType m_Closure; dvander@541: public: dvander@541: // Typedefs to aid generic programming dvander@541: typedef FastDelegate18 type; dvander@541: dvander@541: // Construction and comparison functions dvander@541: FastDelegate18() { clear(); } dvander@541: FastDelegate18(const FastDelegate18 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: void operator = (const FastDelegate18 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: bool operator ==(const FastDelegate18 &x) const { dvander@541: return m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator !=(const FastDelegate18 &x) const { dvander@541: return !m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator <(const FastDelegate18 &x) const { dvander@541: return m_Closure.IsLess(x.m_Closure); } dvander@541: bool operator >(const FastDelegate18 &x) const { dvander@541: return x.m_Closure.IsLess(m_Closure); } dvander@541: // Binding to non-const member functions dvander@541: template < class X, class Y > dvander@541: FastDelegate18(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18) ) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18)) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Binding to const member functions. dvander@541: template < class X, class Y > dvander@541: FastDelegate18(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Static functions. We convert them into a member function call. dvander@541: // This constructor also provides implicit conversion dvander@541: FastDelegate18(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18) ) { dvander@541: bind(function_to_bind); } dvander@541: // for efficiency, prevent creation of a temporary dvander@541: void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18) ) { dvander@541: bind(function_to_bind); } dvander@541: inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18)) { dvander@541: m_Closure.bindstaticfunc(this, &FastDelegate18::InvokeStaticFunction, dvander@541: function_to_bind); } dvander@541: // Invoke the delegate dvander@541: RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18) const { dvander@541: return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18); } dvander@541: // Implicit conversion to "bool" using the safe_bool idiom dvander@541: private: dvander@541: typedef struct SafeBoolStruct { dvander@541: int a_data_pointer_to_this_is_0_on_buggy_compilers; dvander@541: StaticFunctionPtr m_nonzero; dvander@541: } UselessTypedef; dvander@541: typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type; dvander@541: public: dvander@541: operator unspecified_bool_type() const { dvander@541: return empty()? 0: &SafeBoolStruct::m_nonzero; dvander@541: } dvander@541: // necessary to allow ==0 to work despite the safe_bool idiom dvander@541: inline bool operator==(StaticFunctionPtr funcptr) { dvander@541: return m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator!=(StaticFunctionPtr funcptr) { dvander@541: return !m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator ! () const { // Is it bound to anything? dvander@541: return !m_Closure; } dvander@541: inline bool empty() const { dvander@541: return !m_Closure; } dvander@541: void clear() { m_Closure.clear();} dvander@541: // Conversion to and from the DelegateMemento storage class dvander@541: const DelegateMemento & GetMemento() { return m_Closure; } dvander@541: void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); } dvander@541: dvander@541: private: // Invoker for static functions dvander@541: RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18) const { dvander@541: return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18); } dvander@541: }; dvander@541: dvander@541: //N=19 dvander@541: template dvander@541: class FastDelegate19 { dvander@541: private: dvander@541: typedef typename detail::DefaultVoidToVoid::type DesiredRetType; dvander@541: typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19); dvander@541: typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19); dvander@541: typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19); dvander@541: typedef detail::ClosurePtr ClosureType; dvander@541: ClosureType m_Closure; dvander@541: public: dvander@541: // Typedefs to aid generic programming dvander@541: typedef FastDelegate19 type; dvander@541: dvander@541: // Construction and comparison functions dvander@541: FastDelegate19() { clear(); } dvander@541: FastDelegate19(const FastDelegate19 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: void operator = (const FastDelegate19 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: bool operator ==(const FastDelegate19 &x) const { dvander@541: return m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator !=(const FastDelegate19 &x) const { dvander@541: return !m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator <(const FastDelegate19 &x) const { dvander@541: return m_Closure.IsLess(x.m_Closure); } dvander@541: bool operator >(const FastDelegate19 &x) const { dvander@541: return x.m_Closure.IsLess(m_Closure); } dvander@541: // Binding to non-const member functions dvander@541: template < class X, class Y > dvander@541: FastDelegate19(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19) ) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19)) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Binding to const member functions. dvander@541: template < class X, class Y > dvander@541: FastDelegate19(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Static functions. We convert them into a member function call. dvander@541: // This constructor also provides implicit conversion dvander@541: FastDelegate19(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19) ) { dvander@541: bind(function_to_bind); } dvander@541: // for efficiency, prevent creation of a temporary dvander@541: void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19) ) { dvander@541: bind(function_to_bind); } dvander@541: inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19)) { dvander@541: m_Closure.bindstaticfunc(this, &FastDelegate19::InvokeStaticFunction, dvander@541: function_to_bind); } dvander@541: // Invoke the delegate dvander@541: RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19) const { dvander@541: return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19); } dvander@541: // Implicit conversion to "bool" using the safe_bool idiom dvander@541: private: dvander@541: typedef struct SafeBoolStruct { dvander@541: int a_data_pointer_to_this_is_0_on_buggy_compilers; dvander@541: StaticFunctionPtr m_nonzero; dvander@541: } UselessTypedef; dvander@541: typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type; dvander@541: public: dvander@541: operator unspecified_bool_type() const { dvander@541: return empty()? 0: &SafeBoolStruct::m_nonzero; dvander@541: } dvander@541: // necessary to allow ==0 to work despite the safe_bool idiom dvander@541: inline bool operator==(StaticFunctionPtr funcptr) { dvander@541: return m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator!=(StaticFunctionPtr funcptr) { dvander@541: return !m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator ! () const { // Is it bound to anything? dvander@541: return !m_Closure; } dvander@541: inline bool empty() const { dvander@541: return !m_Closure; } dvander@541: void clear() { m_Closure.clear();} dvander@541: // Conversion to and from the DelegateMemento storage class dvander@541: const DelegateMemento & GetMemento() { return m_Closure; } dvander@541: void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); } dvander@541: dvander@541: private: // Invoker for static functions dvander@541: RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19) const { dvander@541: return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19); } dvander@541: }; dvander@541: dvander@541: //N=20 dvander@541: template dvander@541: class FastDelegate20 { dvander@541: private: dvander@541: typedef typename detail::DefaultVoidToVoid::type DesiredRetType; dvander@541: typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19, Param20 p20); dvander@541: typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19, Param20 p20); dvander@541: typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19, Param20 p20); dvander@541: typedef detail::ClosurePtr ClosureType; dvander@541: ClosureType m_Closure; dvander@541: public: dvander@541: // Typedefs to aid generic programming dvander@541: typedef FastDelegate20 type; dvander@541: dvander@541: // Construction and comparison functions dvander@541: FastDelegate20() { clear(); } dvander@541: FastDelegate20(const FastDelegate20 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: void operator = (const FastDelegate20 &x) { dvander@541: m_Closure.CopyFrom(this, x.m_Closure); } dvander@541: bool operator ==(const FastDelegate20 &x) const { dvander@541: return m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator !=(const FastDelegate20 &x) const { dvander@541: return !m_Closure.IsEqual(x.m_Closure); } dvander@541: bool operator <(const FastDelegate20 &x) const { dvander@541: return m_Closure.IsLess(x.m_Closure); } dvander@541: bool operator >(const FastDelegate20 &x) const { dvander@541: return x.m_Closure.IsLess(m_Closure); } dvander@541: // Binding to non-const member functions dvander@541: template < class X, class Y > dvander@541: FastDelegate20(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19, Param20 p20) ) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19, Param20 p20)) { dvander@541: m_Closure.bindmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Binding to const member functions. dvander@541: template < class X, class Y > dvander@541: FastDelegate20(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19, Param20 p20) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: template < class X, class Y > dvander@541: inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19, Param20 p20) const) { dvander@541: m_Closure.bindconstmemfunc(detail::implicit_cast(pthis), function_to_bind); } dvander@541: // Static functions. We convert them into a member function call. dvander@541: // This constructor also provides implicit conversion dvander@541: FastDelegate20(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19, Param20 p20) ) { dvander@541: bind(function_to_bind); } dvander@541: // for efficiency, prevent creation of a temporary dvander@541: void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19, Param20 p20) ) { dvander@541: bind(function_to_bind); } dvander@541: inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19, Param20 p20)) { dvander@541: m_Closure.bindstaticfunc(this, &FastDelegate20::InvokeStaticFunction, dvander@541: function_to_bind); } dvander@541: // Invoke the delegate dvander@541: RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19, Param20 p20) const { dvander@541: return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20); } dvander@541: // Implicit conversion to "bool" using the safe_bool idiom dvander@541: private: dvander@541: typedef struct SafeBoolStruct { dvander@541: int a_data_pointer_to_this_is_0_on_buggy_compilers; dvander@541: StaticFunctionPtr m_nonzero; dvander@541: } UselessTypedef; dvander@541: typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type; dvander@541: public: dvander@541: operator unspecified_bool_type() const { dvander@541: return empty()? 0: &SafeBoolStruct::m_nonzero; dvander@541: } dvander@541: // necessary to allow ==0 to work despite the safe_bool idiom dvander@541: inline bool operator==(StaticFunctionPtr funcptr) { dvander@541: return m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator!=(StaticFunctionPtr funcptr) { dvander@541: return !m_Closure.IsEqualToStaticFuncPtr(funcptr); } dvander@541: inline bool operator ! () const { // Is it bound to anything? dvander@541: return !m_Closure; } dvander@541: inline bool empty() const { dvander@541: return !m_Closure; } dvander@541: void clear() { m_Closure.clear();} dvander@541: // Conversion to and from the DelegateMemento storage class dvander@541: const DelegateMemento & GetMemento() { return m_Closure; } dvander@541: void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); } dvander@541: dvander@541: private: // Invoker for static functions dvander@541: RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19, Param20 p20) const { dvander@541: return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20); } dvander@541: }; dvander@541: dvander@541: dvander@541: //////////////////////////////////////////////////////////////////////////////// dvander@541: // Fast Delegates, part 4: dvander@541: // dvander@541: // FastDelegate<> class (Original author: Jody Hagins) dvander@541: // Allows boost::function style syntax like: dvander@541: // FastDelegate< double (int, long) > dvander@541: // instead of: dvander@541: // FastDelegate2< int, long, double > dvander@541: // dvander@541: //////////////////////////////////////////////////////////////////////////////// dvander@541: dvander@541: #ifdef FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX dvander@541: dvander@541: // Declare FastDelegate as a class template. It will be specialized dvander@541: // later for all number of arguments. dvander@541: template dvander@541: class FastDelegate; dvander@541: dvander@541: //N=0 dvander@541: // Specialization to allow use of dvander@541: // FastDelegate< R ( ) > dvander@541: // instead of dvander@541: // FastDelegate0 < R > dvander@541: template dvander@541: class FastDelegate< R ( ) > dvander@541: // Inherit from FastDelegate0 so that it can be treated just like a FastDelegate0 dvander@541: : public FastDelegate0 < R > dvander@541: { dvander@541: public: dvander@541: // Make using the base type a bit easier via typedef. dvander@541: typedef FastDelegate0 < R > BaseType; dvander@541: dvander@541: // Allow users access to the specific type of this delegate. dvander@541: typedef FastDelegate SelfType; dvander@541: dvander@541: // Mimic the base class constructors. dvander@541: FastDelegate() : BaseType() { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(Y * pthis, dvander@541: R (X::* function_to_bind)( )) dvander@541: : BaseType(pthis, function_to_bind) { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(const Y *pthis, dvander@541: R (X::* function_to_bind)( ) const) dvander@541: : BaseType(pthis, function_to_bind) dvander@541: { } dvander@541: dvander@541: FastDelegate(R (*function_to_bind)( )) dvander@541: : BaseType(function_to_bind) { } dvander@541: void operator = (const BaseType &x) { dvander@541: *static_cast(this) = x; } dvander@541: }; dvander@541: dvander@541: //N=1 dvander@541: // Specialization to allow use of dvander@541: // FastDelegate< R ( Param1 ) > dvander@541: // instead of dvander@541: // FastDelegate1 < Param1, R > dvander@541: template dvander@541: class FastDelegate< R ( Param1 ) > dvander@541: // Inherit from FastDelegate1 so that it can be treated just like a FastDelegate1 dvander@541: : public FastDelegate1 < Param1, R > dvander@541: { dvander@541: public: dvander@541: // Make using the base type a bit easier via typedef. dvander@541: typedef FastDelegate1 < Param1, R > BaseType; dvander@541: dvander@541: // Allow users access to the specific type of this delegate. dvander@541: typedef FastDelegate SelfType; dvander@541: dvander@541: // Mimic the base class constructors. dvander@541: FastDelegate() : BaseType() { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(Y * pthis, dvander@541: R (X::* function_to_bind)( Param1 p1 )) dvander@541: : BaseType(pthis, function_to_bind) { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(const Y *pthis, dvander@541: R (X::* function_to_bind)( Param1 p1 ) const) dvander@541: : BaseType(pthis, function_to_bind) dvander@541: { } dvander@541: dvander@541: FastDelegate(R (*function_to_bind)( Param1 p1 )) dvander@541: : BaseType(function_to_bind) { } dvander@541: void operator = (const BaseType &x) { dvander@541: *static_cast(this) = x; } dvander@541: }; dvander@541: dvander@541: //N=2 dvander@541: // Specialization to allow use of dvander@541: // FastDelegate< R ( Param1, Param2 ) > dvander@541: // instead of dvander@541: // FastDelegate2 < Param1, Param2, R > dvander@541: template dvander@541: class FastDelegate< R ( Param1, Param2 ) > dvander@541: // Inherit from FastDelegate2 so that it can be treated just like a FastDelegate2 dvander@541: : public FastDelegate2 < Param1, Param2, R > dvander@541: { dvander@541: public: dvander@541: // Make using the base type a bit easier via typedef. dvander@541: typedef FastDelegate2 < Param1, Param2, R > BaseType; dvander@541: dvander@541: // Allow users access to the specific type of this delegate. dvander@541: typedef FastDelegate SelfType; dvander@541: dvander@541: // Mimic the base class constructors. dvander@541: FastDelegate() : BaseType() { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(Y * pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2 )) dvander@541: : BaseType(pthis, function_to_bind) { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(const Y *pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2 ) const) dvander@541: : BaseType(pthis, function_to_bind) dvander@541: { } dvander@541: dvander@541: FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2 )) dvander@541: : BaseType(function_to_bind) { } dvander@541: void operator = (const BaseType &x) { dvander@541: *static_cast(this) = x; } dvander@541: }; dvander@541: dvander@541: //N=3 dvander@541: // Specialization to allow use of dvander@541: // FastDelegate< R ( Param1, Param2, Param3 ) > dvander@541: // instead of dvander@541: // FastDelegate3 < Param1, Param2, Param3, R > dvander@541: template dvander@541: class FastDelegate< R ( Param1, Param2, Param3 ) > dvander@541: // Inherit from FastDelegate3 so that it can be treated just like a FastDelegate3 dvander@541: : public FastDelegate3 < Param1, Param2, Param3, R > dvander@541: { dvander@541: public: dvander@541: // Make using the base type a bit easier via typedef. dvander@541: typedef FastDelegate3 < Param1, Param2, Param3, R > BaseType; dvander@541: dvander@541: // Allow users access to the specific type of this delegate. dvander@541: typedef FastDelegate SelfType; dvander@541: dvander@541: // Mimic the base class constructors. dvander@541: FastDelegate() : BaseType() { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(Y * pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3 )) dvander@541: : BaseType(pthis, function_to_bind) { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(const Y *pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3 ) const) dvander@541: : BaseType(pthis, function_to_bind) dvander@541: { } dvander@541: dvander@541: FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3 )) dvander@541: : BaseType(function_to_bind) { } dvander@541: void operator = (const BaseType &x) { dvander@541: *static_cast(this) = x; } dvander@541: }; dvander@541: dvander@541: //N=4 dvander@541: // Specialization to allow use of dvander@541: // FastDelegate< R ( Param1, Param2, Param3, Param4 ) > dvander@541: // instead of dvander@541: // FastDelegate4 < Param1, Param2, Param3, Param4, R > dvander@541: template dvander@541: class FastDelegate< R ( Param1, Param2, Param3, Param4 ) > dvander@541: // Inherit from FastDelegate4 so that it can be treated just like a FastDelegate4 dvander@541: : public FastDelegate4 < Param1, Param2, Param3, Param4, R > dvander@541: { dvander@541: public: dvander@541: // Make using the base type a bit easier via typedef. dvander@541: typedef FastDelegate4 < Param1, Param2, Param3, Param4, R > BaseType; dvander@541: dvander@541: // Allow users access to the specific type of this delegate. dvander@541: typedef FastDelegate SelfType; dvander@541: dvander@541: // Mimic the base class constructors. dvander@541: FastDelegate() : BaseType() { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(Y * pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4 )) dvander@541: : BaseType(pthis, function_to_bind) { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(const Y *pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4 ) const) dvander@541: : BaseType(pthis, function_to_bind) dvander@541: { } dvander@541: dvander@541: FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4 )) dvander@541: : BaseType(function_to_bind) { } dvander@541: void operator = (const BaseType &x) { dvander@541: *static_cast(this) = x; } dvander@541: }; dvander@541: dvander@541: //N=5 dvander@541: // Specialization to allow use of dvander@541: // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5 ) > dvander@541: // instead of dvander@541: // FastDelegate5 < Param1, Param2, Param3, Param4, Param5, R > dvander@541: template dvander@541: class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5 ) > dvander@541: // Inherit from FastDelegate5 so that it can be treated just like a FastDelegate5 dvander@541: : public FastDelegate5 < Param1, Param2, Param3, Param4, Param5, R > dvander@541: { dvander@541: public: dvander@541: // Make using the base type a bit easier via typedef. dvander@541: typedef FastDelegate5 < Param1, Param2, Param3, Param4, Param5, R > BaseType; dvander@541: dvander@541: // Allow users access to the specific type of this delegate. dvander@541: typedef FastDelegate SelfType; dvander@541: dvander@541: // Mimic the base class constructors. dvander@541: FastDelegate() : BaseType() { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(Y * pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5 )) dvander@541: : BaseType(pthis, function_to_bind) { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(const Y *pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5 ) const) dvander@541: : BaseType(pthis, function_to_bind) dvander@541: { } dvander@541: dvander@541: FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5 )) dvander@541: : BaseType(function_to_bind) { } dvander@541: void operator = (const BaseType &x) { dvander@541: *static_cast(this) = x; } dvander@541: }; dvander@541: dvander@541: //N=6 dvander@541: // Specialization to allow use of dvander@541: // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6 ) > dvander@541: // instead of dvander@541: // FastDelegate6 < Param1, Param2, Param3, Param4, Param5, Param6, R > dvander@541: template dvander@541: class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6 ) > dvander@541: // Inherit from FastDelegate6 so that it can be treated just like a FastDelegate6 dvander@541: : public FastDelegate6 < Param1, Param2, Param3, Param4, Param5, Param6, R > dvander@541: { dvander@541: public: dvander@541: // Make using the base type a bit easier via typedef. dvander@541: typedef FastDelegate6 < Param1, Param2, Param3, Param4, Param5, Param6, R > BaseType; dvander@541: dvander@541: // Allow users access to the specific type of this delegate. dvander@541: typedef FastDelegate SelfType; dvander@541: dvander@541: // Mimic the base class constructors. dvander@541: FastDelegate() : BaseType() { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(Y * pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6 )) dvander@541: : BaseType(pthis, function_to_bind) { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(const Y *pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6 ) const) dvander@541: : BaseType(pthis, function_to_bind) dvander@541: { } dvander@541: dvander@541: FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6 )) dvander@541: : BaseType(function_to_bind) { } dvander@541: void operator = (const BaseType &x) { dvander@541: *static_cast(this) = x; } dvander@541: }; dvander@541: dvander@541: //N=7 dvander@541: // Specialization to allow use of dvander@541: // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7 ) > dvander@541: // instead of dvander@541: // FastDelegate7 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, R > dvander@541: template dvander@541: class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7 ) > dvander@541: // Inherit from FastDelegate7 so that it can be treated just like a FastDelegate7 dvander@541: : public FastDelegate7 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, R > dvander@541: { dvander@541: public: dvander@541: // Make using the base type a bit easier via typedef. dvander@541: typedef FastDelegate7 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, R > BaseType; dvander@541: dvander@541: // Allow users access to the specific type of this delegate. dvander@541: typedef FastDelegate SelfType; dvander@541: dvander@541: // Mimic the base class constructors. dvander@541: FastDelegate() : BaseType() { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(Y * pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7 )) dvander@541: : BaseType(pthis, function_to_bind) { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(const Y *pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7 ) const) dvander@541: : BaseType(pthis, function_to_bind) dvander@541: { } dvander@541: dvander@541: FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7 )) dvander@541: : BaseType(function_to_bind) { } dvander@541: void operator = (const BaseType &x) { dvander@541: *static_cast(this) = x; } dvander@541: }; dvander@541: dvander@541: //N=8 dvander@541: // Specialization to allow use of dvander@541: // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8 ) > dvander@541: // instead of dvander@541: // FastDelegate8 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, R > dvander@541: template dvander@541: class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8 ) > dvander@541: // Inherit from FastDelegate8 so that it can be treated just like a FastDelegate8 dvander@541: : public FastDelegate8 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, R > dvander@541: { dvander@541: public: dvander@541: // Make using the base type a bit easier via typedef. dvander@541: typedef FastDelegate8 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, R > BaseType; dvander@541: dvander@541: // Allow users access to the specific type of this delegate. dvander@541: typedef FastDelegate SelfType; dvander@541: dvander@541: // Mimic the base class constructors. dvander@541: FastDelegate() : BaseType() { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(Y * pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8 )) dvander@541: : BaseType(pthis, function_to_bind) { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(const Y *pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8 ) const) dvander@541: : BaseType(pthis, function_to_bind) dvander@541: { } dvander@541: dvander@541: FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8 )) dvander@541: : BaseType(function_to_bind) { } dvander@541: void operator = (const BaseType &x) { dvander@541: *static_cast(this) = x; } dvander@541: }; dvander@541: dvander@541: //N=9 dvander@541: // Specialization to allow use of dvander@541: // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9 ) > dvander@541: // instead of dvander@541: // FastDelegate9 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, R > dvander@541: template dvander@541: class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9 ) > dvander@541: // Inherit from FastDelegate9 so that it can be treated just like a FastDelegate9 dvander@541: : public FastDelegate9 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, R > dvander@541: { dvander@541: public: dvander@541: // Make using the base type a bit easier via typedef. dvander@541: typedef FastDelegate9 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, R > BaseType; dvander@541: dvander@541: // Allow users access to the specific type of this delegate. dvander@541: typedef FastDelegate SelfType; dvander@541: dvander@541: // Mimic the base class constructors. dvander@541: FastDelegate() : BaseType() { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(Y * pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9 )) dvander@541: : BaseType(pthis, function_to_bind) { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(const Y *pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9 ) const) dvander@541: : BaseType(pthis, function_to_bind) dvander@541: { } dvander@541: dvander@541: FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9 )) dvander@541: : BaseType(function_to_bind) { } dvander@541: void operator = (const BaseType &x) { dvander@541: *static_cast(this) = x; } dvander@541: }; dvander@541: dvander@541: //N=10 dvander@541: // Specialization to allow use of dvander@541: // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10 ) > dvander@541: // instead of dvander@541: // FastDelegate10 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, R > dvander@541: template dvander@541: class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10 ) > dvander@541: // Inherit from FastDelegate10 so that it can be treated just like a FastDelegate10 dvander@541: : public FastDelegate10 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, R > dvander@541: { dvander@541: public: dvander@541: // Make using the base type a bit easier via typedef. dvander@541: typedef FastDelegate10 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, R > BaseType; dvander@541: dvander@541: // Allow users access to the specific type of this delegate. dvander@541: typedef FastDelegate SelfType; dvander@541: dvander@541: // Mimic the base class constructors. dvander@541: FastDelegate() : BaseType() { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(Y * pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10 )) dvander@541: : BaseType(pthis, function_to_bind) { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(const Y *pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10 ) const) dvander@541: : BaseType(pthis, function_to_bind) dvander@541: { } dvander@541: dvander@541: FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10 )) dvander@541: : BaseType(function_to_bind) { } dvander@541: void operator = (const BaseType &x) { dvander@541: *static_cast(this) = x; } dvander@541: }; dvander@541: dvander@541: //N=11 dvander@541: // Specialization to allow use of dvander@541: // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11 ) > dvander@541: // instead of dvander@541: // FastDelegate11 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, R > dvander@541: template dvander@541: class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11 ) > dvander@541: // Inherit from FastDelegate11 so that it can be treated just like a FastDelegate11 dvander@541: : public FastDelegate11 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, R > dvander@541: { dvander@541: public: dvander@541: // Make using the base type a bit easier via typedef. dvander@541: typedef FastDelegate11 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, R > BaseType; dvander@541: dvander@541: // Allow users access to the specific type of this delegate. dvander@541: typedef FastDelegate SelfType; dvander@541: dvander@541: // Mimic the base class constructors. dvander@541: FastDelegate() : BaseType() { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(Y * pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11 )) dvander@541: : BaseType(pthis, function_to_bind) { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(const Y *pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11 ) const) dvander@541: : BaseType(pthis, function_to_bind) dvander@541: { } dvander@541: dvander@541: FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11 )) dvander@541: : BaseType(function_to_bind) { } dvander@541: void operator = (const BaseType &x) { dvander@541: *static_cast(this) = x; } dvander@541: }; dvander@541: dvander@541: //N=12 dvander@541: // Specialization to allow use of dvander@541: // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12 ) > dvander@541: // instead of dvander@541: // FastDelegate12 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, R > dvander@541: template dvander@541: class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12 ) > dvander@541: // Inherit from FastDelegate12 so that it can be treated just like a FastDelegate12 dvander@541: : public FastDelegate12 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, R > dvander@541: { dvander@541: public: dvander@541: // Make using the base type a bit easier via typedef. dvander@541: typedef FastDelegate12 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, R > BaseType; dvander@541: dvander@541: // Allow users access to the specific type of this delegate. dvander@541: typedef FastDelegate SelfType; dvander@541: dvander@541: // Mimic the base class constructors. dvander@541: FastDelegate() : BaseType() { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(Y * pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12 )) dvander@541: : BaseType(pthis, function_to_bind) { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(const Y *pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12 ) const) dvander@541: : BaseType(pthis, function_to_bind) dvander@541: { } dvander@541: dvander@541: FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12 )) dvander@541: : BaseType(function_to_bind) { } dvander@541: void operator = (const BaseType &x) { dvander@541: *static_cast(this) = x; } dvander@541: }; dvander@541: dvander@541: //N=13 dvander@541: // Specialization to allow use of dvander@541: // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13 ) > dvander@541: // instead of dvander@541: // FastDelegate13 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, R > dvander@541: template dvander@541: class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13 ) > dvander@541: // Inherit from FastDelegate13 so that it can be treated just like a FastDelegate13 dvander@541: : public FastDelegate13 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, R > dvander@541: { dvander@541: public: dvander@541: // Make using the base type a bit easier via typedef. dvander@541: typedef FastDelegate13 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, R > BaseType; dvander@541: dvander@541: // Allow users access to the specific type of this delegate. dvander@541: typedef FastDelegate SelfType; dvander@541: dvander@541: // Mimic the base class constructors. dvander@541: FastDelegate() : BaseType() { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(Y * pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13 )) dvander@541: : BaseType(pthis, function_to_bind) { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(const Y *pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13 ) const) dvander@541: : BaseType(pthis, function_to_bind) dvander@541: { } dvander@541: dvander@541: FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13 )) dvander@541: : BaseType(function_to_bind) { } dvander@541: void operator = (const BaseType &x) { dvander@541: *static_cast(this) = x; } dvander@541: }; dvander@541: dvander@541: //N=14 dvander@541: // Specialization to allow use of dvander@541: // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14 ) > dvander@541: // instead of dvander@541: // FastDelegate14 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, R > dvander@541: template dvander@541: class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14 ) > dvander@541: // Inherit from FastDelegate14 so that it can be treated just like a FastDelegate14 dvander@541: : public FastDelegate14 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, R > dvander@541: { dvander@541: public: dvander@541: // Make using the base type a bit easier via typedef. dvander@541: typedef FastDelegate14 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, R > BaseType; dvander@541: dvander@541: // Allow users access to the specific type of this delegate. dvander@541: typedef FastDelegate SelfType; dvander@541: dvander@541: // Mimic the base class constructors. dvander@541: FastDelegate() : BaseType() { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(Y * pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14 )) dvander@541: : BaseType(pthis, function_to_bind) { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(const Y *pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14 ) const) dvander@541: : BaseType(pthis, function_to_bind) dvander@541: { } dvander@541: dvander@541: FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14 )) dvander@541: : BaseType(function_to_bind) { } dvander@541: void operator = (const BaseType &x) { dvander@541: *static_cast(this) = x; } dvander@541: }; dvander@541: dvander@541: //N=15 dvander@541: // Specialization to allow use of dvander@541: // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15 ) > dvander@541: // instead of dvander@541: // FastDelegate15 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, R > dvander@541: template dvander@541: class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15 ) > dvander@541: // Inherit from FastDelegate15 so that it can be treated just like a FastDelegate15 dvander@541: : public FastDelegate15 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, R > dvander@541: { dvander@541: public: dvander@541: // Make using the base type a bit easier via typedef. dvander@541: typedef FastDelegate15 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, R > BaseType; dvander@541: dvander@541: // Allow users access to the specific type of this delegate. dvander@541: typedef FastDelegate SelfType; dvander@541: dvander@541: // Mimic the base class constructors. dvander@541: FastDelegate() : BaseType() { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(Y * pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15 )) dvander@541: : BaseType(pthis, function_to_bind) { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(const Y *pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15 ) const) dvander@541: : BaseType(pthis, function_to_bind) dvander@541: { } dvander@541: dvander@541: FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15 )) dvander@541: : BaseType(function_to_bind) { } dvander@541: void operator = (const BaseType &x) { dvander@541: *static_cast(this) = x; } dvander@541: }; dvander@541: dvander@541: //N=16 dvander@541: // Specialization to allow use of dvander@541: // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16 ) > dvander@541: // instead of dvander@541: // FastDelegate16 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, R > dvander@541: template dvander@541: class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16 ) > dvander@541: // Inherit from FastDelegate16 so that it can be treated just like a FastDelegate16 dvander@541: : public FastDelegate16 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, R > dvander@541: { dvander@541: public: dvander@541: // Make using the base type a bit easier via typedef. dvander@541: typedef FastDelegate16 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, R > BaseType; dvander@541: dvander@541: // Allow users access to the specific type of this delegate. dvander@541: typedef FastDelegate SelfType; dvander@541: dvander@541: // Mimic the base class constructors. dvander@541: FastDelegate() : BaseType() { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(Y * pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16 )) dvander@541: : BaseType(pthis, function_to_bind) { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(const Y *pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16 ) const) dvander@541: : BaseType(pthis, function_to_bind) dvander@541: { } dvander@541: dvander@541: FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16 )) dvander@541: : BaseType(function_to_bind) { } dvander@541: void operator = (const BaseType &x) { dvander@541: *static_cast(this) = x; } dvander@541: }; dvander@541: dvander@541: //N=17 dvander@541: // Specialization to allow use of dvander@541: // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17 ) > dvander@541: // instead of dvander@541: // FastDelegate17 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, R > dvander@541: template dvander@541: class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17 ) > dvander@541: // Inherit from FastDelegate17 so that it can be treated just like a FastDelegate17 dvander@541: : public FastDelegate17 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, R > dvander@541: { dvander@541: public: dvander@541: // Make using the base type a bit easier via typedef. dvander@541: typedef FastDelegate17 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, R > BaseType; dvander@541: dvander@541: // Allow users access to the specific type of this delegate. dvander@541: typedef FastDelegate SelfType; dvander@541: dvander@541: // Mimic the base class constructors. dvander@541: FastDelegate() : BaseType() { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(Y * pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17 )) dvander@541: : BaseType(pthis, function_to_bind) { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(const Y *pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17 ) const) dvander@541: : BaseType(pthis, function_to_bind) dvander@541: { } dvander@541: dvander@541: FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17 )) dvander@541: : BaseType(function_to_bind) { } dvander@541: void operator = (const BaseType &x) { dvander@541: *static_cast(this) = x; } dvander@541: }; dvander@541: dvander@541: //N=18 dvander@541: // Specialization to allow use of dvander@541: // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18 ) > dvander@541: // instead of dvander@541: // FastDelegate18 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, R > dvander@541: template dvander@541: class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18 ) > dvander@541: // Inherit from FastDelegate18 so that it can be treated just like a FastDelegate18 dvander@541: : public FastDelegate18 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, R > dvander@541: { dvander@541: public: dvander@541: // Make using the base type a bit easier via typedef. dvander@541: typedef FastDelegate18 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, R > BaseType; dvander@541: dvander@541: // Allow users access to the specific type of this delegate. dvander@541: typedef FastDelegate SelfType; dvander@541: dvander@541: // Mimic the base class constructors. dvander@541: FastDelegate() : BaseType() { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(Y * pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18 )) dvander@541: : BaseType(pthis, function_to_bind) { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(const Y *pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18 ) const) dvander@541: : BaseType(pthis, function_to_bind) dvander@541: { } dvander@541: dvander@541: FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18 )) dvander@541: : BaseType(function_to_bind) { } dvander@541: void operator = (const BaseType &x) { dvander@541: *static_cast(this) = x; } dvander@541: }; dvander@541: dvander@541: //N=19 dvander@541: // Specialization to allow use of dvander@541: // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19 ) > dvander@541: // instead of dvander@541: // FastDelegate19 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19, R > dvander@541: template dvander@541: class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19 ) > dvander@541: // Inherit from FastDelegate19 so that it can be treated just like a FastDelegate19 dvander@541: : public FastDelegate19 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19, R > dvander@541: { dvander@541: public: dvander@541: // Make using the base type a bit easier via typedef. dvander@541: typedef FastDelegate19 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19, R > BaseType; dvander@541: dvander@541: // Allow users access to the specific type of this delegate. dvander@541: typedef FastDelegate SelfType; dvander@541: dvander@541: // Mimic the base class constructors. dvander@541: FastDelegate() : BaseType() { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(Y * pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19 )) dvander@541: : BaseType(pthis, function_to_bind) { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(const Y *pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19 ) const) dvander@541: : BaseType(pthis, function_to_bind) dvander@541: { } dvander@541: dvander@541: FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19 )) dvander@541: : BaseType(function_to_bind) { } dvander@541: void operator = (const BaseType &x) { dvander@541: *static_cast(this) = x; } dvander@541: }; dvander@541: dvander@541: //N=20 dvander@541: // Specialization to allow use of dvander@541: // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19, Param20 ) > dvander@541: // instead of dvander@541: // FastDelegate20 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19, Param20, R > dvander@541: template dvander@541: class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19, Param20 ) > dvander@541: // Inherit from FastDelegate20 so that it can be treated just like a FastDelegate20 dvander@541: : public FastDelegate20 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19, Param20, R > dvander@541: { dvander@541: public: dvander@541: // Make using the base type a bit easier via typedef. dvander@541: typedef FastDelegate20 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19, Param20, R > BaseType; dvander@541: dvander@541: // Allow users access to the specific type of this delegate. dvander@541: typedef FastDelegate SelfType; dvander@541: dvander@541: // Mimic the base class constructors. dvander@541: FastDelegate() : BaseType() { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(Y * pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19, Param20 p20 )) dvander@541: : BaseType(pthis, function_to_bind) { } dvander@541: dvander@541: template < class X, class Y > dvander@541: FastDelegate(const Y *pthis, dvander@541: R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19, Param20 p20 ) const) dvander@541: : BaseType(pthis, function_to_bind) dvander@541: { } dvander@541: dvander@541: FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19, Param20 p20 )) dvander@541: : BaseType(function_to_bind) { } dvander@541: void operator = (const BaseType &x) { dvander@541: *static_cast(this) = x; } dvander@541: }; dvander@541: dvander@541: dvander@541: #endif //FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX dvander@541: dvander@541: //////////////////////////////////////////////////////////////////////////////// dvander@541: // Fast Delegates, part 5: dvander@541: // dvander@541: // MakeDelegate() helper function dvander@541: // dvander@541: // MakeDelegate(&x, &X::func) returns a fastdelegate of the type dvander@541: // necessary for calling x.func() with the correct number of arguments. dvander@541: // This makes it possible to eliminate many typedefs from user code. dvander@541: // dvander@541: //////////////////////////////////////////////////////////////////////////////// dvander@541: dvander@541: // Also declare overloads of a MakeDelegate() global function to dvander@541: // reduce the need for typedefs. dvander@541: // We need seperate overloads for const and non-const member functions. dvander@541: // Also, because of the weird rule about the class of derived member function pointers, dvander@541: // implicit downcasts may need to be applied later to the 'this' pointer. dvander@541: // That's why two classes (X and Y) appear in the definitions. Y must be implicitly dvander@541: // castable to X. dvander@541: dvander@541: // Workaround for VC6. VC6 needs void return types converted into DefaultVoid. dvander@541: // GCC 3.2 and later won't compile this unless it's preceded by 'typename', dvander@541: // but VC6 doesn't allow 'typename' in this context. dvander@541: // So, I have to use a macro. dvander@541: dvander@541: #ifdef FASTDLGT_VC6 dvander@541: #define FASTDLGT_RETTYPE detail::VoidToDefaultVoid::type dvander@541: #else dvander@541: #define FASTDLGT_RETTYPE RetType dvander@541: #endif dvander@541: dvander@541: //N=0 dvander@541: template dvander@541: FastDelegate0 MakeDelegate(Y* x, RetType (X::*func)()) { dvander@541: return FastDelegate0(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate0 MakeDelegate(Y* x, RetType (X::*func)() const) { dvander@541: return FastDelegate0(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate0 MakeDelegate(RetType (*func)()) { dvander@541: return FastDelegate0(func); dvander@541: } dvander@541: dvander@541: //N=1 dvander@541: template dvander@541: FastDelegate1 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1)) { dvander@541: return FastDelegate1(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate1 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1) const) { dvander@541: return FastDelegate1(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate1 MakeDelegate(RetType (*func)(Param1 p1)) { dvander@541: return FastDelegate1(func); dvander@541: } dvander@541: dvander@541: //N=2 dvander@541: template dvander@541: FastDelegate2 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2)) { dvander@541: return FastDelegate2(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate2 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2) const) { dvander@541: return FastDelegate2(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate2 MakeDelegate(RetType (*func)(Param1 p1, Param2 p2)) { dvander@541: return FastDelegate2(func); dvander@541: } dvander@541: dvander@541: //N=3 dvander@541: template dvander@541: FastDelegate3 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3)) { dvander@541: return FastDelegate3(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate3 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3) const) { dvander@541: return FastDelegate3(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate3 MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3)) { dvander@541: return FastDelegate3(func); dvander@541: } dvander@541: dvander@541: //N=4 dvander@541: template dvander@541: FastDelegate4 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4)) { dvander@541: return FastDelegate4(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate4 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const) { dvander@541: return FastDelegate4(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate4 MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4)) { dvander@541: return FastDelegate4(func); dvander@541: } dvander@541: dvander@541: //N=5 dvander@541: template dvander@541: FastDelegate5 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5)) { dvander@541: return FastDelegate5(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate5 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const) { dvander@541: return FastDelegate5(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate5 MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5)) { dvander@541: return FastDelegate5(func); dvander@541: } dvander@541: dvander@541: //N=6 dvander@541: template dvander@541: FastDelegate6 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6)) { dvander@541: return FastDelegate6(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate6 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const) { dvander@541: return FastDelegate6(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate6 MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6)) { dvander@541: return FastDelegate6(func); dvander@541: } dvander@541: dvander@541: //N=7 dvander@541: template dvander@541: FastDelegate7 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7)) { dvander@541: return FastDelegate7(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate7 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const) { dvander@541: return FastDelegate7(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate7 MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7)) { dvander@541: return FastDelegate7(func); dvander@541: } dvander@541: dvander@541: //N=8 dvander@541: template dvander@541: FastDelegate8 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8)) { dvander@541: return FastDelegate8(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate8 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) const) { dvander@541: return FastDelegate8(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate8 MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8)) { dvander@541: return FastDelegate8(func); dvander@541: } dvander@541: dvander@541: //N=9 dvander@541: template dvander@541: FastDelegate9 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9)) { dvander@541: return FastDelegate9(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate9 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9) const) { dvander@541: return FastDelegate9(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate9 MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9)) { dvander@541: return FastDelegate9(func); dvander@541: } dvander@541: dvander@541: //N=10 dvander@541: template dvander@541: FastDelegate10 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10)) { dvander@541: return FastDelegate10(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate10 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10) const) { dvander@541: return FastDelegate10(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate10 MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10)) { dvander@541: return FastDelegate10(func); dvander@541: } dvander@541: dvander@541: //N=11 dvander@541: template dvander@541: FastDelegate11 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11)) { dvander@541: return FastDelegate11(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate11 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11) const) { dvander@541: return FastDelegate11(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate11 MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11)) { dvander@541: return FastDelegate11(func); dvander@541: } dvander@541: dvander@541: //N=12 dvander@541: template dvander@541: FastDelegate12 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12)) { dvander@541: return FastDelegate12(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate12 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12) const) { dvander@541: return FastDelegate12(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate12 MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12)) { dvander@541: return FastDelegate12(func); dvander@541: } dvander@541: dvander@541: //N=13 dvander@541: template dvander@541: FastDelegate13 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13)) { dvander@541: return FastDelegate13(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate13 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13) const) { dvander@541: return FastDelegate13(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate13 MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13)) { dvander@541: return FastDelegate13(func); dvander@541: } dvander@541: dvander@541: //N=14 dvander@541: template dvander@541: FastDelegate14 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14)) { dvander@541: return FastDelegate14(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate14 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14) const) { dvander@541: return FastDelegate14(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate14 MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14)) { dvander@541: return FastDelegate14(func); dvander@541: } dvander@541: dvander@541: //N=15 dvander@541: template dvander@541: FastDelegate15 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15)) { dvander@541: return FastDelegate15(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate15 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15) const) { dvander@541: return FastDelegate15(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate15 MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15)) { dvander@541: return FastDelegate15(func); dvander@541: } dvander@541: dvander@541: //N=16 dvander@541: template dvander@541: FastDelegate16 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16)) { dvander@541: return FastDelegate16(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate16 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16) const) { dvander@541: return FastDelegate16(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate16 MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16)) { dvander@541: return FastDelegate16(func); dvander@541: } dvander@541: dvander@541: //N=17 dvander@541: template dvander@541: FastDelegate17 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17)) { dvander@541: return FastDelegate17(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate17 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17) const) { dvander@541: return FastDelegate17(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate17 MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17)) { dvander@541: return FastDelegate17(func); dvander@541: } dvander@541: dvander@541: //N=18 dvander@541: template dvander@541: FastDelegate18 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18)) { dvander@541: return FastDelegate18(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate18 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18) const) { dvander@541: return FastDelegate18(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate18 MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18)) { dvander@541: return FastDelegate18(func); dvander@541: } dvander@541: dvander@541: //N=19 dvander@541: template dvander@541: FastDelegate19 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19)) { dvander@541: return FastDelegate19(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate19 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19) const) { dvander@541: return FastDelegate19(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate19 MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19)) { dvander@541: return FastDelegate19(func); dvander@541: } dvander@541: dvander@541: //N=20 dvander@541: template dvander@541: FastDelegate20 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19, Param20 p20)) { dvander@541: return FastDelegate20(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate20 MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19, Param20 p20) const) { dvander@541: return FastDelegate20(x, func); dvander@541: } dvander@541: dvander@541: template dvander@541: FastDelegate20 MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17, Param18 p18, Param19 p19, Param20 p20)) { dvander@541: return FastDelegate20(func); dvander@541: } dvander@541: dvander@541: dvander@541: // clean up after ourselves... dvander@541: #undef FASTDLGT_RETTYPE dvander@541: dvander@541: } // namespace fastdelegate dvander@541: dvander@541: #endif // !defined(FASTDELEGATE_H)