sourcehook/FastDelegate.h
author Pavol Marko <pavolmarko@gmail.com>
Fri Nov 09 21:14:37 2007 +0000 (2007-11-09)
branchhookman_autogen
changeset 452 2efe13dab607
parent 390 66690bf8af93
permissions -rw-r--r--
- Removed unnecessary definitions from sh_pagealloc.h
- Added CallConv_StdCall
- Added CallConv_HasVarArgs and CallConv_HasVafmt
     1 //						FastDelegate.h
     2 //	Efficient delegates in C++ that generate only two lines of asm code!
     3 //  Documentation is found at http://www.codeproject.com/cpp/FastDelegate.asp
     4 //
     5 //						- Don Clugston, Mar 2004.
     6 //		Major contributions were made by Jody Hagins.
     7 // History:
     8 // 24-Apr-04 1.0  * Submitted to CodeProject.
     9 // 28-Apr-04 1.1  * Prevent most unsafe uses of evil static function hack.
    10 //				  * Improved syntax for horrible_cast (thanks Paul Bludov).
    11 //				  * Tested on Metrowerks MWCC and Intel ICL (IA32)
    12 //				  * Compiled, but not run, on Comeau C++ and Intel Itanium ICL.
    13 //	27-Jun-04 1.2 * Now works on Borland C++ Builder 5.5
    14 //				  * Now works on /clr "managed C++" code on VC7, VC7.1
    15 //				  * Comeau C++ now compiles without warnings.
    16 //				  * Prevent the virtual inheritance case from being used on
    17 //					  VC6 and earlier, which generate incorrect code.
    18 //				  * Improved warning and error messages. Non-standard hacks
    19 //					 now have compile-time checks to make them safer.
    20 //				  * implicit_cast used instead of static_cast in many cases.
    21 //				  * If calling a const member function, a const class pointer can be used.
    22 //				  * MakeDelegate() global helper function added to simplify pass-by-value.
    23 //				  * Added fastdelegate.clear()
    24 // 16-Jul-04 1.2.1* Workaround for gcc bug (const member function pointers in templates)
    25 // 30-Oct-04 1.3  * Support for (non-void) return values.
    26 //				  * No more workarounds in client code!
    27 //					 MSVC and Intel now use a clever hack invented by John Dlugosz:
    28 //				     - The FASTDELEGATEDECLARE workaround is no longer necessary.
    29 //					 - No more warning messages for VC6
    30 //				  * Less use of macros. Error messages should be more comprehensible.
    31 //				  * Added include guards
    32 //				  * Added FastDelegate::empty() to test if invocation is safe (Thanks Neville Franks).
    33 //				  * Now tested on VS 2005 Express Beta, PGI C++
    34 // 24-Dec-04 1.4  * Added DelegateMemento, to allow collections of disparate delegates.
    35 //                * <,>,<=,>= comparison operators to allow storage in ordered containers.
    36 //				  * Substantial reduction of code size, especially the 'Closure' class.
    37 //				  * Standardised all the compiler-specific workarounds.
    38 //                * MFP conversion now works for CodePlay (but not yet supported in the full code).
    39 //                * Now compiles without warnings on _any_ supported compiler, including BCC 5.5.1
    40 //				  * New syntax: FastDelegate< int (char *, double) >.
    41 // 14-Feb-05 1.4.1* Now treats =0 as equivalent to .clear(), ==0 as equivalent to .empty(). (Thanks elfric).
    42 //				  * Now tested on Intel ICL for AMD64, VS2005 Beta for AMD64 and Itanium.
    43 // 30-Mar-05 1.5  * Safebool idiom: "if (dg)" is now equivalent to "if (!dg.empty())"
    44 //				  * Fully supported by CodePlay VectorC
    45 //                * Bugfix for Metrowerks: empty() was buggy because a valid MFP can be 0 on MWCC!
    46 //                * More optimal assignment,== and != operators for static function pointers.
    47 
    48 #ifndef FASTDELEGATE_H
    49 #define FASTDELEGATE_H
    50 
    51 #ifdef _MSC_VER
    52 # if _MSC_VER > 1000
    53 #  pragma once
    54 # endif // _MSC_VER > 1000
    55 #endif // #ifdef _MSC_VER
    56 
    57 #include <memory.h> // to allow <,> comparisons
    58 
    59 ////////////////////////////////////////////////////////////////////////////////
    60 //						Configuration options
    61 //
    62 ////////////////////////////////////////////////////////////////////////////////
    63 
    64 // Uncomment the following #define for optimally-sized delegates.
    65 // In this case, the generated asm code is almost identical to the code you'd get
    66 // if the compiler had native support for delegates.
    67 // It will not work on systems where sizeof(dataptr) < sizeof(codeptr).
    68 // Thus, it will not work for DOS compilers using the medium model.
    69 // It will also probably fail on some DSP systems.
    70 #define FASTDELEGATE_USESTATICFUNCTIONHACK
    71 
    72 // Uncomment the next line to allow function declarator syntax.
    73 // It is automatically enabled for those compilers where it is known to work.
    74 //#define FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX
    75 
    76 ////////////////////////////////////////////////////////////////////////////////
    77 //						Compiler identification for workarounds
    78 //
    79 ////////////////////////////////////////////////////////////////////////////////
    80 
    81 // Compiler identification. It's not easy to identify Visual C++ because
    82 // many vendors fraudulently define Microsoft's identifiers.
    83 #if defined(_MSC_VER) && !defined(__MWERKS__) && !defined(__VECTOR_C) && !defined(__ICL) && !defined(__BORLANDC__)
    84 #define FASTDLGT_ISMSVC
    85 
    86 #if (_MSC_VER <1300) // Many workarounds are required for VC6.
    87 #define FASTDLGT_VC6
    88 #pragma warning(disable:4786) // disable this ridiculous warning
    89 #endif
    90 
    91 #endif
    92 
    93 // Does the compiler uses Microsoft's member function pointer structure?
    94 // If so, it needs special treatment.
    95 // Metrowerks CodeWarrior, Intel, and CodePlay fraudulently define Microsoft's
    96 // identifier, _MSC_VER. We need to filter Metrowerks out.
    97 #if defined(_MSC_VER) && !defined(__MWERKS__)
    98 #define FASTDLGT_MICROSOFT_MFP
    99 
   100 #if !defined(__VECTOR_C)
   101 // CodePlay doesn't have the __single/multi/virtual_inheritance keywords
   102 #define FASTDLGT_HASINHERITANCE_KEYWORDS
   103 #endif
   104 #endif
   105 
   106 // Does it allow function declarator syntax? The following compilers are known to work:
   107 #if defined(FASTDLGT_ISMSVC) && (_MSC_VER >=1310) // VC 7.1
   108 #define FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX
   109 #endif
   110 
   111 // Gcc(2.95+), and versions of Digital Mars, Intel and Comeau in common use.
   112 #if defined (__DMC__) || defined(__GNUC__) || defined(__ICL) || defined(__COMO__)
   113 #define FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX
   114 #endif
   115 
   116 // It works on Metrowerks MWCC 3.2.2. From boost.Config it should work on earlier ones too.
   117 #if defined (__MWERKS__)
   118 #define FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX
   119 #endif
   120 
   121 #ifdef __GNUC__ // Workaround GCC bug #8271
   122 	// At present, GCC doesn't recognize constness of MFPs in templates
   123 #define FASTDELEGATE_GCC_BUG_8271
   124 #endif
   125 
   126 
   127 
   128 ////////////////////////////////////////////////////////////////////////////////
   129 //						General tricks used in this code
   130 //
   131 // (a) Error messages are generated by typdefing an array of negative size to
   132 //     generate compile-time errors.
   133 // (b) Warning messages on MSVC are generated by declaring unused variables, and
   134 //	    enabling the "variable XXX is never used" warning.
   135 // (c) Unions are used in a few compiler-specific cases to perform illegal casts.
   136 // (d) For Microsoft and Intel, when adjusting the 'this' pointer, it's cast to
   137 //     (char *) first to ensure that the correct number of *bytes* are added.
   138 //
   139 ////////////////////////////////////////////////////////////////////////////////
   140 //						Helper templates
   141 //
   142 ////////////////////////////////////////////////////////////////////////////////
   143 
   144 
   145 namespace fastdelegate {
   146 namespace detail {	// we'll hide the implementation details in a nested namespace.
   147 
   148 //		implicit_cast< >
   149 // I believe this was originally going to be in the C++ standard but
   150 // was left out by accident. It's even milder than static_cast.
   151 // I use it instead of static_cast<> to emphasize that I'm not doing
   152 // anything nasty.
   153 // Usage is identical to static_cast<>
   154 template <class OutputClass, class InputClass>
   155 inline OutputClass implicit_cast(InputClass input){
   156 	return input;
   157 }
   158 
   159 //		horrible_cast< >
   160 // This is truly evil. It completely subverts C++'s type system, allowing you
   161 // to cast from any class to any other class. Technically, using a union
   162 // to perform the cast is undefined behaviour (even in C). But we can see if
   163 // it is OK by checking that the union is the same size as each of its members.
   164 // horrible_cast<> should only be used for compiler-specific workarounds.
   165 // Usage is identical to reinterpret_cast<>.
   166 
   167 // This union is declared outside the horrible_cast because BCC 5.5.1
   168 // can't inline a function with a nested class, and gives a warning.
   169 template <class OutputClass, class InputClass>
   170 union horrible_union{
   171 	OutputClass out;
   172 	InputClass in;
   173 };
   174 
   175 template <class OutputClass, class InputClass>
   176 inline OutputClass horrible_cast(const InputClass input){
   177 	horrible_union<OutputClass, InputClass> u;
   178 	// Cause a compile-time error if in, out and u are not the same size.
   179 	// If the compile fails here, it means the compiler has peculiar
   180 	// unions which would prevent the cast from working.
   181 	typedef int ERROR_CantUseHorrible_cast[sizeof(InputClass)==sizeof(u)
   182 		&& sizeof(InputClass)==sizeof(OutputClass) ? 1 : -1];
   183 	u.in = input;
   184 	return u.out;
   185 }
   186 
   187 ////////////////////////////////////////////////////////////////////////////////
   188 //						Workarounds
   189 //
   190 ////////////////////////////////////////////////////////////////////////////////
   191 
   192 // Backwards compatibility: This macro used to be necessary in the virtual inheritance
   193 // case for Intel and Microsoft. Now it just forward-declares the class.
   194 #define FASTDELEGATEDECLARE(CLASSNAME)	class CLASSNAME;
   195 
   196 // Prevent use of the static function hack with the DOS medium model.
   197 #ifdef __MEDIUM__
   198 #undef FASTDELEGATE_USESTATICFUNCTIONHACK
   199 #endif
   200 
   201 //			DefaultVoid - a workaround for 'void' templates in VC6.
   202 //
   203 //  (1) VC6 and earlier do not allow 'void' as a default template argument.
   204 //  (2) They also doesn't allow you to return 'void' from a function.
   205 //
   206 // Workaround for (1): Declare a dummy type 'DefaultVoid' which we use
   207 //   when we'd like to use 'void'. We convert it into 'void' and back
   208 //   using the templates DefaultVoidToVoid<> and VoidToDefaultVoid<>.
   209 // Workaround for (2): On VC6, the code for calling a void function is
   210 //   identical to the code for calling a non-void function in which the
   211 //   return value is never used, provided the return value is returned
   212 //   in the EAX register, rather than on the stack.
   213 //   This is true for most fundamental types such as int, enum, void *.
   214 //   Const void * is the safest option since it doesn't participate
   215 //   in any automatic conversions. But on a 16-bit compiler it might
   216 //   cause extra code to be generated, so we disable it for all compilers
   217 //   except for VC6 (and VC5).
   218 #ifdef FASTDLGT_VC6
   219 // VC6 workaround
   220 typedef const void * DefaultVoid;
   221 #else
   222 // On any other compiler, just use a normal void.
   223 typedef void DefaultVoid;
   224 #endif
   225 
   226 // Translate from 'DefaultVoid' to 'void'.
   227 // Everything else is unchanged
   228 template <class T>
   229 struct DefaultVoidToVoid { typedef T type; };
   230 
   231 template <>
   232 struct DefaultVoidToVoid<DefaultVoid> {	typedef void type; };
   233 
   234 // Translate from 'void' into 'DefaultVoid'
   235 // Everything else is unchanged
   236 template <class T>
   237 struct VoidToDefaultVoid { typedef T type; };
   238 
   239 template <>
   240 struct VoidToDefaultVoid<void> { typedef DefaultVoid type; };
   241 
   242 
   243 
   244 ////////////////////////////////////////////////////////////////////////////////
   245 //						Fast Delegates, part 1:
   246 //
   247 //		Conversion of member function pointer to a standard form
   248 //
   249 ////////////////////////////////////////////////////////////////////////////////
   250 
   251 // GenericClass is a fake class, ONLY used to provide a type.
   252 // It is vitally important that it is never defined, so that the compiler doesn't
   253 // think it can optimize the invocation. For example, Borland generates simpler
   254 // code if it knows the class only uses single inheritance.
   255 
   256 // Compilers using Microsoft's structure need to be treated as a special case.
   257 #ifdef  FASTDLGT_MICROSOFT_MFP
   258 
   259 #ifdef FASTDLGT_HASINHERITANCE_KEYWORDS
   260 	// For Microsoft and Intel, we want to ensure that it's the most efficient type of MFP
   261 	// (4 bytes), even when the /vmg option is used. Declaring an empty class
   262 	// would give 16 byte pointers in this case....
   263 	class __single_inheritance GenericClass;
   264 #endif
   265 	// ...but for Codeplay, an empty class *always* gives 4 byte pointers.
   266 	// If compiled with the /clr option ("managed C++"), the JIT compiler thinks
   267 	// it needs to load GenericClass before it can call any of its functions,
   268 	// (compiles OK but crashes at runtime!), so we need to declare an
   269 	// empty class to make it happy.
   270 	// Codeplay and VC4 can't cope with the unknown_inheritance case either.
   271 	class GenericClass {};
   272 #else
   273 	class GenericClass;
   274 #endif
   275 
   276 // The size of a single inheritance member function pointer.
   277 const int SINGLE_MEMFUNCPTR_SIZE = sizeof(void (GenericClass::*)());
   278 
   279 //						SimplifyMemFunc< >::Convert()
   280 //
   281 //	A template function that converts an arbitrary member function pointer into the
   282 //	simplest possible form of member function pointer, using a supplied 'this' pointer.
   283 //  According to the standard, this can be done legally with reinterpret_cast<>.
   284 //	For (non-standard) compilers which use member function pointers which vary in size
   285 //  depending on the class, we need to use	knowledge of the internal structure of a
   286 //  member function pointer, as used by the compiler. Template specialization is used
   287 //  to distinguish between the sizes. Because some compilers don't support partial
   288 //	template specialisation, I use full specialisation of a wrapper struct.
   289 
   290 // general case -- don't know how to convert it. Force a compile failure
   291 template <int N>
   292 struct SimplifyMemFunc {
   293 	template <class X, class XFuncType, class GenericMemFuncType>
   294 	inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind,
   295 		GenericMemFuncType &bound_func) {
   296 		// Unsupported member function type -- force a compile failure.
   297 	    // (it's illegal to have a array with negative size).
   298 		typedef char ERROR_Unsupported_member_function_pointer_on_this_compiler[N-100];
   299 		return 0;
   300 	}
   301 };
   302 
   303 // For compilers where all member func ptrs are the same size, everything goes here.
   304 // For non-standard compilers, only single_inheritance classes go here.
   305 template <>
   306 struct SimplifyMemFunc<SINGLE_MEMFUNCPTR_SIZE>  {
   307 	template <class X, class XFuncType, class GenericMemFuncType>
   308 	inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind,
   309 			GenericMemFuncType &bound_func) {
   310 #if defined __DMC__
   311 		// Digital Mars doesn't allow you to cast between abitrary PMF's,
   312 		// even though the standard says you can. The 32-bit compiler lets you
   313 		// static_cast through an int, but the DOS compiler doesn't.
   314 		bound_func = horrible_cast<GenericMemFuncType>(function_to_bind);
   315 #else
   316         bound_func = reinterpret_cast<GenericMemFuncType>(function_to_bind);
   317 #endif
   318         return reinterpret_cast<GenericClass *>(pthis);
   319 	}
   320 };
   321 
   322 ////////////////////////////////////////////////////////////////////////////////
   323 //						Fast Delegates, part 1b:
   324 //
   325 //					Workarounds for Microsoft and Intel
   326 //
   327 ////////////////////////////////////////////////////////////////////////////////
   328 
   329 
   330 // Compilers with member function pointers which violate the standard (MSVC, Intel, Codeplay),
   331 // need to be treated as a special case.
   332 #ifdef FASTDLGT_MICROSOFT_MFP
   333 
   334 // We use unions to perform horrible_casts. I would like to use #pragma pack(push, 1)
   335 // at the start of each function for extra safety, but VC6 seems to ICE
   336 // intermittently if you do this inside a template.
   337 
   338 // __multiple_inheritance classes go here
   339 // Nasty hack for Microsoft and Intel (IA32 and Itanium)
   340 template<>
   341 struct SimplifyMemFunc< SINGLE_MEMFUNCPTR_SIZE + sizeof(int) >  {
   342 	template <class X, class XFuncType, class GenericMemFuncType>
   343 	inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind,
   344 		GenericMemFuncType &bound_func) {
   345 		// We need to use a horrible_cast to do this conversion.
   346 		// In MSVC, a multiple inheritance member pointer is internally defined as:
   347         union {
   348 			XFuncType func;
   349 			struct {
   350 				GenericMemFuncType funcaddress; // points to the actual member function
   351 				int delta;	     // #BYTES to be added to the 'this' pointer
   352 			}s;
   353         } u;
   354 		// Check that the horrible_cast will work
   355 		typedef int ERROR_CantUsehorrible_cast[sizeof(function_to_bind)==sizeof(u.s)? 1 : -1];
   356         u.func = function_to_bind;
   357 		bound_func = u.s.funcaddress;
   358 		return reinterpret_cast<GenericClass *>(reinterpret_cast<char *>(pthis) + u.s.delta);
   359 	}
   360 };
   361 
   362 // virtual inheritance is a real nuisance. It's inefficient and complicated.
   363 // On MSVC and Intel, there isn't enough information in the pointer itself to
   364 // enable conversion to a closure pointer. Earlier versions of this code didn't
   365 // work for all cases, and generated a compile-time error instead.
   366 // But a very clever hack invented by John M. Dlugosz solves this problem.
   367 // My code is somewhat different to his: I have no asm code, and I make no
   368 // assumptions about the calling convention that is used.
   369 
   370 // In VC++ and ICL, a virtual_inheritance member pointer
   371 // is internally defined as:
   372 struct MicrosoftVirtualMFP {
   373 	void (GenericClass::*codeptr)(); // points to the actual member function
   374 	int delta;		// #bytes to be added to the 'this' pointer
   375 	int vtable_index; // or 0 if no virtual inheritance
   376 };
   377 // The CRUCIAL feature of Microsoft/Intel MFPs which we exploit is that the
   378 // m_codeptr member is *always* called, regardless of the values of the other
   379 // members. (This is *not* true for other compilers, eg GCC, which obtain the
   380 // function address from the vtable if a virtual function is being called).
   381 // Dlugosz's trick is to make the codeptr point to a probe function which
   382 // returns the 'this' pointer that was used.
   383 
   384 // Define a generic class that uses virtual inheritance.
   385 // It has a trival member function that returns the value of the 'this' pointer.
   386 struct GenericVirtualClass : virtual public GenericClass
   387 {
   388 	typedef GenericVirtualClass * (GenericVirtualClass::*ProbePtrType)();
   389 	GenericVirtualClass * GetThis() { return this; }
   390 };
   391 
   392 // __virtual_inheritance classes go here
   393 template <>
   394 struct SimplifyMemFunc<SINGLE_MEMFUNCPTR_SIZE + 2*sizeof(int) >
   395 {
   396 
   397 	template <class X, class XFuncType, class GenericMemFuncType>
   398 	inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind,
   399 		GenericMemFuncType &bound_func) {
   400 		union {
   401 			XFuncType func;
   402 			GenericClass* (X::*ProbeFunc)();
   403 			MicrosoftVirtualMFP s;
   404 		} u;
   405 		u.func = function_to_bind;
   406 		bound_func = reinterpret_cast<GenericMemFuncType>(u.s.codeptr);
   407 		union {
   408 			GenericVirtualClass::ProbePtrType virtfunc;
   409 			MicrosoftVirtualMFP s;
   410 		} u2;
   411 		// Check that the horrible_cast<>s will work
   412 		typedef int ERROR_CantUsehorrible_cast[sizeof(function_to_bind)==sizeof(u.s)
   413 			&& sizeof(function_to_bind)==sizeof(u.ProbeFunc)
   414 			&& sizeof(u2.virtfunc)==sizeof(u2.s) ? 1 : -1];
   415    // Unfortunately, taking the address of a MF prevents it from being inlined, so
   416    // this next line can't be completely optimised away by the compiler.
   417 		u2.virtfunc = &GenericVirtualClass::GetThis;
   418 		u.s.codeptr = u2.s.codeptr;
   419 		return (pthis->*u.ProbeFunc)();
   420 	}
   421 };
   422 
   423 #if (_MSC_VER <1300)
   424 
   425 // Nasty hack for Microsoft Visual C++ 6.0
   426 // unknown_inheritance classes go here
   427 // There is a compiler bug in MSVC6 which generates incorrect code in this case!!
   428 template <>
   429 struct SimplifyMemFunc<SINGLE_MEMFUNCPTR_SIZE + 3*sizeof(int) >
   430 {
   431 	template <class X, class XFuncType, class GenericMemFuncType>
   432 	inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind,
   433 		GenericMemFuncType &bound_func) {
   434 		// There is an apalling but obscure compiler bug in MSVC6 and earlier:
   435 		// vtable_index and 'vtordisp' are always set to 0 in the
   436 		// unknown_inheritance case!
   437 		// This means that an incorrect function could be called!!!
   438 		// Compiling with the /vmg option leads to potentially incorrect code.
   439 		// This is probably the reason that the IDE has a user interface for specifying
   440 		// the /vmg option, but it is disabled -  you can only specify /vmg on
   441 		// the command line. In VC1.5 and earlier, the compiler would ICE if it ever
   442 		// encountered this situation.
   443 		// It is OK to use the /vmg option if /vmm or /vms is specified.
   444 
   445 		// Fortunately, the wrong function is only called in very obscure cases.
   446 		// It only occurs when a derived class overrides a virtual function declared
   447 		// in a virtual base class, and the member function
   448 		// points to the *Derived* version of that function. The problem can be
   449 		// completely averted in 100% of cases by using the *Base class* for the
   450 		// member fpointer. Ie, if you use the base class as an interface, you'll
   451 		// stay out of trouble.
   452 		// Occasionally, you might want to point directly to a derived class function
   453 		// that isn't an override of a base class. In this case, both vtable_index
   454 		// and 'vtordisp' are zero, but a virtual_inheritance pointer will be generated.
   455 		// We can generate correct code in this case. To prevent an incorrect call from
   456 		// ever being made, on MSVC6 we generate a warning, and call a function to
   457 		// make the program crash instantly.
   458 		typedef char ERROR_VC6CompilerBug[-100];
   459 		return 0;
   460 	}
   461 };
   462 
   463 
   464 #else
   465 
   466 // Nasty hack for Microsoft and Intel (IA32 and Itanium)
   467 // unknown_inheritance classes go here
   468 // This is probably the ugliest bit of code I've ever written. Look at the casts!
   469 // There is a compiler bug in MSVC6 which prevents it from using this code.
   470 template <>
   471 struct SimplifyMemFunc<SINGLE_MEMFUNCPTR_SIZE + 3*sizeof(int) >
   472 {
   473 	template <class X, class XFuncType, class GenericMemFuncType>
   474 	inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind,
   475 			GenericMemFuncType &bound_func) {
   476 		// The member function pointer is 16 bytes long. We can't use a normal cast, but
   477 		// we can use a union to do the conversion.
   478 		union {
   479 			XFuncType func;
   480 			// In VC++ and ICL, an unknown_inheritance member pointer
   481 			// is internally defined as:
   482 			struct {
   483 				GenericMemFuncType m_funcaddress; // points to the actual member function
   484 				int delta;		// #bytes to be added to the 'this' pointer
   485 				int vtordisp;		// #bytes to add to 'this' to find the vtable
   486 				int vtable_index; // or 0 if no virtual inheritance
   487 			} s;
   488 		} u;
   489 		// Check that the horrible_cast will work
   490 		typedef int ERROR_CantUsehorrible_cast[sizeof(XFuncType)==sizeof(u.s)? 1 : -1];
   491 		u.func = function_to_bind;
   492 		bound_func = u.s.funcaddress;
   493 		int virtual_delta = 0;
   494 		if (u.s.vtable_index) { // Virtual inheritance is used
   495 			// First, get to the vtable.
   496 			// It is 'vtordisp' bytes from the start of the class.
   497 			const int * vtable = *reinterpret_cast<const int *const*>(
   498 				reinterpret_cast<const char *>(pthis) + u.s.vtordisp );
   499 
   500 			// 'vtable_index' tells us where in the table we should be looking.
   501 			virtual_delta = u.s.vtordisp + *reinterpret_cast<const int *>(
   502 				reinterpret_cast<const char *>(vtable) + u.s.vtable_index);
   503 		}
   504 		// The int at 'virtual_delta' gives us the amount to add to 'this'.
   505         // Finally we can add the three components together. Phew!
   506         return reinterpret_cast<GenericClass *>(
   507 			reinterpret_cast<char *>(pthis) + u.s.delta + virtual_delta);
   508 	};
   509 };
   510 #endif // MSVC 7 and greater
   511 
   512 #endif // MS/Intel hacks
   513 
   514 }  // namespace detail
   515 
   516 ////////////////////////////////////////////////////////////////////////////////
   517 //						Fast Delegates, part 2:
   518 //
   519 //	Define the delegate storage, and cope with static functions
   520 //
   521 ////////////////////////////////////////////////////////////////////////////////
   522 
   523 // DelegateMemento -- an opaque structure which can hold an arbitary delegate.
   524 // It knows nothing about the calling convention or number of arguments used by
   525 // the function pointed to.
   526 // It supplies comparison operators so that it can be stored in STL collections.
   527 // It cannot be set to anything other than null, nor invoked directly:
   528 //   it must be converted to a specific delegate.
   529 
   530 // Implementation:
   531 // There are two possible implementations: the Safe method and the Evil method.
   532 //				DelegateMemento - Safe version
   533 //
   534 // This implementation is standard-compliant, but a bit tricky.
   535 // A static function pointer is stored inside the class.
   536 // Here are the valid values:
   537 // +-- Static pointer --+--pThis --+-- pMemFunc-+-- Meaning------+
   538 // |   0				|  0       |   0        | Empty          |
   539 // |   !=0              |(dontcare)|  Invoker   | Static function|
   540 // |   0                |  !=0     |  !=0*      | Method call    |
   541 // +--------------------+----------+------------+----------------+
   542 //  * For Metrowerks, this can be 0. (first virtual function in a 
   543 //       single_inheritance class).
   544 // When stored stored inside a specific delegate, the 'dontcare' entries are replaced
   545 // with a reference to the delegate itself. This complicates the = and == operators
   546 // for the delegate class.
   547 
   548 //				DelegateMemento - Evil version
   549 //
   550 // For compilers where data pointers are at least as big as code pointers, it is
   551 // possible to store the function pointer in the this pointer, using another
   552 // horrible_cast. In this case the DelegateMemento implementation is simple:
   553 // +--pThis --+-- pMemFunc-+-- Meaning---------------------+
   554 // |    0     |  0         | Empty                         |
   555 // |  !=0     |  !=0*      | Static function or method call|
   556 // +----------+------------+-------------------------------+
   557 //  * For Metrowerks, this can be 0. (first virtual function in a 
   558 //       single_inheritance class).
   559 // Note that the Sun C++ and MSVC documentation explicitly state that they 
   560 // support static_cast between void * and function pointers.
   561 
   562 class DelegateMemento {
   563 protected:
   564 	// the data is protected, not private, because many
   565 	// compilers have problems with template friends.
   566 	typedef void (detail::GenericClass::*GenericMemFuncType)(); // arbitrary MFP.
   567 	detail::GenericClass *m_pthis;
   568 	GenericMemFuncType m_pFunction;
   569 
   570 #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
   571 	typedef void (*GenericFuncPtr)(); // arbitrary code pointer
   572 	GenericFuncPtr m_pStaticFunction;
   573 #endif
   574 
   575 public:
   576 #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
   577 	DelegateMemento() : m_pthis(0), m_pFunction(0), m_pStaticFunction(0) {};
   578 	void clear() {
   579 		m_pthis=0; m_pFunction=0; m_pStaticFunction=0;
   580 	}
   581 #else
   582 	DelegateMemento() : m_pthis(0), m_pFunction(0) {};
   583 	void clear() {	m_pthis=0; m_pFunction=0;	}
   584 #endif
   585 public:
   586 #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
   587 	inline bool IsEqual (const DelegateMemento &x) const{
   588 	    // We have to cope with the static function pointers as a special case
   589 		if (m_pFunction!=x.m_pFunction) return false;
   590 		// the static function ptrs must either both be equal, or both be 0.
   591 		if (m_pStaticFunction!=x.m_pStaticFunction) return false;
   592 		if (m_pStaticFunction!=0) return m_pthis==x.m_pthis;
   593 		else return true;
   594 	}
   595 #else // Evil Method
   596 	inline bool IsEqual (const DelegateMemento &x) const{
   597 		return m_pthis==x.m_pthis && m_pFunction==x.m_pFunction;
   598 	}
   599 #endif
   600 	// Provide a strict weak ordering for DelegateMementos.
   601 	inline bool IsLess(const DelegateMemento &right) const {
   602 		// deal with static function pointers first
   603 #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
   604 		if (m_pStaticFunction !=0 || right.m_pStaticFunction!=0)
   605 				return m_pStaticFunction < right.m_pStaticFunction;
   606 #endif
   607 		if (m_pthis !=right.m_pthis) return m_pthis < right.m_pthis;
   608 	// There are no ordering operators for member function pointers,
   609 	// but we can fake one by comparing each byte. The resulting ordering is
   610 	// arbitrary (and compiler-dependent), but it permits storage in ordered STL containers.
   611 		return memcmp(&m_pFunction, &right.m_pFunction, sizeof(m_pFunction)) < 0;
   612 
   613 	}
   614 	// BUGFIX (Mar 2005):
   615 	// We can't just compare m_pFunction because on Metrowerks,
   616 	// m_pFunction can be zero even if the delegate is not empty!
   617 	inline bool operator ! () const		// Is it bound to anything?
   618 	{ return m_pthis==0 && m_pFunction==0; }
   619 	inline bool empty() const		// Is it bound to anything?
   620 	{ return m_pthis==0 && m_pFunction==0; }
   621 public:
   622 	DelegateMemento & operator = (const DelegateMemento &right)  {
   623 		SetMementoFrom(right);
   624 		return *this;
   625 	}
   626 	inline bool operator <(const DelegateMemento &right) {
   627 		return IsLess(right);
   628 	}
   629 	inline bool operator >(const DelegateMemento &right) {
   630 		return right.IsLess(*this);
   631 	}
   632 	DelegateMemento (const DelegateMemento &right)  :
   633 		m_pthis(right.m_pthis), m_pFunction(right.m_pFunction)
   634 #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
   635 		, m_pStaticFunction (right.m_pStaticFunction)
   636 #endif
   637 		{}
   638 protected:
   639 	void SetMementoFrom(const DelegateMemento &right)  {
   640 		m_pFunction = right.m_pFunction;
   641 		m_pthis = right.m_pthis;
   642 #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
   643 		m_pStaticFunction = right.m_pStaticFunction;
   644 #endif
   645 	}
   646 };
   647 
   648 
   649 //						ClosurePtr<>
   650 //
   651 // A private wrapper class that adds function signatures to DelegateMemento.
   652 // It's the class that does most of the actual work.
   653 // The signatures are specified by:
   654 // GenericMemFunc: must be a type of GenericClass member function pointer.
   655 // StaticFuncPtr:  must be a type of function pointer with the same signature
   656 //                 as GenericMemFunc.
   657 // UnvoidStaticFuncPtr: is the same as StaticFuncPtr, except on VC6
   658 //                 where it never returns void (returns DefaultVoid instead).
   659 
   660 // An outer class, FastDelegateN<>, handles the invoking and creates the
   661 // necessary typedefs.
   662 // This class does everything else.
   663 
   664 namespace detail {
   665 
   666 template < class GenericMemFunc, class StaticFuncPtr, class UnvoidStaticFuncPtr>
   667 class ClosurePtr : public DelegateMemento {
   668 public:
   669 	// These functions are for setting the delegate to a member function.
   670 
   671 	// Here's the clever bit: we convert an arbitrary member function into a
   672 	// standard form. XMemFunc should be a member function of class X, but I can't
   673 	// enforce that here. It needs to be enforced by the wrapper class.
   674 	template < class X, class XMemFunc >
   675 	inline void bindmemfunc(X *pthis, XMemFunc function_to_bind ) {
   676 		m_pthis = SimplifyMemFunc< sizeof(function_to_bind) >
   677 			::Convert(pthis, function_to_bind, m_pFunction);
   678 #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
   679 		m_pStaticFunction = 0;
   680 #endif
   681 	}
   682 	// For const member functions, we only need a const class pointer.
   683 	// Since we know that the member function is const, it's safe to
   684 	// remove the const qualifier from the 'this' pointer with a const_cast.
   685 	// VC6 has problems if we just overload 'bindmemfunc', so we give it a different name.
   686 	template < class X, class XMemFunc>
   687 	inline void bindconstmemfunc(const X *pthis, XMemFunc function_to_bind) {
   688 		m_pthis= SimplifyMemFunc< sizeof(function_to_bind) >
   689 			::Convert(const_cast<X*>(pthis), function_to_bind, m_pFunction);
   690 #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
   691 		m_pStaticFunction = 0;
   692 #endif
   693 	}
   694 #ifdef FASTDELEGATE_GCC_BUG_8271	// At present, GCC doesn't recognize constness of MFPs in templates
   695 	template < class X, class XMemFunc>
   696 	inline void bindmemfunc(const X *pthis, XMemFunc function_to_bind) {
   697 		bindconstmemfunc(pthis, function_to_bind);
   698 #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
   699 		m_pStaticFunction = 0;
   700 #endif
   701 	}
   702 #endif
   703 	// These functions are required for invoking the stored function
   704 	inline GenericClass *GetClosureThis() const { return m_pthis; }
   705 	inline GenericMemFunc GetClosureMemPtr() const { return reinterpret_cast<GenericMemFunc>(m_pFunction); }
   706 
   707 // There are a few ways of dealing with static function pointers.
   708 // There's a standard-compliant, but tricky method.
   709 // There's also a straightforward hack, that won't work on DOS compilers using the
   710 // medium memory model. It's so evil that I can't recommend it, but I've
   711 // implemented it anyway because it produces very nice asm code.
   712 
   713 #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
   714 
   715 //				ClosurePtr<> - Safe version
   716 //
   717 // This implementation is standard-compliant, but a bit tricky.
   718 // I store the function pointer inside the class, and the delegate then
   719 // points to itself. Whenever the delegate is copied, these self-references
   720 // must be transformed, and this complicates the = and == operators.
   721 public:
   722 	// The next two functions are for operator ==, =, and the copy constructor.
   723 	// We may need to convert the m_pthis pointers, so that
   724 	// they remain as self-references.
   725 	template< class DerivedClass >
   726 	inline void CopyFrom (DerivedClass *pParent, const DelegateMemento &x) {
   727 		SetMementoFrom(x);
   728 		if (m_pStaticFunction!=0) {
   729 			// transform self references...
   730 			m_pthis=reinterpret_cast<GenericClass *>(pParent);
   731 		}
   732 	}
   733 	// For static functions, the 'static_function_invoker' class in the parent
   734 	// will be called. The parent then needs to call GetStaticFunction() to find out
   735 	// the actual function to invoke.
   736 	template < class DerivedClass, class ParentInvokerSig >
   737 	inline void bindstaticfunc(DerivedClass *pParent, ParentInvokerSig static_function_invoker,
   738 				StaticFuncPtr function_to_bind ) {
   739 		if (function_to_bind==0) { // cope with assignment to 0
   740 			m_pFunction=0;
   741 		} else {
   742 			bindmemfunc(pParent, static_function_invoker);
   743         }
   744 		m_pStaticFunction=reinterpret_cast<GenericFuncPtr>(function_to_bind);
   745 	}
   746 	inline UnvoidStaticFuncPtr GetStaticFunction() const {
   747 		return reinterpret_cast<UnvoidStaticFuncPtr>(m_pStaticFunction);
   748 	}
   749 #else
   750 
   751 //				ClosurePtr<> - Evil version
   752 //
   753 // For compilers where data pointers are at least as big as code pointers, it is
   754 // possible to store the function pointer in the this pointer, using another
   755 // horrible_cast. Invocation isn't any faster, but it saves 4 bytes, and
   756 // speeds up comparison and assignment. If C++ provided direct language support
   757 // for delegates, they would produce asm code that was almost identical to this.
   758 // Note that the Sun C++ and MSVC documentation explicitly state that they
   759 // support static_cast between void * and function pointers.
   760 
   761 	template< class DerivedClass >
   762 	inline void CopyFrom (DerivedClass *pParent, const DelegateMemento &right) {
   763 		SetMementoFrom(right);
   764 	}
   765 	// For static functions, the 'static_function_invoker' class in the parent
   766 	// will be called. The parent then needs to call GetStaticFunction() to find out
   767 	// the actual function to invoke.
   768 	// ******** EVIL, EVIL CODE! *******
   769 	template < 	class DerivedClass, class ParentInvokerSig>
   770 	inline void bindstaticfunc(DerivedClass *pParent, ParentInvokerSig static_function_invoker,
   771 				StaticFuncPtr function_to_bind) {
   772 		if (function_to_bind==0) { // cope with assignment to 0
   773 			m_pFunction=0;
   774 		} else { 
   775 		   // We'll be ignoring the 'this' pointer, but we need to make sure we pass
   776 		   // a valid value to bindmemfunc().
   777 			bindmemfunc(pParent, static_function_invoker);
   778         }
   779 
   780 		// WARNING! Evil hack. We store the function in the 'this' pointer!
   781 		// Ensure that there's a compilation failure if function pointers
   782 		// and data pointers have different sizes.
   783 		// If you get this error, you need to #undef FASTDELEGATE_USESTATICFUNCTIONHACK.
   784 		typedef int ERROR_CantUseEvilMethod[sizeof(GenericClass *)==sizeof(function_to_bind) ? 1 : -1];
   785 		m_pthis = horrible_cast<GenericClass *>(function_to_bind);
   786 		// MSVC, SunC++ and DMC accept the following (non-standard) code:
   787 //		m_pthis = static_cast<GenericClass *>(static_cast<void *>(function_to_bind));
   788 		// BCC32, Comeau and DMC accept this method. MSVC7.1 needs __int64 instead of long
   789 //		m_pthis = reinterpret_cast<GenericClass *>(reinterpret_cast<long>(function_to_bind));
   790 	}
   791 	// ******** EVIL, EVIL CODE! *******
   792 	// This function will be called with an invalid 'this' pointer!!
   793 	// We're just returning the 'this' pointer, converted into
   794 	// a function pointer!
   795 	inline UnvoidStaticFuncPtr GetStaticFunction() const {
   796 		// Ensure that there's a compilation failure if function pointers
   797 		// and data pointers have different sizes.
   798 		// If you get this error, you need to #undef FASTDELEGATE_USESTATICFUNCTIONHACK.
   799 		typedef int ERROR_CantUseEvilMethod[sizeof(UnvoidStaticFuncPtr)==sizeof(this) ? 1 : -1];
   800 		return horrible_cast<UnvoidStaticFuncPtr>(this);
   801 	}
   802 #endif // !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
   803 
   804 	// Does the closure contain this static function?
   805 	inline bool IsEqualToStaticFuncPtr(StaticFuncPtr funcptr){
   806 		if (funcptr==0) return empty();
   807 	// For the Evil method, if it doesn't actually contain a static function, this will return an arbitrary
   808 	// value that is not equal to any valid function pointer.
   809 		else return funcptr==reinterpret_cast<StaticFuncPtr>(GetStaticFunction());
   810 	}
   811 };
   812 
   813 
   814 } // namespace detail
   815 
   816 ////////////////////////////////////////////////////////////////////////////////
   817 //						Fast Delegates, part 3:
   818 //
   819 //				Wrapper classes to ensure type safety
   820 //
   821 ////////////////////////////////////////////////////////////////////////////////
   822 
   823 
   824 // Once we have the member function conversion templates, it's easy to make the
   825 // wrapper classes. So that they will work with as many compilers as possible,
   826 // the classes are of the form
   827 //   FastDelegate3<int, char *, double>
   828 // They can cope with any combination of parameters. The max number of parameters
   829 // allowed is 8, but it is trivial to increase this limit.
   830 // Note that we need to treat const member functions seperately.
   831 // All this class does is to enforce type safety, and invoke the delegate with
   832 // the correct list of parameters.
   833 
   834 // Because of the weird rule about the class of derived member function pointers,
   835 // you sometimes need to apply a downcast to the 'this' pointer.
   836 // This is the reason for the use of "implicit_cast<X*>(pthis)" in the code below.
   837 // If CDerivedClass is derived from CBaseClass, but doesn't override SimpleVirtualFunction,
   838 // without this trick you'd need to write:
   839 //		MyDelegate(static_cast<CBaseClass *>(&d), &CDerivedClass::SimpleVirtualFunction);
   840 // but with the trick you can write
   841 //		MyDelegate(&d, &CDerivedClass::SimpleVirtualFunction);
   842 
   843 // RetType is the type the compiler uses in compiling the template. For VC6,
   844 // it cannot be void. DesiredRetType is the real type which is returned from
   845 // all of the functions. It can be void.
   846 
   847 // Implicit conversion to "bool" is achieved using the safe_bool idiom,
   848 // using member data pointers (MDP). This allows "if (dg)..." syntax
   849 // Because some compilers (eg codeplay) don't have a unique value for a zero
   850 // MDP, an extra padding member is added to the SafeBool struct.
   851 // Some compilers (eg VC6) won't implicitly convert from 0 to an MDP, so
   852 // in that case the static function constructor is not made explicit; this
   853 // allows "if (dg==0) ..." to compile.
   854 
   855 //N=0
   856 template<class RetType=detail::DefaultVoid>
   857 class FastDelegate0 {
   858 private:
   859 	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
   860 	typedef DesiredRetType (*StaticFunctionPtr)();
   861 	typedef RetType (*UnvoidStaticFunctionPtr)();
   862 	typedef RetType (detail::GenericClass::*GenericMemFn)();
   863 	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   864 	ClosureType m_Closure;
   865 public:
   866 	// Typedefs to aid generic programming
   867 	typedef FastDelegate0 type;
   868 
   869 	// Construction and comparison functions
   870 	FastDelegate0() { clear(); }
   871 	FastDelegate0(const FastDelegate0 &x) {
   872 		m_Closure.CopyFrom(this, x.m_Closure); }
   873 	void operator = (const FastDelegate0 &x)  {
   874 		m_Closure.CopyFrom(this, x.m_Closure); }
   875 	bool operator ==(const FastDelegate0 &x) const {
   876 		return m_Closure.IsEqual(x.m_Closure);	}
   877 	bool operator !=(const FastDelegate0 &x) const {
   878 		return !m_Closure.IsEqual(x.m_Closure); }
   879 	bool operator <(const FastDelegate0 &x) const {
   880 		return m_Closure.IsLess(x.m_Closure);	}
   881 	bool operator >(const FastDelegate0 &x) const {
   882 		return x.m_Closure.IsLess(m_Closure);	}
   883 	// Binding to non-const member functions
   884 	template < class X, class Y >
   885 	FastDelegate0(Y *pthis, DesiredRetType (X::* function_to_bind)() ) {
   886 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
   887 	template < class X, class Y >
   888 	inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)()) {
   889 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
   890 	// Binding to const member functions.
   891 	template < class X, class Y >
   892 	FastDelegate0(const Y *pthis, DesiredRetType (X::* function_to_bind)() const) {
   893 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
   894 	template < class X, class Y >
   895 	inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)() const) {
   896 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   897 	// Static functions. We convert them into a member function call.
   898 	// This constructor also provides implicit conversion
   899 	FastDelegate0(DesiredRetType (*function_to_bind)() ) {
   900 		bind(function_to_bind);	}
   901 	// for efficiency, prevent creation of a temporary
   902 	void operator = (DesiredRetType (*function_to_bind)() ) {
   903 		bind(function_to_bind);	}
   904 	inline void bind(DesiredRetType (*function_to_bind)()) {
   905 		m_Closure.bindstaticfunc(this, &FastDelegate0::InvokeStaticFunction,
   906 			function_to_bind); }
   907 	// Invoke the delegate
   908 	RetType operator() () const {
   909 	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(); }
   910 	// Implicit conversion to "bool" using the safe_bool idiom
   911 private:
   912 	typedef struct SafeBoolStruct {
   913 		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   914 		StaticFunctionPtr m_nonzero;
   915 	} UselessTypedef;
   916     typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   917 public:
   918 	operator unspecified_bool_type() const {
   919         return empty()? 0: &SafeBoolStruct::m_nonzero;
   920     }
   921 	// necessary to allow ==0 to work despite the safe_bool idiom
   922 	inline bool operator==(StaticFunctionPtr funcptr) {
   923 		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
   924 	inline bool operator!=(StaticFunctionPtr funcptr) { 
   925 		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
   926 	inline bool operator ! () const	{	// Is it bound to anything?
   927 			return !m_Closure; }
   928 	inline bool empty() const	{
   929 			return !m_Closure; }
   930 	void clear() { m_Closure.clear();}
   931 	// Conversion to and from the DelegateMemento storage class
   932 	const DelegateMemento & GetMemento() { return m_Closure; }
   933 	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
   934 
   935 private:	// Invoker for static functions
   936 	RetType InvokeStaticFunction() const {
   937 	return (*(m_Closure.GetStaticFunction()))(); }
   938 };
   939 
   940 //N=1
   941 template<class Param1, class RetType=detail::DefaultVoid>
   942 class FastDelegate1 {
   943 private:
   944 	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
   945 	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1);
   946 	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1);
   947 	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1);
   948 	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   949 	ClosureType m_Closure;
   950 public:
   951 	// Typedefs to aid generic programming
   952 	typedef FastDelegate1 type;
   953 
   954 	// Construction and comparison functions
   955 	FastDelegate1() { clear(); }
   956 	FastDelegate1(const FastDelegate1 &x) {
   957 		m_Closure.CopyFrom(this, x.m_Closure); }
   958 	void operator = (const FastDelegate1 &x)  {
   959 		m_Closure.CopyFrom(this, x.m_Closure); }
   960 	bool operator ==(const FastDelegate1 &x) const {
   961 		return m_Closure.IsEqual(x.m_Closure);	}
   962 	bool operator !=(const FastDelegate1 &x) const {
   963 		return !m_Closure.IsEqual(x.m_Closure); }
   964 	bool operator <(const FastDelegate1 &x) const {
   965 		return m_Closure.IsLess(x.m_Closure);	}
   966 	bool operator >(const FastDelegate1 &x) const {
   967 		return x.m_Closure.IsLess(m_Closure);	}
   968 	// Binding to non-const member functions
   969 	template < class X, class Y >
   970 	FastDelegate1(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1) ) {
   971 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
   972 	template < class X, class Y >
   973 	inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1)) {
   974 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
   975 	// Binding to const member functions.
   976 	template < class X, class Y >
   977 	FastDelegate1(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1) const) {
   978 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
   979 	template < class X, class Y >
   980 	inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1) const) {
   981 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   982 	// Static functions. We convert them into a member function call.
   983 	// This constructor also provides implicit conversion
   984 	FastDelegate1(DesiredRetType (*function_to_bind)(Param1 p1) ) {
   985 		bind(function_to_bind);	}
   986 	// for efficiency, prevent creation of a temporary
   987 	void operator = (DesiredRetType (*function_to_bind)(Param1 p1) ) {
   988 		bind(function_to_bind);	}
   989 	inline void bind(DesiredRetType (*function_to_bind)(Param1 p1)) {
   990 		m_Closure.bindstaticfunc(this, &FastDelegate1::InvokeStaticFunction,
   991 			function_to_bind); }
   992 	// Invoke the delegate
   993 	RetType operator() (Param1 p1) const {
   994 	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1); }
   995 	// Implicit conversion to "bool" using the safe_bool idiom
   996 private:
   997 	typedef struct SafeBoolStruct {
   998 		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   999 		StaticFunctionPtr m_nonzero;
  1000 	} UselessTypedef;
  1001     typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  1002 public:
  1003 	operator unspecified_bool_type() const {
  1004         return empty()? 0: &SafeBoolStruct::m_nonzero;
  1005     }
  1006 	// necessary to allow ==0 to work despite the safe_bool idiom
  1007 	inline bool operator==(StaticFunctionPtr funcptr) {
  1008 		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
  1009 	inline bool operator!=(StaticFunctionPtr funcptr) { 
  1010 		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
  1011 	inline bool operator ! () const	{	// Is it bound to anything?
  1012 			return !m_Closure; }
  1013 	inline bool empty() const	{
  1014 			return !m_Closure; }
  1015 	void clear() { m_Closure.clear();}
  1016 	// Conversion to and from the DelegateMemento storage class
  1017 	const DelegateMemento & GetMemento() { return m_Closure; }
  1018 	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
  1019 
  1020 private:	// Invoker for static functions
  1021 	RetType InvokeStaticFunction(Param1 p1) const {
  1022 	return (*(m_Closure.GetStaticFunction()))(p1); }
  1023 };
  1024 
  1025 //N=2
  1026 template<class Param1, class Param2, class RetType=detail::DefaultVoid>
  1027 class FastDelegate2 {
  1028 private:
  1029 	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
  1030 	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2);
  1031 	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2);
  1032 	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2);
  1033 	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
  1034 	ClosureType m_Closure;
  1035 public:
  1036 	// Typedefs to aid generic programming
  1037 	typedef FastDelegate2 type;
  1038 
  1039 	// Construction and comparison functions
  1040 	FastDelegate2() { clear(); }
  1041 	FastDelegate2(const FastDelegate2 &x) {
  1042 		m_Closure.CopyFrom(this, x.m_Closure); }
  1043 	void operator = (const FastDelegate2 &x)  {
  1044 		m_Closure.CopyFrom(this, x.m_Closure); }
  1045 	bool operator ==(const FastDelegate2 &x) const {
  1046 		return m_Closure.IsEqual(x.m_Closure);	}
  1047 	bool operator !=(const FastDelegate2 &x) const {
  1048 		return !m_Closure.IsEqual(x.m_Closure); }
  1049 	bool operator <(const FastDelegate2 &x) const {
  1050 		return m_Closure.IsLess(x.m_Closure);	}
  1051 	bool operator >(const FastDelegate2 &x) const {
  1052 		return x.m_Closure.IsLess(m_Closure);	}
  1053 	// Binding to non-const member functions
  1054 	template < class X, class Y >
  1055 	FastDelegate2(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2) ) {
  1056 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
  1057 	template < class X, class Y >
  1058 	inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2)) {
  1059 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
  1060 	// Binding to const member functions.
  1061 	template < class X, class Y >
  1062 	FastDelegate2(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2) const) {
  1063 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
  1064 	template < class X, class Y >
  1065 	inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2) const) {
  1066 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
  1067 	// Static functions. We convert them into a member function call.
  1068 	// This constructor also provides implicit conversion
  1069 	FastDelegate2(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2) ) {
  1070 		bind(function_to_bind);	}
  1071 	// for efficiency, prevent creation of a temporary
  1072 	void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2) ) {
  1073 		bind(function_to_bind);	}
  1074 	inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2)) {
  1075 		m_Closure.bindstaticfunc(this, &FastDelegate2::InvokeStaticFunction,
  1076 			function_to_bind); }
  1077 	// Invoke the delegate
  1078 	RetType operator() (Param1 p1, Param2 p2) const {
  1079 	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2); }
  1080 	// Implicit conversion to "bool" using the safe_bool idiom
  1081 private:
  1082 	typedef struct SafeBoolStruct {
  1083 		int a_data_pointer_to_this_is_0_on_buggy_compilers;
  1084 		StaticFunctionPtr m_nonzero;
  1085 	} UselessTypedef;
  1086     typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  1087 public:
  1088 	operator unspecified_bool_type() const {
  1089         return empty()? 0: &SafeBoolStruct::m_nonzero;
  1090     }
  1091 	// necessary to allow ==0 to work despite the safe_bool idiom
  1092 	inline bool operator==(StaticFunctionPtr funcptr) {
  1093 		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
  1094 	inline bool operator!=(StaticFunctionPtr funcptr) { 
  1095 		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
  1096 	inline bool operator ! () const	{	// Is it bound to anything?
  1097 			return !m_Closure; }
  1098 	inline bool empty() const	{
  1099 			return !m_Closure; }
  1100 	void clear() { m_Closure.clear();}
  1101 	// Conversion to and from the DelegateMemento storage class
  1102 	const DelegateMemento & GetMemento() { return m_Closure; }
  1103 	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
  1104 
  1105 private:	// Invoker for static functions
  1106 	RetType InvokeStaticFunction(Param1 p1, Param2 p2) const {
  1107 	return (*(m_Closure.GetStaticFunction()))(p1, p2); }
  1108 };
  1109 
  1110 //N=3
  1111 template<class Param1, class Param2, class Param3, class RetType=detail::DefaultVoid>
  1112 class FastDelegate3 {
  1113 private:
  1114 	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
  1115 	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3);
  1116 	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3);
  1117 	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3);
  1118 	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
  1119 	ClosureType m_Closure;
  1120 public:
  1121 	// Typedefs to aid generic programming
  1122 	typedef FastDelegate3 type;
  1123 
  1124 	// Construction and comparison functions
  1125 	FastDelegate3() { clear(); }
  1126 	FastDelegate3(const FastDelegate3 &x) {
  1127 		m_Closure.CopyFrom(this, x.m_Closure); }
  1128 	void operator = (const FastDelegate3 &x)  {
  1129 		m_Closure.CopyFrom(this, x.m_Closure); }
  1130 	bool operator ==(const FastDelegate3 &x) const {
  1131 		return m_Closure.IsEqual(x.m_Closure);	}
  1132 	bool operator !=(const FastDelegate3 &x) const {
  1133 		return !m_Closure.IsEqual(x.m_Closure); }
  1134 	bool operator <(const FastDelegate3 &x) const {
  1135 		return m_Closure.IsLess(x.m_Closure);	}
  1136 	bool operator >(const FastDelegate3 &x) const {
  1137 		return x.m_Closure.IsLess(m_Closure);	}
  1138 	// Binding to non-const member functions
  1139 	template < class X, class Y >
  1140 	FastDelegate3(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3) ) {
  1141 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
  1142 	template < class X, class Y >
  1143 	inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3)) {
  1144 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
  1145 	// Binding to const member functions.
  1146 	template < class X, class Y >
  1147 	FastDelegate3(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3) const) {
  1148 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
  1149 	template < class X, class Y >
  1150 	inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3) const) {
  1151 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
  1152 	// Static functions. We convert them into a member function call.
  1153 	// This constructor also provides implicit conversion
  1154 	FastDelegate3(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3) ) {
  1155 		bind(function_to_bind);	}
  1156 	// for efficiency, prevent creation of a temporary
  1157 	void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3) ) {
  1158 		bind(function_to_bind);	}
  1159 	inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3)) {
  1160 		m_Closure.bindstaticfunc(this, &FastDelegate3::InvokeStaticFunction,
  1161 			function_to_bind); }
  1162 	// Invoke the delegate
  1163 	RetType operator() (Param1 p1, Param2 p2, Param3 p3) const {
  1164 	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3); }
  1165 	// Implicit conversion to "bool" using the safe_bool idiom
  1166 private:
  1167 	typedef struct SafeBoolStruct {
  1168 		int a_data_pointer_to_this_is_0_on_buggy_compilers;
  1169 		StaticFunctionPtr m_nonzero;
  1170 	} UselessTypedef;
  1171     typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  1172 public:
  1173 	operator unspecified_bool_type() const {
  1174         return empty()? 0: &SafeBoolStruct::m_nonzero;
  1175     }
  1176 	// necessary to allow ==0 to work despite the safe_bool idiom
  1177 	inline bool operator==(StaticFunctionPtr funcptr) {
  1178 		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
  1179 	inline bool operator!=(StaticFunctionPtr funcptr) { 
  1180 		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
  1181 	inline bool operator ! () const	{	// Is it bound to anything?
  1182 			return !m_Closure; }
  1183 	inline bool empty() const	{
  1184 			return !m_Closure; }
  1185 	void clear() { m_Closure.clear();}
  1186 	// Conversion to and from the DelegateMemento storage class
  1187 	const DelegateMemento & GetMemento() { return m_Closure; }
  1188 	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
  1189 
  1190 private:	// Invoker for static functions
  1191 	RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3) const {
  1192 	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3); }
  1193 };
  1194 
  1195 //N=4
  1196 template<class Param1, class Param2, class Param3, class Param4, class RetType=detail::DefaultVoid>
  1197 class FastDelegate4 {
  1198 private:
  1199 	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
  1200 	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4);
  1201 	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4);
  1202 	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4);
  1203 	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
  1204 	ClosureType m_Closure;
  1205 public:
  1206 	// Typedefs to aid generic programming
  1207 	typedef FastDelegate4 type;
  1208 
  1209 	// Construction and comparison functions
  1210 	FastDelegate4() { clear(); }
  1211 	FastDelegate4(const FastDelegate4 &x) {
  1212 		m_Closure.CopyFrom(this, x.m_Closure); }
  1213 	void operator = (const FastDelegate4 &x)  {
  1214 		m_Closure.CopyFrom(this, x.m_Closure); }
  1215 	bool operator ==(const FastDelegate4 &x) const {
  1216 		return m_Closure.IsEqual(x.m_Closure);	}
  1217 	bool operator !=(const FastDelegate4 &x) const {
  1218 		return !m_Closure.IsEqual(x.m_Closure); }
  1219 	bool operator <(const FastDelegate4 &x) const {
  1220 		return m_Closure.IsLess(x.m_Closure);	}
  1221 	bool operator >(const FastDelegate4 &x) const {
  1222 		return x.m_Closure.IsLess(m_Closure);	}
  1223 	// Binding to non-const member functions
  1224 	template < class X, class Y >
  1225 	FastDelegate4(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4) ) {
  1226 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
  1227 	template < class X, class Y >
  1228 	inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4)) {
  1229 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
  1230 	// Binding to const member functions.
  1231 	template < class X, class Y >
  1232 	FastDelegate4(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const) {
  1233 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
  1234 	template < class X, class Y >
  1235 	inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const) {
  1236 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
  1237 	// Static functions. We convert them into a member function call.
  1238 	// This constructor also provides implicit conversion
  1239 	FastDelegate4(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4) ) {
  1240 		bind(function_to_bind);	}
  1241 	// for efficiency, prevent creation of a temporary
  1242 	void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4) ) {
  1243 		bind(function_to_bind);	}
  1244 	inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4)) {
  1245 		m_Closure.bindstaticfunc(this, &FastDelegate4::InvokeStaticFunction,
  1246 			function_to_bind); }
  1247 	// Invoke the delegate
  1248 	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4) const {
  1249 	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4); }
  1250 	// Implicit conversion to "bool" using the safe_bool idiom
  1251 private:
  1252 	typedef struct SafeBoolStruct {
  1253 		int a_data_pointer_to_this_is_0_on_buggy_compilers;
  1254 		StaticFunctionPtr m_nonzero;
  1255 	} UselessTypedef;
  1256     typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  1257 public:
  1258 	operator unspecified_bool_type() const {
  1259         return empty()? 0: &SafeBoolStruct::m_nonzero;
  1260     }
  1261 	// necessary to allow ==0 to work despite the safe_bool idiom
  1262 	inline bool operator==(StaticFunctionPtr funcptr) {
  1263 		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
  1264 	inline bool operator!=(StaticFunctionPtr funcptr) { 
  1265 		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
  1266 	inline bool operator ! () const	{	// Is it bound to anything?
  1267 			return !m_Closure; }
  1268 	inline bool empty() const	{
  1269 			return !m_Closure; }
  1270 	void clear() { m_Closure.clear();}
  1271 	// Conversion to and from the DelegateMemento storage class
  1272 	const DelegateMemento & GetMemento() { return m_Closure; }
  1273 	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
  1274 
  1275 private:	// Invoker for static functions
  1276 	RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const {
  1277 	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4); }
  1278 };
  1279 
  1280 //N=5
  1281 template<class Param1, class Param2, class Param3, class Param4, class Param5, class RetType=detail::DefaultVoid>
  1282 class FastDelegate5 {
  1283 private:
  1284 	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
  1285 	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5);
  1286 	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5);
  1287 	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5);
  1288 	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
  1289 	ClosureType m_Closure;
  1290 public:
  1291 	// Typedefs to aid generic programming
  1292 	typedef FastDelegate5 type;
  1293 
  1294 	// Construction and comparison functions
  1295 	FastDelegate5() { clear(); }
  1296 	FastDelegate5(const FastDelegate5 &x) {
  1297 		m_Closure.CopyFrom(this, x.m_Closure); }
  1298 	void operator = (const FastDelegate5 &x)  {
  1299 		m_Closure.CopyFrom(this, x.m_Closure); }
  1300 	bool operator ==(const FastDelegate5 &x) const {
  1301 		return m_Closure.IsEqual(x.m_Closure);	}
  1302 	bool operator !=(const FastDelegate5 &x) const {
  1303 		return !m_Closure.IsEqual(x.m_Closure); }
  1304 	bool operator <(const FastDelegate5 &x) const {
  1305 		return m_Closure.IsLess(x.m_Closure);	}
  1306 	bool operator >(const FastDelegate5 &x) const {
  1307 		return x.m_Closure.IsLess(m_Closure);	}
  1308 	// Binding to non-const member functions
  1309 	template < class X, class Y >
  1310 	FastDelegate5(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) ) {
  1311 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
  1312 	template < class X, class Y >
  1313 	inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5)) {
  1314 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
  1315 	// Binding to const member functions.
  1316 	template < class X, class Y >
  1317 	FastDelegate5(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const) {
  1318 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
  1319 	template < class X, class Y >
  1320 	inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const) {
  1321 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
  1322 	// Static functions. We convert them into a member function call.
  1323 	// This constructor also provides implicit conversion
  1324 	FastDelegate5(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) ) {
  1325 		bind(function_to_bind);	}
  1326 	// for efficiency, prevent creation of a temporary
  1327 	void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) ) {
  1328 		bind(function_to_bind);	}
  1329 	inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5)) {
  1330 		m_Closure.bindstaticfunc(this, &FastDelegate5::InvokeStaticFunction,
  1331 			function_to_bind); }
  1332 	// Invoke the delegate
  1333 	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const {
  1334 	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5); }
  1335 	// Implicit conversion to "bool" using the safe_bool idiom
  1336 private:
  1337 	typedef struct SafeBoolStruct {
  1338 		int a_data_pointer_to_this_is_0_on_buggy_compilers;
  1339 		StaticFunctionPtr m_nonzero;
  1340 	} UselessTypedef;
  1341     typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  1342 public:
  1343 	operator unspecified_bool_type() const {
  1344         return empty()? 0: &SafeBoolStruct::m_nonzero;
  1345     }
  1346 	// necessary to allow ==0 to work despite the safe_bool idiom
  1347 	inline bool operator==(StaticFunctionPtr funcptr) {
  1348 		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
  1349 	inline bool operator!=(StaticFunctionPtr funcptr) { 
  1350 		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
  1351 	inline bool operator ! () const	{	// Is it bound to anything?
  1352 			return !m_Closure; }
  1353 	inline bool empty() const	{
  1354 			return !m_Closure; }
  1355 	void clear() { m_Closure.clear();}
  1356 	// Conversion to and from the DelegateMemento storage class
  1357 	const DelegateMemento & GetMemento() { return m_Closure; }
  1358 	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
  1359 
  1360 private:	// Invoker for static functions
  1361 	RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const {
  1362 	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5); }
  1363 };
  1364 
  1365 //N=6
  1366 template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class RetType=detail::DefaultVoid>
  1367 class FastDelegate6 {
  1368 private:
  1369 	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
  1370 	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6);
  1371 	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6);
  1372 	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6);
  1373 	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
  1374 	ClosureType m_Closure;
  1375 public:
  1376 	// Typedefs to aid generic programming
  1377 	typedef FastDelegate6 type;
  1378 
  1379 	// Construction and comparison functions
  1380 	FastDelegate6() { clear(); }
  1381 	FastDelegate6(const FastDelegate6 &x) {
  1382 		m_Closure.CopyFrom(this, x.m_Closure); }
  1383 	void operator = (const FastDelegate6 &x)  {
  1384 		m_Closure.CopyFrom(this, x.m_Closure); }
  1385 	bool operator ==(const FastDelegate6 &x) const {
  1386 		return m_Closure.IsEqual(x.m_Closure);	}
  1387 	bool operator !=(const FastDelegate6 &x) const {
  1388 		return !m_Closure.IsEqual(x.m_Closure); }
  1389 	bool operator <(const FastDelegate6 &x) const {
  1390 		return m_Closure.IsLess(x.m_Closure);	}
  1391 	bool operator >(const FastDelegate6 &x) const {
  1392 		return x.m_Closure.IsLess(m_Closure);	}
  1393 	// Binding to non-const member functions
  1394 	template < class X, class Y >
  1395 	FastDelegate6(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) ) {
  1396 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
  1397 	template < class X, class Y >
  1398 	inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6)) {
  1399 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
  1400 	// Binding to const member functions.
  1401 	template < class X, class Y >
  1402 	FastDelegate6(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const) {
  1403 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
  1404 	template < class X, class Y >
  1405 	inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const) {
  1406 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
  1407 	// Static functions. We convert them into a member function call.
  1408 	// This constructor also provides implicit conversion
  1409 	FastDelegate6(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) ) {
  1410 		bind(function_to_bind);	}
  1411 	// for efficiency, prevent creation of a temporary
  1412 	void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) ) {
  1413 		bind(function_to_bind);	}
  1414 	inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6)) {
  1415 		m_Closure.bindstaticfunc(this, &FastDelegate6::InvokeStaticFunction,
  1416 			function_to_bind); }
  1417 	// Invoke the delegate
  1418 	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const {
  1419 	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6); }
  1420 	// Implicit conversion to "bool" using the safe_bool idiom
  1421 private:
  1422 	typedef struct SafeBoolStruct {
  1423 		int a_data_pointer_to_this_is_0_on_buggy_compilers;
  1424 		StaticFunctionPtr m_nonzero;
  1425 	} UselessTypedef;
  1426     typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  1427 public:
  1428 	operator unspecified_bool_type() const {
  1429         return empty()? 0: &SafeBoolStruct::m_nonzero;
  1430     }
  1431 	// necessary to allow ==0 to work despite the safe_bool idiom
  1432 	inline bool operator==(StaticFunctionPtr funcptr) {
  1433 		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
  1434 	inline bool operator!=(StaticFunctionPtr funcptr) { 
  1435 		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
  1436 	inline bool operator ! () const	{	// Is it bound to anything?
  1437 			return !m_Closure; }
  1438 	inline bool empty() const	{
  1439 			return !m_Closure; }
  1440 	void clear() { m_Closure.clear();}
  1441 	// Conversion to and from the DelegateMemento storage class
  1442 	const DelegateMemento & GetMemento() { return m_Closure; }
  1443 	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
  1444 
  1445 private:	// Invoker for static functions
  1446 	RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const {
  1447 	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6); }
  1448 };
  1449 
  1450 //N=7
  1451 template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class RetType=detail::DefaultVoid>
  1452 class FastDelegate7 {
  1453 private:
  1454 	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
  1455 	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7);
  1456 	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7);
  1457 	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7);
  1458 	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
  1459 	ClosureType m_Closure;
  1460 public:
  1461 	// Typedefs to aid generic programming
  1462 	typedef FastDelegate7 type;
  1463 
  1464 	// Construction and comparison functions
  1465 	FastDelegate7() { clear(); }
  1466 	FastDelegate7(const FastDelegate7 &x) {
  1467 		m_Closure.CopyFrom(this, x.m_Closure); }
  1468 	void operator = (const FastDelegate7 &x)  {
  1469 		m_Closure.CopyFrom(this, x.m_Closure); }
  1470 	bool operator ==(const FastDelegate7 &x) const {
  1471 		return m_Closure.IsEqual(x.m_Closure);	}
  1472 	bool operator !=(const FastDelegate7 &x) const {
  1473 		return !m_Closure.IsEqual(x.m_Closure); }
  1474 	bool operator <(const FastDelegate7 &x) const {
  1475 		return m_Closure.IsLess(x.m_Closure);	}
  1476 	bool operator >(const FastDelegate7 &x) const {
  1477 		return x.m_Closure.IsLess(m_Closure);	}
  1478 	// Binding to non-const member functions
  1479 	template < class X, class Y >
  1480 	FastDelegate7(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) ) {
  1481 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
  1482 	template < class X, class Y >
  1483 	inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7)) {
  1484 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
  1485 	// Binding to const member functions.
  1486 	template < class X, class Y >
  1487 	FastDelegate7(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const) {
  1488 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
  1489 	template < class X, class Y >
  1490 	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) {
  1491 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
  1492 	// Static functions. We convert them into a member function call.
  1493 	// This constructor also provides implicit conversion
  1494 	FastDelegate7(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) ) {
  1495 		bind(function_to_bind);	}
  1496 	// for efficiency, prevent creation of a temporary
  1497 	void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) ) {
  1498 		bind(function_to_bind);	}
  1499 	inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7)) {
  1500 		m_Closure.bindstaticfunc(this, &FastDelegate7::InvokeStaticFunction,
  1501 			function_to_bind); }
  1502 	// Invoke the delegate
  1503 	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const {
  1504 	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7); }
  1505 	// Implicit conversion to "bool" using the safe_bool idiom
  1506 private:
  1507 	typedef struct SafeBoolStruct {
  1508 		int a_data_pointer_to_this_is_0_on_buggy_compilers;
  1509 		StaticFunctionPtr m_nonzero;
  1510 	} UselessTypedef;
  1511     typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  1512 public:
  1513 	operator unspecified_bool_type() const {
  1514         return empty()? 0: &SafeBoolStruct::m_nonzero;
  1515     }
  1516 	// necessary to allow ==0 to work despite the safe_bool idiom
  1517 	inline bool operator==(StaticFunctionPtr funcptr) {
  1518 		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
  1519 	inline bool operator!=(StaticFunctionPtr funcptr) { 
  1520 		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
  1521 	inline bool operator ! () const	{	// Is it bound to anything?
  1522 			return !m_Closure; }
  1523 	inline bool empty() const	{
  1524 			return !m_Closure; }
  1525 	void clear() { m_Closure.clear();}
  1526 	// Conversion to and from the DelegateMemento storage class
  1527 	const DelegateMemento & GetMemento() { return m_Closure; }
  1528 	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
  1529 
  1530 private:	// Invoker for static functions
  1531 	RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const {
  1532 	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7); }
  1533 };
  1534 
  1535 //N=8
  1536 template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class RetType=detail::DefaultVoid>
  1537 class FastDelegate8 {
  1538 private:
  1539 	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
  1540 	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8);
  1541 	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8);
  1542 	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8);
  1543 	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
  1544 	ClosureType m_Closure;
  1545 public:
  1546 	// Typedefs to aid generic programming
  1547 	typedef FastDelegate8 type;
  1548 
  1549 	// Construction and comparison functions
  1550 	FastDelegate8() { clear(); }
  1551 	FastDelegate8(const FastDelegate8 &x) {
  1552 		m_Closure.CopyFrom(this, x.m_Closure); }
  1553 	void operator = (const FastDelegate8 &x)  {
  1554 		m_Closure.CopyFrom(this, x.m_Closure); }
  1555 	bool operator ==(const FastDelegate8 &x) const {
  1556 		return m_Closure.IsEqual(x.m_Closure);	}
  1557 	bool operator !=(const FastDelegate8 &x) const {
  1558 		return !m_Closure.IsEqual(x.m_Closure); }
  1559 	bool operator <(const FastDelegate8 &x) const {
  1560 		return m_Closure.IsLess(x.m_Closure);	}
  1561 	bool operator >(const FastDelegate8 &x) const {
  1562 		return x.m_Closure.IsLess(m_Closure);	}
  1563 	// Binding to non-const member functions
  1564 	template < class X, class Y >
  1565 	FastDelegate8(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) ) {
  1566 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
  1567 	template < class X, class Y >
  1568 	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)) {
  1569 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
  1570 	// Binding to const member functions.
  1571 	template < class X, class Y >
  1572 	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) {
  1573 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
  1574 	template < class X, class Y >
  1575 	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) {
  1576 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
  1577 	// Static functions. We convert them into a member function call.
  1578 	// This constructor also provides implicit conversion
  1579 	FastDelegate8(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) ) {
  1580 		bind(function_to_bind);	}
  1581 	// for efficiency, prevent creation of a temporary
  1582 	void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) ) {
  1583 		bind(function_to_bind);	}
  1584 	inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8)) {
  1585 		m_Closure.bindstaticfunc(this, &FastDelegate8::InvokeStaticFunction,
  1586 			function_to_bind); }
  1587 	// Invoke the delegate
  1588 	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) const {
  1589 	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8); }
  1590 	// Implicit conversion to "bool" using the safe_bool idiom
  1591 private:
  1592 	typedef struct SafeBoolStruct {
  1593 		int a_data_pointer_to_this_is_0_on_buggy_compilers;
  1594 		StaticFunctionPtr m_nonzero;
  1595 	} UselessTypedef;
  1596     typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  1597 public:
  1598 	operator unspecified_bool_type() const {
  1599         return empty()? 0: &SafeBoolStruct::m_nonzero;
  1600     }
  1601 	// necessary to allow ==0 to work despite the safe_bool idiom
  1602 	inline bool operator==(StaticFunctionPtr funcptr) {
  1603 		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
  1604 	inline bool operator!=(StaticFunctionPtr funcptr) { 
  1605 		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
  1606 	inline bool operator ! () const	{	// Is it bound to anything?
  1607 			return !m_Closure; }
  1608 	inline bool empty() const	{
  1609 			return !m_Closure; }
  1610 	void clear() { m_Closure.clear();}
  1611 	// Conversion to and from the DelegateMemento storage class
  1612 	const DelegateMemento & GetMemento() { return m_Closure; }
  1613 	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
  1614 
  1615 private:	// Invoker for static functions
  1616 	RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) const {
  1617 	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8); }
  1618 };
  1619 
  1620 //N=9
  1621 template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class RetType=detail::DefaultVoid>
  1622 class FastDelegate9 {
  1623 private:
  1624 	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
  1625 	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9);
  1626 	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9);
  1627 	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9);
  1628 	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
  1629 	ClosureType m_Closure;
  1630 public:
  1631 	// Typedefs to aid generic programming
  1632 	typedef FastDelegate9 type;
  1633 
  1634 	// Construction and comparison functions
  1635 	FastDelegate9() { clear(); }
  1636 	FastDelegate9(const FastDelegate9 &x) {
  1637 		m_Closure.CopyFrom(this, x.m_Closure); }
  1638 	void operator = (const FastDelegate9 &x)  {
  1639 		m_Closure.CopyFrom(this, x.m_Closure); }
  1640 	bool operator ==(const FastDelegate9 &x) const {
  1641 		return m_Closure.IsEqual(x.m_Closure);	}
  1642 	bool operator !=(const FastDelegate9 &x) const {
  1643 		return !m_Closure.IsEqual(x.m_Closure); }
  1644 	bool operator <(const FastDelegate9 &x) const {
  1645 		return m_Closure.IsLess(x.m_Closure);	}
  1646 	bool operator >(const FastDelegate9 &x) const {
  1647 		return x.m_Closure.IsLess(m_Closure);	}
  1648 	// Binding to non-const member functions
  1649 	template < class X, class Y >
  1650 	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) ) {
  1651 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
  1652 	template < class X, class Y >
  1653 	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)) {
  1654 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
  1655 	// Binding to const member functions.
  1656 	template < class X, class Y >
  1657 	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) {
  1658 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
  1659 	template < class X, class Y >
  1660 	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) {
  1661 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
  1662 	// Static functions. We convert them into a member function call.
  1663 	// This constructor also provides implicit conversion
  1664 	FastDelegate9(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9) ) {
  1665 		bind(function_to_bind);	}
  1666 	// for efficiency, prevent creation of a temporary
  1667 	void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9) ) {
  1668 		bind(function_to_bind);	}
  1669 	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)) {
  1670 		m_Closure.bindstaticfunc(this, &FastDelegate9::InvokeStaticFunction,
  1671 			function_to_bind); }
  1672 	// Invoke the delegate
  1673 	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9) const {
  1674 	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9); }
  1675 	// Implicit conversion to "bool" using the safe_bool idiom
  1676 private:
  1677 	typedef struct SafeBoolStruct {
  1678 		int a_data_pointer_to_this_is_0_on_buggy_compilers;
  1679 		StaticFunctionPtr m_nonzero;
  1680 	} UselessTypedef;
  1681     typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  1682 public:
  1683 	operator unspecified_bool_type() const {
  1684         return empty()? 0: &SafeBoolStruct::m_nonzero;
  1685     }
  1686 	// necessary to allow ==0 to work despite the safe_bool idiom
  1687 	inline bool operator==(StaticFunctionPtr funcptr) {
  1688 		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
  1689 	inline bool operator!=(StaticFunctionPtr funcptr) { 
  1690 		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
  1691 	inline bool operator ! () const	{	// Is it bound to anything?
  1692 			return !m_Closure; }
  1693 	inline bool empty() const	{
  1694 			return !m_Closure; }
  1695 	void clear() { m_Closure.clear();}
  1696 	// Conversion to and from the DelegateMemento storage class
  1697 	const DelegateMemento & GetMemento() { return m_Closure; }
  1698 	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
  1699 
  1700 private:	// Invoker for static functions
  1701 	RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9) const {
  1702 	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9); }
  1703 };
  1704 
  1705 //N=10
  1706 template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class RetType=detail::DefaultVoid>
  1707 class FastDelegate10 {
  1708 private:
  1709 	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
  1710 	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10);
  1711 	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10);
  1712 	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);
  1713 	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
  1714 	ClosureType m_Closure;
  1715 public:
  1716 	// Typedefs to aid generic programming
  1717 	typedef FastDelegate10 type;
  1718 
  1719 	// Construction and comparison functions
  1720 	FastDelegate10() { clear(); }
  1721 	FastDelegate10(const FastDelegate10 &x) {
  1722 		m_Closure.CopyFrom(this, x.m_Closure); }
  1723 	void operator = (const FastDelegate10 &x)  {
  1724 		m_Closure.CopyFrom(this, x.m_Closure); }
  1725 	bool operator ==(const FastDelegate10 &x) const {
  1726 		return m_Closure.IsEqual(x.m_Closure);	}
  1727 	bool operator !=(const FastDelegate10 &x) const {
  1728 		return !m_Closure.IsEqual(x.m_Closure); }
  1729 	bool operator <(const FastDelegate10 &x) const {
  1730 		return m_Closure.IsLess(x.m_Closure);	}
  1731 	bool operator >(const FastDelegate10 &x) const {
  1732 		return x.m_Closure.IsLess(m_Closure);	}
  1733 	// Binding to non-const member functions
  1734 	template < class X, class Y >
  1735 	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) ) {
  1736 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
  1737 	template < class X, class Y >
  1738 	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)) {
  1739 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
  1740 	// Binding to const member functions.
  1741 	template < class X, class Y >
  1742 	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) {
  1743 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
  1744 	template < class X, class Y >
  1745 	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) {
  1746 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
  1747 	// Static functions. We convert them into a member function call.
  1748 	// This constructor also provides implicit conversion
  1749 	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) ) {
  1750 		bind(function_to_bind);	}
  1751 	// for efficiency, prevent creation of a temporary
  1752 	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) ) {
  1753 		bind(function_to_bind);	}
  1754 	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)) {
  1755 		m_Closure.bindstaticfunc(this, &FastDelegate10::InvokeStaticFunction,
  1756 			function_to_bind); }
  1757 	// Invoke the delegate
  1758 	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10) const {
  1759 	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); }
  1760 	// Implicit conversion to "bool" using the safe_bool idiom
  1761 private:
  1762 	typedef struct SafeBoolStruct {
  1763 		int a_data_pointer_to_this_is_0_on_buggy_compilers;
  1764 		StaticFunctionPtr m_nonzero;
  1765 	} UselessTypedef;
  1766     typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  1767 public:
  1768 	operator unspecified_bool_type() const {
  1769         return empty()? 0: &SafeBoolStruct::m_nonzero;
  1770     }
  1771 	// necessary to allow ==0 to work despite the safe_bool idiom
  1772 	inline bool operator==(StaticFunctionPtr funcptr) {
  1773 		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
  1774 	inline bool operator!=(StaticFunctionPtr funcptr) { 
  1775 		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
  1776 	inline bool operator ! () const	{	// Is it bound to anything?
  1777 			return !m_Closure; }
  1778 	inline bool empty() const	{
  1779 			return !m_Closure; }
  1780 	void clear() { m_Closure.clear();}
  1781 	// Conversion to and from the DelegateMemento storage class
  1782 	const DelegateMemento & GetMemento() { return m_Closure; }
  1783 	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
  1784 
  1785 private:	// Invoker for static functions
  1786 	RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10) const {
  1787 	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); }
  1788 };
  1789 
  1790 //N=11
  1791 template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class RetType=detail::DefaultVoid>
  1792 class FastDelegate11 {
  1793 private:
  1794 	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
  1795 	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);
  1796 	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);
  1797 	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);
  1798 	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
  1799 	ClosureType m_Closure;
  1800 public:
  1801 	// Typedefs to aid generic programming
  1802 	typedef FastDelegate11 type;
  1803 
  1804 	// Construction and comparison functions
  1805 	FastDelegate11() { clear(); }
  1806 	FastDelegate11(const FastDelegate11 &x) {
  1807 		m_Closure.CopyFrom(this, x.m_Closure); }
  1808 	void operator = (const FastDelegate11 &x)  {
  1809 		m_Closure.CopyFrom(this, x.m_Closure); }
  1810 	bool operator ==(const FastDelegate11 &x) const {
  1811 		return m_Closure.IsEqual(x.m_Closure);	}
  1812 	bool operator !=(const FastDelegate11 &x) const {
  1813 		return !m_Closure.IsEqual(x.m_Closure); }
  1814 	bool operator <(const FastDelegate11 &x) const {
  1815 		return m_Closure.IsLess(x.m_Closure);	}
  1816 	bool operator >(const FastDelegate11 &x) const {
  1817 		return x.m_Closure.IsLess(m_Closure);	}
  1818 	// Binding to non-const member functions
  1819 	template < class X, class Y >
  1820 	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) ) {
  1821 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
  1822 	template < class X, class Y >
  1823 	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)) {
  1824 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
  1825 	// Binding to const member functions.
  1826 	template < class X, class Y >
  1827 	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) {
  1828 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
  1829 	template < class X, class Y >
  1830 	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) {
  1831 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
  1832 	// Static functions. We convert them into a member function call.
  1833 	// This constructor also provides implicit conversion
  1834 	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) ) {
  1835 		bind(function_to_bind);	}
  1836 	// for efficiency, prevent creation of a temporary
  1837 	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) ) {
  1838 		bind(function_to_bind);	}
  1839 	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)) {
  1840 		m_Closure.bindstaticfunc(this, &FastDelegate11::InvokeStaticFunction,
  1841 			function_to_bind); }
  1842 	// Invoke the delegate
  1843 	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 {
  1844 	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); }
  1845 	// Implicit conversion to "bool" using the safe_bool idiom
  1846 private:
  1847 	typedef struct SafeBoolStruct {
  1848 		int a_data_pointer_to_this_is_0_on_buggy_compilers;
  1849 		StaticFunctionPtr m_nonzero;
  1850 	} UselessTypedef;
  1851     typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  1852 public:
  1853 	operator unspecified_bool_type() const {
  1854         return empty()? 0: &SafeBoolStruct::m_nonzero;
  1855     }
  1856 	// necessary to allow ==0 to work despite the safe_bool idiom
  1857 	inline bool operator==(StaticFunctionPtr funcptr) {
  1858 		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
  1859 	inline bool operator!=(StaticFunctionPtr funcptr) { 
  1860 		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
  1861 	inline bool operator ! () const	{	// Is it bound to anything?
  1862 			return !m_Closure; }
  1863 	inline bool empty() const	{
  1864 			return !m_Closure; }
  1865 	void clear() { m_Closure.clear();}
  1866 	// Conversion to and from the DelegateMemento storage class
  1867 	const DelegateMemento & GetMemento() { return m_Closure; }
  1868 	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
  1869 
  1870 private:	// Invoker for static functions
  1871 	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 {
  1872 	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); }
  1873 };
  1874 
  1875 //N=12
  1876 template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class RetType=detail::DefaultVoid>
  1877 class FastDelegate12 {
  1878 private:
  1879 	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
  1880 	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);
  1881 	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);
  1882 	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);
  1883 	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
  1884 	ClosureType m_Closure;
  1885 public:
  1886 	// Typedefs to aid generic programming
  1887 	typedef FastDelegate12 type;
  1888 
  1889 	// Construction and comparison functions
  1890 	FastDelegate12() { clear(); }
  1891 	FastDelegate12(const FastDelegate12 &x) {
  1892 		m_Closure.CopyFrom(this, x.m_Closure); }
  1893 	void operator = (const FastDelegate12 &x)  {
  1894 		m_Closure.CopyFrom(this, x.m_Closure); }
  1895 	bool operator ==(const FastDelegate12 &x) const {
  1896 		return m_Closure.IsEqual(x.m_Closure);	}
  1897 	bool operator !=(const FastDelegate12 &x) const {
  1898 		return !m_Closure.IsEqual(x.m_Closure); }
  1899 	bool operator <(const FastDelegate12 &x) const {
  1900 		return m_Closure.IsLess(x.m_Closure);	}
  1901 	bool operator >(const FastDelegate12 &x) const {
  1902 		return x.m_Closure.IsLess(m_Closure);	}
  1903 	// Binding to non-const member functions
  1904 	template < class X, class Y >
  1905 	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) ) {
  1906 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
  1907 	template < class X, class Y >
  1908 	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)) {
  1909 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
  1910 	// Binding to const member functions.
  1911 	template < class X, class Y >
  1912 	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) {
  1913 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
  1914 	template < class X, class Y >
  1915 	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) {
  1916 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
  1917 	// Static functions. We convert them into a member function call.
  1918 	// This constructor also provides implicit conversion
  1919 	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) ) {
  1920 		bind(function_to_bind);	}
  1921 	// for efficiency, prevent creation of a temporary
  1922 	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) ) {
  1923 		bind(function_to_bind);	}
  1924 	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)) {
  1925 		m_Closure.bindstaticfunc(this, &FastDelegate12::InvokeStaticFunction,
  1926 			function_to_bind); }
  1927 	// Invoke the delegate
  1928 	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 {
  1929 	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); }
  1930 	// Implicit conversion to "bool" using the safe_bool idiom
  1931 private:
  1932 	typedef struct SafeBoolStruct {
  1933 		int a_data_pointer_to_this_is_0_on_buggy_compilers;
  1934 		StaticFunctionPtr m_nonzero;
  1935 	} UselessTypedef;
  1936     typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  1937 public:
  1938 	operator unspecified_bool_type() const {
  1939         return empty()? 0: &SafeBoolStruct::m_nonzero;
  1940     }
  1941 	// necessary to allow ==0 to work despite the safe_bool idiom
  1942 	inline bool operator==(StaticFunctionPtr funcptr) {
  1943 		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
  1944 	inline bool operator!=(StaticFunctionPtr funcptr) { 
  1945 		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
  1946 	inline bool operator ! () const	{	// Is it bound to anything?
  1947 			return !m_Closure; }
  1948 	inline bool empty() const	{
  1949 			return !m_Closure; }
  1950 	void clear() { m_Closure.clear();}
  1951 	// Conversion to and from the DelegateMemento storage class
  1952 	const DelegateMemento & GetMemento() { return m_Closure; }
  1953 	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
  1954 
  1955 private:	// Invoker for static functions
  1956 	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 {
  1957 	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); }
  1958 };
  1959 
  1960 //N=13
  1961 template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class RetType=detail::DefaultVoid>
  1962 class FastDelegate13 {
  1963 private:
  1964 	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
  1965 	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);
  1966 	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);
  1967 	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);
  1968 	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
  1969 	ClosureType m_Closure;
  1970 public:
  1971 	// Typedefs to aid generic programming
  1972 	typedef FastDelegate13 type;
  1973 
  1974 	// Construction and comparison functions
  1975 	FastDelegate13() { clear(); }
  1976 	FastDelegate13(const FastDelegate13 &x) {
  1977 		m_Closure.CopyFrom(this, x.m_Closure); }
  1978 	void operator = (const FastDelegate13 &x)  {
  1979 		m_Closure.CopyFrom(this, x.m_Closure); }
  1980 	bool operator ==(const FastDelegate13 &x) const {
  1981 		return m_Closure.IsEqual(x.m_Closure);	}
  1982 	bool operator !=(const FastDelegate13 &x) const {
  1983 		return !m_Closure.IsEqual(x.m_Closure); }
  1984 	bool operator <(const FastDelegate13 &x) const {
  1985 		return m_Closure.IsLess(x.m_Closure);	}
  1986 	bool operator >(const FastDelegate13 &x) const {
  1987 		return x.m_Closure.IsLess(m_Closure);	}
  1988 	// Binding to non-const member functions
  1989 	template < class X, class Y >
  1990 	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) ) {
  1991 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
  1992 	template < class X, class Y >
  1993 	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)) {
  1994 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
  1995 	// Binding to const member functions.
  1996 	template < class X, class Y >
  1997 	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) {
  1998 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
  1999 	template < class X, class Y >
  2000 	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) {
  2001 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
  2002 	// Static functions. We convert them into a member function call.
  2003 	// This constructor also provides implicit conversion
  2004 	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) ) {
  2005 		bind(function_to_bind);	}
  2006 	// for efficiency, prevent creation of a temporary
  2007 	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) ) {
  2008 		bind(function_to_bind);	}
  2009 	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)) {
  2010 		m_Closure.bindstaticfunc(this, &FastDelegate13::InvokeStaticFunction,
  2011 			function_to_bind); }
  2012 	// Invoke the delegate
  2013 	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 {
  2014 	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); }
  2015 	// Implicit conversion to "bool" using the safe_bool idiom
  2016 private:
  2017 	typedef struct SafeBoolStruct {
  2018 		int a_data_pointer_to_this_is_0_on_buggy_compilers;
  2019 		StaticFunctionPtr m_nonzero;
  2020 	} UselessTypedef;
  2021     typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  2022 public:
  2023 	operator unspecified_bool_type() const {
  2024         return empty()? 0: &SafeBoolStruct::m_nonzero;
  2025     }
  2026 	// necessary to allow ==0 to work despite the safe_bool idiom
  2027 	inline bool operator==(StaticFunctionPtr funcptr) {
  2028 		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
  2029 	inline bool operator!=(StaticFunctionPtr funcptr) { 
  2030 		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
  2031 	inline bool operator ! () const	{	// Is it bound to anything?
  2032 			return !m_Closure; }
  2033 	inline bool empty() const	{
  2034 			return !m_Closure; }
  2035 	void clear() { m_Closure.clear();}
  2036 	// Conversion to and from the DelegateMemento storage class
  2037 	const DelegateMemento & GetMemento() { return m_Closure; }
  2038 	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
  2039 
  2040 private:	// Invoker for static functions
  2041 	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 {
  2042 	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); }
  2043 };
  2044 
  2045 //N=14
  2046 template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class RetType=detail::DefaultVoid>
  2047 class FastDelegate14 {
  2048 private:
  2049 	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
  2050 	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);
  2051 	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);
  2052 	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);
  2053 	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
  2054 	ClosureType m_Closure;
  2055 public:
  2056 	// Typedefs to aid generic programming
  2057 	typedef FastDelegate14 type;
  2058 
  2059 	// Construction and comparison functions
  2060 	FastDelegate14() { clear(); }
  2061 	FastDelegate14(const FastDelegate14 &x) {
  2062 		m_Closure.CopyFrom(this, x.m_Closure); }
  2063 	void operator = (const FastDelegate14 &x)  {
  2064 		m_Closure.CopyFrom(this, x.m_Closure); }
  2065 	bool operator ==(const FastDelegate14 &x) const {
  2066 		return m_Closure.IsEqual(x.m_Closure);	}
  2067 	bool operator !=(const FastDelegate14 &x) const {
  2068 		return !m_Closure.IsEqual(x.m_Closure); }
  2069 	bool operator <(const FastDelegate14 &x) const {
  2070 		return m_Closure.IsLess(x.m_Closure);	}
  2071 	bool operator >(const FastDelegate14 &x) const {
  2072 		return x.m_Closure.IsLess(m_Closure);	}
  2073 	// Binding to non-const member functions
  2074 	template < class X, class Y >
  2075 	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) ) {
  2076 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
  2077 	template < class X, class Y >
  2078 	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)) {
  2079 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
  2080 	// Binding to const member functions.
  2081 	template < class X, class Y >
  2082 	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) {
  2083 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
  2084 	template < class X, class Y >
  2085 	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) {
  2086 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
  2087 	// Static functions. We convert them into a member function call.
  2088 	// This constructor also provides implicit conversion
  2089 	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) ) {
  2090 		bind(function_to_bind);	}
  2091 	// for efficiency, prevent creation of a temporary
  2092 	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) ) {
  2093 		bind(function_to_bind);	}
  2094 	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)) {
  2095 		m_Closure.bindstaticfunc(this, &FastDelegate14::InvokeStaticFunction,
  2096 			function_to_bind); }
  2097 	// Invoke the delegate
  2098 	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 {
  2099 	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); }
  2100 	// Implicit conversion to "bool" using the safe_bool idiom
  2101 private:
  2102 	typedef struct SafeBoolStruct {
  2103 		int a_data_pointer_to_this_is_0_on_buggy_compilers;
  2104 		StaticFunctionPtr m_nonzero;
  2105 	} UselessTypedef;
  2106     typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  2107 public:
  2108 	operator unspecified_bool_type() const {
  2109         return empty()? 0: &SafeBoolStruct::m_nonzero;
  2110     }
  2111 	// necessary to allow ==0 to work despite the safe_bool idiom
  2112 	inline bool operator==(StaticFunctionPtr funcptr) {
  2113 		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
  2114 	inline bool operator!=(StaticFunctionPtr funcptr) { 
  2115 		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
  2116 	inline bool operator ! () const	{	// Is it bound to anything?
  2117 			return !m_Closure; }
  2118 	inline bool empty() const	{
  2119 			return !m_Closure; }
  2120 	void clear() { m_Closure.clear();}
  2121 	// Conversion to and from the DelegateMemento storage class
  2122 	const DelegateMemento & GetMemento() { return m_Closure; }
  2123 	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
  2124 
  2125 private:	// Invoker for static functions
  2126 	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 {
  2127 	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); }
  2128 };
  2129 
  2130 //N=15
  2131 template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class RetType=detail::DefaultVoid>
  2132 class FastDelegate15 {
  2133 private:
  2134 	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
  2135 	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);
  2136 	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);
  2137 	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);
  2138 	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
  2139 	ClosureType m_Closure;
  2140 public:
  2141 	// Typedefs to aid generic programming
  2142 	typedef FastDelegate15 type;
  2143 
  2144 	// Construction and comparison functions
  2145 	FastDelegate15() { clear(); }
  2146 	FastDelegate15(const FastDelegate15 &x) {
  2147 		m_Closure.CopyFrom(this, x.m_Closure); }
  2148 	void operator = (const FastDelegate15 &x)  {
  2149 		m_Closure.CopyFrom(this, x.m_Closure); }
  2150 	bool operator ==(const FastDelegate15 &x) const {
  2151 		return m_Closure.IsEqual(x.m_Closure);	}
  2152 	bool operator !=(const FastDelegate15 &x) const {
  2153 		return !m_Closure.IsEqual(x.m_Closure); }
  2154 	bool operator <(const FastDelegate15 &x) const {
  2155 		return m_Closure.IsLess(x.m_Closure);	}
  2156 	bool operator >(const FastDelegate15 &x) const {
  2157 		return x.m_Closure.IsLess(m_Closure);	}
  2158 	// Binding to non-const member functions
  2159 	template < class X, class Y >
  2160 	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) ) {
  2161 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
  2162 	template < class X, class Y >
  2163 	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)) {
  2164 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
  2165 	// Binding to const member functions.
  2166 	template < class X, class Y >
  2167 	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) {
  2168 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
  2169 	template < class X, class Y >
  2170 	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) {
  2171 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
  2172 	// Static functions. We convert them into a member function call.
  2173 	// This constructor also provides implicit conversion
  2174 	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) ) {
  2175 		bind(function_to_bind);	}
  2176 	// for efficiency, prevent creation of a temporary
  2177 	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) ) {
  2178 		bind(function_to_bind);	}
  2179 	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)) {
  2180 		m_Closure.bindstaticfunc(this, &FastDelegate15::InvokeStaticFunction,
  2181 			function_to_bind); }
  2182 	// Invoke the delegate
  2183 	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 {
  2184 	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); }
  2185 	// Implicit conversion to "bool" using the safe_bool idiom
  2186 private:
  2187 	typedef struct SafeBoolStruct {
  2188 		int a_data_pointer_to_this_is_0_on_buggy_compilers;
  2189 		StaticFunctionPtr m_nonzero;
  2190 	} UselessTypedef;
  2191     typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  2192 public:
  2193 	operator unspecified_bool_type() const {
  2194         return empty()? 0: &SafeBoolStruct::m_nonzero;
  2195     }
  2196 	// necessary to allow ==0 to work despite the safe_bool idiom
  2197 	inline bool operator==(StaticFunctionPtr funcptr) {
  2198 		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
  2199 	inline bool operator!=(StaticFunctionPtr funcptr) { 
  2200 		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
  2201 	inline bool operator ! () const	{	// Is it bound to anything?
  2202 			return !m_Closure; }
  2203 	inline bool empty() const	{
  2204 			return !m_Closure; }
  2205 	void clear() { m_Closure.clear();}
  2206 	// Conversion to and from the DelegateMemento storage class
  2207 	const DelegateMemento & GetMemento() { return m_Closure; }
  2208 	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
  2209 
  2210 private:	// Invoker for static functions
  2211 	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 {
  2212 	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); }
  2213 };
  2214 
  2215 //N=16
  2216 template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16, class RetType=detail::DefaultVoid>
  2217 class FastDelegate16 {
  2218 private:
  2219 	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
  2220 	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);
  2221 	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);
  2222 	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);
  2223 	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
  2224 	ClosureType m_Closure;
  2225 public:
  2226 	// Typedefs to aid generic programming
  2227 	typedef FastDelegate16 type;
  2228 
  2229 	// Construction and comparison functions
  2230 	FastDelegate16() { clear(); }
  2231 	FastDelegate16(const FastDelegate16 &x) {
  2232 		m_Closure.CopyFrom(this, x.m_Closure); }
  2233 	void operator = (const FastDelegate16 &x)  {
  2234 		m_Closure.CopyFrom(this, x.m_Closure); }
  2235 	bool operator ==(const FastDelegate16 &x) const {
  2236 		return m_Closure.IsEqual(x.m_Closure);	}
  2237 	bool operator !=(const FastDelegate16 &x) const {
  2238 		return !m_Closure.IsEqual(x.m_Closure); }
  2239 	bool operator <(const FastDelegate16 &x) const {
  2240 		return m_Closure.IsLess(x.m_Closure);	}
  2241 	bool operator >(const FastDelegate16 &x) const {
  2242 		return x.m_Closure.IsLess(m_Closure);	}
  2243 	// Binding to non-const member functions
  2244 	template < class X, class Y >
  2245 	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) ) {
  2246 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
  2247 	template < class X, class Y >
  2248 	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)) {
  2249 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
  2250 	// Binding to const member functions.
  2251 	template < class X, class Y >
  2252 	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) {
  2253 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
  2254 	template < class X, class Y >
  2255 	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) {
  2256 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
  2257 	// Static functions. We convert them into a member function call.
  2258 	// This constructor also provides implicit conversion
  2259 	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) ) {
  2260 		bind(function_to_bind);	}
  2261 	// for efficiency, prevent creation of a temporary
  2262 	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) ) {
  2263 		bind(function_to_bind);	}
  2264 	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)) {
  2265 		m_Closure.bindstaticfunc(this, &FastDelegate16::InvokeStaticFunction,
  2266 			function_to_bind); }
  2267 	// Invoke the delegate
  2268 	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 {
  2269 	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16); }
  2270 	// Implicit conversion to "bool" using the safe_bool idiom
  2271 private:
  2272 	typedef struct SafeBoolStruct {
  2273 		int a_data_pointer_to_this_is_0_on_buggy_compilers;
  2274 		StaticFunctionPtr m_nonzero;
  2275 	} UselessTypedef;
  2276     typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  2277 public:
  2278 	operator unspecified_bool_type() const {
  2279         return empty()? 0: &SafeBoolStruct::m_nonzero;
  2280     }
  2281 	// necessary to allow ==0 to work despite the safe_bool idiom
  2282 	inline bool operator==(StaticFunctionPtr funcptr) {
  2283 		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
  2284 	inline bool operator!=(StaticFunctionPtr funcptr) { 
  2285 		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
  2286 	inline bool operator ! () const	{	// Is it bound to anything?
  2287 			return !m_Closure; }
  2288 	inline bool empty() const	{
  2289 			return !m_Closure; }
  2290 	void clear() { m_Closure.clear();}
  2291 	// Conversion to and from the DelegateMemento storage class
  2292 	const DelegateMemento & GetMemento() { return m_Closure; }
  2293 	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
  2294 
  2295 private:	// Invoker for static functions
  2296 	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 {
  2297 	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16); }
  2298 };
  2299 
  2300 
  2301 ////////////////////////////////////////////////////////////////////////////////
  2302 //						Fast Delegates, part 4:
  2303 //
  2304 //				FastDelegate<> class (Original author: Jody Hagins)
  2305 //	Allows boost::function style syntax like:
  2306 //			FastDelegate< double (int, long) >
  2307 // instead of:
  2308 //			FastDelegate2< int, long, double >
  2309 //
  2310 ////////////////////////////////////////////////////////////////////////////////
  2311 
  2312 #ifdef FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX
  2313 
  2314 // Declare FastDelegate as a class template.  It will be specialized
  2315 // later for all number of arguments.
  2316 template <typename Signature>
  2317 class FastDelegate;
  2318 
  2319 //N=0
  2320 // Specialization to allow use of
  2321 // FastDelegate< R (  ) >
  2322 // instead of
  2323 // FastDelegate0 < R >
  2324 template<typename R>
  2325 class FastDelegate< R (  ) >
  2326   // Inherit from FastDelegate0 so that it can be treated just like a FastDelegate0
  2327   : public FastDelegate0 < R >
  2328 {
  2329 public:
  2330   // Make using the base type a bit easier via typedef.
  2331   typedef FastDelegate0 < R > BaseType;
  2332 
  2333   // Allow users access to the specific type of this delegate.
  2334   typedef FastDelegate SelfType;
  2335 
  2336   // Mimic the base class constructors.
  2337   FastDelegate() : BaseType() { }
  2338 
  2339   template < class X, class Y >
  2340   FastDelegate(Y * pthis,
  2341     R (X::* function_to_bind)(  ))
  2342     : BaseType(pthis, function_to_bind)  { }
  2343 
  2344   template < class X, class Y >
  2345   FastDelegate(const Y *pthis,
  2346       R (X::* function_to_bind)(  ) const)
  2347     : BaseType(pthis, function_to_bind)
  2348   {  }
  2349 
  2350   FastDelegate(R (*function_to_bind)(  ))
  2351     : BaseType(function_to_bind)  { }
  2352   void operator = (const BaseType &x)  {
  2353 		*static_cast<BaseType*>(this) = x; }
  2354 };
  2355 
  2356 //N=1
  2357 // Specialization to allow use of
  2358 // FastDelegate< R ( Param1 ) >
  2359 // instead of
  2360 // FastDelegate1 < Param1, R >
  2361 template<typename R, class Param1>
  2362 class FastDelegate< R ( Param1 ) >
  2363   // Inherit from FastDelegate1 so that it can be treated just like a FastDelegate1
  2364   : public FastDelegate1 < Param1, R >
  2365 {
  2366 public:
  2367   // Make using the base type a bit easier via typedef.
  2368   typedef FastDelegate1 < Param1, R > BaseType;
  2369 
  2370   // Allow users access to the specific type of this delegate.
  2371   typedef FastDelegate SelfType;
  2372 
  2373   // Mimic the base class constructors.
  2374   FastDelegate() : BaseType() { }
  2375 
  2376   template < class X, class Y >
  2377   FastDelegate(Y * pthis,
  2378     R (X::* function_to_bind)( Param1 p1 ))
  2379     : BaseType(pthis, function_to_bind)  { }
  2380 
  2381   template < class X, class Y >
  2382   FastDelegate(const Y *pthis,
  2383       R (X::* function_to_bind)( Param1 p1 ) const)
  2384     : BaseType(pthis, function_to_bind)
  2385   {  }
  2386 
  2387   FastDelegate(R (*function_to_bind)( Param1 p1 ))
  2388     : BaseType(function_to_bind)  { }
  2389   void operator = (const BaseType &x)  {
  2390 		*static_cast<BaseType*>(this) = x; }
  2391 };
  2392 
  2393 //N=2
  2394 // Specialization to allow use of
  2395 // FastDelegate< R ( Param1, Param2 ) >
  2396 // instead of
  2397 // FastDelegate2 < Param1, Param2, R >
  2398 template<typename R, class Param1, class Param2>
  2399 class FastDelegate< R ( Param1, Param2 ) >
  2400   // Inherit from FastDelegate2 so that it can be treated just like a FastDelegate2
  2401   : public FastDelegate2 < Param1, Param2, R >
  2402 {
  2403 public:
  2404   // Make using the base type a bit easier via typedef.
  2405   typedef FastDelegate2 < Param1, Param2, R > BaseType;
  2406 
  2407   // Allow users access to the specific type of this delegate.
  2408   typedef FastDelegate SelfType;
  2409 
  2410   // Mimic the base class constructors.
  2411   FastDelegate() : BaseType() { }
  2412 
  2413   template < class X, class Y >
  2414   FastDelegate(Y * pthis,
  2415     R (X::* function_to_bind)( Param1 p1, Param2 p2 ))
  2416     : BaseType(pthis, function_to_bind)  { }
  2417 
  2418   template < class X, class Y >
  2419   FastDelegate(const Y *pthis,
  2420       R (X::* function_to_bind)( Param1 p1, Param2 p2 ) const)
  2421     : BaseType(pthis, function_to_bind)
  2422   {  }
  2423 
  2424   FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2 ))
  2425     : BaseType(function_to_bind)  { }
  2426   void operator = (const BaseType &x)  {
  2427 		*static_cast<BaseType*>(this) = x; }
  2428 };
  2429 
  2430 //N=3
  2431 // Specialization to allow use of
  2432 // FastDelegate< R ( Param1, Param2, Param3 ) >
  2433 // instead of
  2434 // FastDelegate3 < Param1, Param2, Param3, R >
  2435 template<typename R, class Param1, class Param2, class Param3>
  2436 class FastDelegate< R ( Param1, Param2, Param3 ) >
  2437   // Inherit from FastDelegate3 so that it can be treated just like a FastDelegate3
  2438   : public FastDelegate3 < Param1, Param2, Param3, R >
  2439 {
  2440 public:
  2441   // Make using the base type a bit easier via typedef.
  2442   typedef FastDelegate3 < Param1, Param2, Param3, R > BaseType;
  2443 
  2444   // Allow users access to the specific type of this delegate.
  2445   typedef FastDelegate SelfType;
  2446 
  2447   // Mimic the base class constructors.
  2448   FastDelegate() : BaseType() { }
  2449 
  2450   template < class X, class Y >
  2451   FastDelegate(Y * pthis,
  2452     R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3 ))
  2453     : BaseType(pthis, function_to_bind)  { }
  2454 
  2455   template < class X, class Y >
  2456   FastDelegate(const Y *pthis,
  2457       R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3 ) const)
  2458     : BaseType(pthis, function_to_bind)
  2459   {  }
  2460 
  2461   FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3 ))
  2462     : BaseType(function_to_bind)  { }
  2463   void operator = (const BaseType &x)  {
  2464 		*static_cast<BaseType*>(this) = x; }
  2465 };
  2466 
  2467 //N=4
  2468 // Specialization to allow use of
  2469 // FastDelegate< R ( Param1, Param2, Param3, Param4 ) >
  2470 // instead of
  2471 // FastDelegate4 < Param1, Param2, Param3, Param4, R >
  2472 template<typename R, class Param1, class Param2, class Param3, class Param4>
  2473 class FastDelegate< R ( Param1, Param2, Param3, Param4 ) >
  2474   // Inherit from FastDelegate4 so that it can be treated just like a FastDelegate4
  2475   : public FastDelegate4 < Param1, Param2, Param3, Param4, R >
  2476 {
  2477 public:
  2478   // Make using the base type a bit easier via typedef.
  2479   typedef FastDelegate4 < Param1, Param2, Param3, Param4, R > BaseType;
  2480 
  2481   // Allow users access to the specific type of this delegate.
  2482   typedef FastDelegate SelfType;
  2483 
  2484   // Mimic the base class constructors.
  2485   FastDelegate() : BaseType() { }
  2486 
  2487   template < class X, class Y >
  2488   FastDelegate(Y * pthis,
  2489     R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4 ))
  2490     : BaseType(pthis, function_to_bind)  { }
  2491 
  2492   template < class X, class Y >
  2493   FastDelegate(const Y *pthis,
  2494       R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4 ) const)
  2495     : BaseType(pthis, function_to_bind)
  2496   {  }
  2497 
  2498   FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4 ))
  2499     : BaseType(function_to_bind)  { }
  2500   void operator = (const BaseType &x)  {
  2501 		*static_cast<BaseType*>(this) = x; }
  2502 };
  2503 
  2504 //N=5
  2505 // Specialization to allow use of
  2506 // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5 ) >
  2507 // instead of
  2508 // FastDelegate5 < Param1, Param2, Param3, Param4, Param5, R >
  2509 template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5>
  2510 class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5 ) >
  2511   // Inherit from FastDelegate5 so that it can be treated just like a FastDelegate5
  2512   : public FastDelegate5 < Param1, Param2, Param3, Param4, Param5, R >
  2513 {
  2514 public:
  2515   // Make using the base type a bit easier via typedef.
  2516   typedef FastDelegate5 < Param1, Param2, Param3, Param4, Param5, R > BaseType;
  2517 
  2518   // Allow users access to the specific type of this delegate.
  2519   typedef FastDelegate SelfType;
  2520 
  2521   // Mimic the base class constructors.
  2522   FastDelegate() : BaseType() { }
  2523 
  2524   template < class X, class Y >
  2525   FastDelegate(Y * pthis,
  2526     R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5 ))
  2527     : BaseType(pthis, function_to_bind)  { }
  2528 
  2529   template < class X, class Y >
  2530   FastDelegate(const Y *pthis,
  2531       R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5 ) const)
  2532     : BaseType(pthis, function_to_bind)
  2533   {  }
  2534 
  2535   FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5 ))
  2536     : BaseType(function_to_bind)  { }
  2537   void operator = (const BaseType &x)  {
  2538 		*static_cast<BaseType*>(this) = x; }
  2539 };
  2540 
  2541 //N=6
  2542 // Specialization to allow use of
  2543 // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6 ) >
  2544 // instead of
  2545 // FastDelegate6 < Param1, Param2, Param3, Param4, Param5, Param6, R >
  2546 template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
  2547 class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6 ) >
  2548   // Inherit from FastDelegate6 so that it can be treated just like a FastDelegate6
  2549   : public FastDelegate6 < Param1, Param2, Param3, Param4, Param5, Param6, R >
  2550 {
  2551 public:
  2552   // Make using the base type a bit easier via typedef.
  2553   typedef FastDelegate6 < Param1, Param2, Param3, Param4, Param5, Param6, R > BaseType;
  2554 
  2555   // Allow users access to the specific type of this delegate.
  2556   typedef FastDelegate SelfType;
  2557 
  2558   // Mimic the base class constructors.
  2559   FastDelegate() : BaseType() { }
  2560 
  2561   template < class X, class Y >
  2562   FastDelegate(Y * pthis,
  2563     R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6 ))
  2564     : BaseType(pthis, function_to_bind)  { }
  2565 
  2566   template < class X, class Y >
  2567   FastDelegate(const Y *pthis,
  2568       R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6 ) const)
  2569     : BaseType(pthis, function_to_bind)
  2570   {  }
  2571 
  2572   FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6 ))
  2573     : BaseType(function_to_bind)  { }
  2574   void operator = (const BaseType &x)  {
  2575 		*static_cast<BaseType*>(this) = x; }
  2576 };
  2577 
  2578 //N=7
  2579 // Specialization to allow use of
  2580 // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7 ) >
  2581 // instead of
  2582 // FastDelegate7 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, R >
  2583 template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
  2584 class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7 ) >
  2585   // Inherit from FastDelegate7 so that it can be treated just like a FastDelegate7
  2586   : public FastDelegate7 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, R >
  2587 {
  2588 public:
  2589   // Make using the base type a bit easier via typedef.
  2590   typedef FastDelegate7 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, R > BaseType;
  2591 
  2592   // Allow users access to the specific type of this delegate.
  2593   typedef FastDelegate SelfType;
  2594 
  2595   // Mimic the base class constructors.
  2596   FastDelegate() : BaseType() { }
  2597 
  2598   template < class X, class Y >
  2599   FastDelegate(Y * pthis,
  2600     R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7 ))
  2601     : BaseType(pthis, function_to_bind)  { }
  2602 
  2603   template < class X, class Y >
  2604   FastDelegate(const Y *pthis,
  2605       R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7 ) const)
  2606     : BaseType(pthis, function_to_bind)
  2607   {  }
  2608 
  2609   FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7 ))
  2610     : BaseType(function_to_bind)  { }
  2611   void operator = (const BaseType &x)  {
  2612 		*static_cast<BaseType*>(this) = x; }
  2613 };
  2614 
  2615 //N=8
  2616 // Specialization to allow use of
  2617 // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8 ) >
  2618 // instead of
  2619 // FastDelegate8 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, R >
  2620 template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
  2621 class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8 ) >
  2622   // Inherit from FastDelegate8 so that it can be treated just like a FastDelegate8
  2623   : public FastDelegate8 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, R >
  2624 {
  2625 public:
  2626   // Make using the base type a bit easier via typedef.
  2627   typedef FastDelegate8 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, R > BaseType;
  2628 
  2629   // Allow users access to the specific type of this delegate.
  2630   typedef FastDelegate SelfType;
  2631 
  2632   // Mimic the base class constructors.
  2633   FastDelegate() : BaseType() { }
  2634 
  2635   template < class X, class Y >
  2636   FastDelegate(Y * pthis,
  2637     R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8 ))
  2638     : BaseType(pthis, function_to_bind)  { }
  2639 
  2640   template < class X, class Y >
  2641   FastDelegate(const Y *pthis,
  2642       R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8 ) const)
  2643     : BaseType(pthis, function_to_bind)
  2644   {  }
  2645 
  2646   FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8 ))
  2647     : BaseType(function_to_bind)  { }
  2648   void operator = (const BaseType &x)  {
  2649 		*static_cast<BaseType*>(this) = x; }
  2650 };
  2651 
  2652 //N=9
  2653 // Specialization to allow use of
  2654 // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9 ) >
  2655 // instead of
  2656 // FastDelegate9 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, R >
  2657 template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9>
  2658 class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9 ) >
  2659   // Inherit from FastDelegate9 so that it can be treated just like a FastDelegate9
  2660   : public FastDelegate9 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, R >
  2661 {
  2662 public:
  2663   // Make using the base type a bit easier via typedef.
  2664   typedef FastDelegate9 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, R > BaseType;
  2665 
  2666   // Allow users access to the specific type of this delegate.
  2667   typedef FastDelegate SelfType;
  2668 
  2669   // Mimic the base class constructors.
  2670   FastDelegate() : BaseType() { }
  2671 
  2672   template < class X, class Y >
  2673   FastDelegate(Y * pthis,
  2674     R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9 ))
  2675     : BaseType(pthis, function_to_bind)  { }
  2676 
  2677   template < class X, class Y >
  2678   FastDelegate(const Y *pthis,
  2679       R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9 ) const)
  2680     : BaseType(pthis, function_to_bind)
  2681   {  }
  2682 
  2683   FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9 ))
  2684     : BaseType(function_to_bind)  { }
  2685   void operator = (const BaseType &x)  {
  2686 		*static_cast<BaseType*>(this) = x; }
  2687 };
  2688 
  2689 //N=10
  2690 // Specialization to allow use of
  2691 // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10 ) >
  2692 // instead of
  2693 // FastDelegate10 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, R >
  2694 template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10>
  2695 class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10 ) >
  2696   // Inherit from FastDelegate10 so that it can be treated just like a FastDelegate10
  2697   : public FastDelegate10 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, R >
  2698 {
  2699 public:
  2700   // Make using the base type a bit easier via typedef.
  2701   typedef FastDelegate10 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, R > BaseType;
  2702 
  2703   // Allow users access to the specific type of this delegate.
  2704   typedef FastDelegate SelfType;
  2705 
  2706   // Mimic the base class constructors.
  2707   FastDelegate() : BaseType() { }
  2708 
  2709   template < class X, class Y >
  2710   FastDelegate(Y * pthis,
  2711     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 ))
  2712     : BaseType(pthis, function_to_bind)  { }
  2713 
  2714   template < class X, class Y >
  2715   FastDelegate(const Y *pthis,
  2716       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)
  2717     : BaseType(pthis, function_to_bind)
  2718   {  }
  2719 
  2720   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 ))
  2721     : BaseType(function_to_bind)  { }
  2722   void operator = (const BaseType &x)  {
  2723 		*static_cast<BaseType*>(this) = x; }
  2724 };
  2725 
  2726 //N=11
  2727 // Specialization to allow use of
  2728 // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11 ) >
  2729 // instead of
  2730 // FastDelegate11 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, R >
  2731 template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11>
  2732 class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11 ) >
  2733   // Inherit from FastDelegate11 so that it can be treated just like a FastDelegate11
  2734   : public FastDelegate11 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, R >
  2735 {
  2736 public:
  2737   // Make using the base type a bit easier via typedef.
  2738   typedef FastDelegate11 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, R > BaseType;
  2739 
  2740   // Allow users access to the specific type of this delegate.
  2741   typedef FastDelegate SelfType;
  2742 
  2743   // Mimic the base class constructors.
  2744   FastDelegate() : BaseType() { }
  2745 
  2746   template < class X, class Y >
  2747   FastDelegate(Y * pthis,
  2748     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 ))
  2749     : BaseType(pthis, function_to_bind)  { }
  2750 
  2751   template < class X, class Y >
  2752   FastDelegate(const Y *pthis,
  2753       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)
  2754     : BaseType(pthis, function_to_bind)
  2755   {  }
  2756 
  2757   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 ))
  2758     : BaseType(function_to_bind)  { }
  2759   void operator = (const BaseType &x)  {
  2760 		*static_cast<BaseType*>(this) = x; }
  2761 };
  2762 
  2763 //N=12
  2764 // Specialization to allow use of
  2765 // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12 ) >
  2766 // instead of
  2767 // FastDelegate12 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, R >
  2768 template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12>
  2769 class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12 ) >
  2770   // Inherit from FastDelegate12 so that it can be treated just like a FastDelegate12
  2771   : public FastDelegate12 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, R >
  2772 {
  2773 public:
  2774   // Make using the base type a bit easier via typedef.
  2775   typedef FastDelegate12 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, R > BaseType;
  2776 
  2777   // Allow users access to the specific type of this delegate.
  2778   typedef FastDelegate SelfType;
  2779 
  2780   // Mimic the base class constructors.
  2781   FastDelegate() : BaseType() { }
  2782 
  2783   template < class X, class Y >
  2784   FastDelegate(Y * pthis,
  2785     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 ))
  2786     : BaseType(pthis, function_to_bind)  { }
  2787 
  2788   template < class X, class Y >
  2789   FastDelegate(const Y *pthis,
  2790       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)
  2791     : BaseType(pthis, function_to_bind)
  2792   {  }
  2793 
  2794   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 ))
  2795     : BaseType(function_to_bind)  { }
  2796   void operator = (const BaseType &x)  {
  2797 		*static_cast<BaseType*>(this) = x; }
  2798 };
  2799 
  2800 //N=13
  2801 // Specialization to allow use of
  2802 // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13 ) >
  2803 // instead of
  2804 // FastDelegate13 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, R >
  2805 template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13>
  2806 class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13 ) >
  2807   // Inherit from FastDelegate13 so that it can be treated just like a FastDelegate13
  2808   : public FastDelegate13 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, R >
  2809 {
  2810 public:
  2811   // Make using the base type a bit easier via typedef.
  2812   typedef FastDelegate13 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, R > BaseType;
  2813 
  2814   // Allow users access to the specific type of this delegate.
  2815   typedef FastDelegate SelfType;
  2816 
  2817   // Mimic the base class constructors.
  2818   FastDelegate() : BaseType() { }
  2819 
  2820   template < class X, class Y >
  2821   FastDelegate(Y * pthis,
  2822     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 ))
  2823     : BaseType(pthis, function_to_bind)  { }
  2824 
  2825   template < class X, class Y >
  2826   FastDelegate(const Y *pthis,
  2827       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)
  2828     : BaseType(pthis, function_to_bind)
  2829   {  }
  2830 
  2831   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 ))
  2832     : BaseType(function_to_bind)  { }
  2833   void operator = (const BaseType &x)  {
  2834 		*static_cast<BaseType*>(this) = x; }
  2835 };
  2836 
  2837 //N=14
  2838 // Specialization to allow use of
  2839 // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14 ) >
  2840 // instead of
  2841 // FastDelegate14 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, R >
  2842 template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14>
  2843 class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14 ) >
  2844   // Inherit from FastDelegate14 so that it can be treated just like a FastDelegate14
  2845   : public FastDelegate14 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, R >
  2846 {
  2847 public:
  2848   // Make using the base type a bit easier via typedef.
  2849   typedef FastDelegate14 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, R > BaseType;
  2850 
  2851   // Allow users access to the specific type of this delegate.
  2852   typedef FastDelegate SelfType;
  2853 
  2854   // Mimic the base class constructors.
  2855   FastDelegate() : BaseType() { }
  2856 
  2857   template < class X, class Y >
  2858   FastDelegate(Y * pthis,
  2859     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 ))
  2860     : BaseType(pthis, function_to_bind)  { }
  2861 
  2862   template < class X, class Y >
  2863   FastDelegate(const Y *pthis,
  2864       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)
  2865     : BaseType(pthis, function_to_bind)
  2866   {  }
  2867 
  2868   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 ))
  2869     : BaseType(function_to_bind)  { }
  2870   void operator = (const BaseType &x)  {
  2871 		*static_cast<BaseType*>(this) = x; }
  2872 };
  2873 
  2874 //N=15
  2875 // Specialization to allow use of
  2876 // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15 ) >
  2877 // instead of
  2878 // FastDelegate15 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, R >
  2879 template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15>
  2880 class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15 ) >
  2881   // Inherit from FastDelegate15 so that it can be treated just like a FastDelegate15
  2882   : public FastDelegate15 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, R >
  2883 {
  2884 public:
  2885   // Make using the base type a bit easier via typedef.
  2886   typedef FastDelegate15 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, R > BaseType;
  2887 
  2888   // Allow users access to the specific type of this delegate.
  2889   typedef FastDelegate SelfType;
  2890 
  2891   // Mimic the base class constructors.
  2892   FastDelegate() : BaseType() { }
  2893 
  2894   template < class X, class Y >
  2895   FastDelegate(Y * pthis,
  2896     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 ))
  2897     : BaseType(pthis, function_to_bind)  { }
  2898 
  2899   template < class X, class Y >
  2900   FastDelegate(const Y *pthis,
  2901       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)
  2902     : BaseType(pthis, function_to_bind)
  2903   {  }
  2904 
  2905   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 ))
  2906     : BaseType(function_to_bind)  { }
  2907   void operator = (const BaseType &x)  {
  2908 		*static_cast<BaseType*>(this) = x; }
  2909 };
  2910 
  2911 //N=16
  2912 // Specialization to allow use of
  2913 // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16 ) >
  2914 // instead of
  2915 // FastDelegate16 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, R >
  2916 template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16>
  2917 class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16 ) >
  2918   // Inherit from FastDelegate16 so that it can be treated just like a FastDelegate16
  2919   : public FastDelegate16 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, R >
  2920 {
  2921 public:
  2922   // Make using the base type a bit easier via typedef.
  2923   typedef FastDelegate16 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, R > BaseType;
  2924 
  2925   // Allow users access to the specific type of this delegate.
  2926   typedef FastDelegate SelfType;
  2927 
  2928   // Mimic the base class constructors.
  2929   FastDelegate() : BaseType() { }
  2930 
  2931   template < class X, class Y >
  2932   FastDelegate(Y * pthis,
  2933     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 ))
  2934     : BaseType(pthis, function_to_bind)  { }
  2935 
  2936   template < class X, class Y >
  2937   FastDelegate(const Y *pthis,
  2938       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)
  2939     : BaseType(pthis, function_to_bind)
  2940   {  }
  2941 
  2942   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 ))
  2943     : BaseType(function_to_bind)  { }
  2944   void operator = (const BaseType &x)  {
  2945 		*static_cast<BaseType*>(this) = x; }
  2946 };
  2947 
  2948 
  2949 #endif //FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX
  2950 
  2951 ////////////////////////////////////////////////////////////////////////////////
  2952 //						Fast Delegates, part 5:
  2953 //
  2954 //				MakeDelegate() helper function
  2955 //
  2956 //			MakeDelegate(&x, &X::func) returns a fastdelegate of the type
  2957 //			necessary for calling x.func() with the correct number of arguments.
  2958 //			This makes it possible to eliminate many typedefs from user code.
  2959 //
  2960 ////////////////////////////////////////////////////////////////////////////////
  2961 
  2962 // Also declare overloads of a MakeDelegate() global function to
  2963 // reduce the need for typedefs.
  2964 // We need seperate overloads for const and non-const member functions.
  2965 // Also, because of the weird rule about the class of derived member function pointers,
  2966 // implicit downcasts may need to be applied later to the 'this' pointer.
  2967 // That's why two classes (X and Y) appear in the definitions. Y must be implicitly
  2968 // castable to X.
  2969 
  2970 // Workaround for VC6. VC6 needs void return types converted into DefaultVoid.
  2971 // GCC 3.2 and later won't compile this unless it's preceded by 'typename',
  2972 // but VC6 doesn't allow 'typename' in this context.
  2973 // So, I have to use a macro.
  2974 
  2975 #ifdef FASTDLGT_VC6
  2976 #define FASTDLGT_RETTYPE detail::VoidToDefaultVoid<RetType>::type
  2977 #else
  2978 #define FASTDLGT_RETTYPE RetType
  2979 #endif
  2980 
  2981 //N=0
  2982 template <class X, class Y, class RetType>
  2983 FastDelegate0<FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)()) {
  2984 	return FastDelegate0<FASTDLGT_RETTYPE>(x, func);
  2985 }
  2986 
  2987 template <class X, class Y, class RetType>
  2988 FastDelegate0<FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)() const) {
  2989 	return FastDelegate0<FASTDLGT_RETTYPE>(x, func);
  2990 }
  2991 
  2992 template <class RetType>
  2993 FastDelegate0<FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)()) {
  2994 	return FastDelegate0<FASTDLGT_RETTYPE>(func);
  2995 }
  2996 
  2997 //N=1
  2998 template <class X, class Y, class Param1, class RetType>
  2999 FastDelegate1<Param1, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1)) {
  3000 	return FastDelegate1<Param1, FASTDLGT_RETTYPE>(x, func);
  3001 }
  3002 
  3003 template <class X, class Y, class Param1, class RetType>
  3004 FastDelegate1<Param1, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1) const) {
  3005 	return FastDelegate1<Param1, FASTDLGT_RETTYPE>(x, func);
  3006 }
  3007 
  3008 template <class Param1, class RetType>
  3009 FastDelegate1<Param1, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(Param1 p1)) {
  3010 	return FastDelegate1<Param1, FASTDLGT_RETTYPE>(func);
  3011 }
  3012 
  3013 //N=2
  3014 template <class X, class Y, class Param1, class Param2, class RetType>
  3015 FastDelegate2<Param1, Param2, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2)) {
  3016 	return FastDelegate2<Param1, Param2, FASTDLGT_RETTYPE>(x, func);
  3017 }
  3018 
  3019 template <class X, class Y, class Param1, class Param2, class RetType>
  3020 FastDelegate2<Param1, Param2, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2) const) {
  3021 	return FastDelegate2<Param1, Param2, FASTDLGT_RETTYPE>(x, func);
  3022 }
  3023 
  3024 template <class Param1, class Param2, class RetType>
  3025 FastDelegate2<Param1, Param2, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(Param1 p1, Param2 p2)) {
  3026 	return FastDelegate2<Param1, Param2, FASTDLGT_RETTYPE>(func);
  3027 }
  3028 
  3029 //N=3
  3030 template <class X, class Y, class Param1, class Param2, class Param3, class RetType>
  3031 FastDelegate3<Param1, Param2, Param3, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3)) {
  3032 	return FastDelegate3<Param1, Param2, Param3, FASTDLGT_RETTYPE>(x, func);
  3033 }
  3034 
  3035 template <class X, class Y, class Param1, class Param2, class Param3, class RetType>
  3036 FastDelegate3<Param1, Param2, Param3, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3) const) {
  3037 	return FastDelegate3<Param1, Param2, Param3, FASTDLGT_RETTYPE>(x, func);
  3038 }
  3039 
  3040 template <class Param1, class Param2, class Param3, class RetType>
  3041 FastDelegate3<Param1, Param2, Param3, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3)) {
  3042 	return FastDelegate3<Param1, Param2, Param3, FASTDLGT_RETTYPE>(func);
  3043 }
  3044 
  3045 //N=4
  3046 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class RetType>
  3047 FastDelegate4<Param1, Param2, Param3, Param4, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4)) {
  3048 	return FastDelegate4<Param1, Param2, Param3, Param4, FASTDLGT_RETTYPE>(x, func);
  3049 }
  3050 
  3051 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class RetType>
  3052 FastDelegate4<Param1, Param2, Param3, Param4, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const) {
  3053 	return FastDelegate4<Param1, Param2, Param3, Param4, FASTDLGT_RETTYPE>(x, func);
  3054 }
  3055 
  3056 template <class Param1, class Param2, class Param3, class Param4, class RetType>
  3057 FastDelegate4<Param1, Param2, Param3, Param4, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4)) {
  3058 	return FastDelegate4<Param1, Param2, Param3, Param4, FASTDLGT_RETTYPE>(func);
  3059 }
  3060 
  3061 //N=5
  3062 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class RetType>
  3063 FastDelegate5<Param1, Param2, Param3, Param4, Param5, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5)) {
  3064 	return FastDelegate5<Param1, Param2, Param3, Param4, Param5, FASTDLGT_RETTYPE>(x, func);
  3065 }
  3066 
  3067 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class RetType>
  3068 FastDelegate5<Param1, Param2, Param3, Param4, Param5, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const) {
  3069 	return FastDelegate5<Param1, Param2, Param3, Param4, Param5, FASTDLGT_RETTYPE>(x, func);
  3070 }
  3071 
  3072 template <class Param1, class Param2, class Param3, class Param4, class Param5, class RetType>
  3073 FastDelegate5<Param1, Param2, Param3, Param4, Param5, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5)) {
  3074 	return FastDelegate5<Param1, Param2, Param3, Param4, Param5, FASTDLGT_RETTYPE>(func);
  3075 }
  3076 
  3077 //N=6
  3078 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class RetType>
  3079 FastDelegate6<Param1, Param2, Param3, Param4, Param5, Param6, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6)) {
  3080 	return FastDelegate6<Param1, Param2, Param3, Param4, Param5, Param6, FASTDLGT_RETTYPE>(x, func);
  3081 }
  3082 
  3083 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class RetType>
  3084 FastDelegate6<Param1, Param2, Param3, Param4, Param5, Param6, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const) {
  3085 	return FastDelegate6<Param1, Param2, Param3, Param4, Param5, Param6, FASTDLGT_RETTYPE>(x, func);
  3086 }
  3087 
  3088 template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class RetType>
  3089 FastDelegate6<Param1, Param2, Param3, Param4, Param5, Param6, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6)) {
  3090 	return FastDelegate6<Param1, Param2, Param3, Param4, Param5, Param6, FASTDLGT_RETTYPE>(func);
  3091 }
  3092 
  3093 //N=7
  3094 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class RetType>
  3095 FastDelegate7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7)) {
  3096 	return FastDelegate7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, FASTDLGT_RETTYPE>(x, func);
  3097 }
  3098 
  3099 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class RetType>
  3100 FastDelegate7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const) {
  3101 	return FastDelegate7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, FASTDLGT_RETTYPE>(x, func);
  3102 }
  3103 
  3104 template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class RetType>
  3105 FastDelegate7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7)) {
  3106 	return FastDelegate7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, FASTDLGT_RETTYPE>(func);
  3107 }
  3108 
  3109 //N=8
  3110 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class RetType>
  3111 FastDelegate8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8)) {
  3112 	return FastDelegate8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, FASTDLGT_RETTYPE>(x, func);
  3113 }
  3114 
  3115 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class RetType>
  3116 FastDelegate8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) const) {
  3117 	return FastDelegate8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, FASTDLGT_RETTYPE>(x, func);
  3118 }
  3119 
  3120 template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class RetType>
  3121 FastDelegate8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8)) {
  3122 	return FastDelegate8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, FASTDLGT_RETTYPE>(func);
  3123 }
  3124 
  3125 //N=9
  3126 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class RetType>
  3127 FastDelegate9<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9)) {
  3128 	return FastDelegate9<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, FASTDLGT_RETTYPE>(x, func);
  3129 }
  3130 
  3131 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class RetType>
  3132 FastDelegate9<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, FASTDLGT_RETTYPE> 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) {
  3133 	return FastDelegate9<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, FASTDLGT_RETTYPE>(x, func);
  3134 }
  3135 
  3136 template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class RetType>
  3137 FastDelegate9<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9)) {
  3138 	return FastDelegate9<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, FASTDLGT_RETTYPE>(func);
  3139 }
  3140 
  3141 //N=10
  3142 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class RetType>
  3143 FastDelegate10<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, FASTDLGT_RETTYPE> 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)) {
  3144 	return FastDelegate10<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, FASTDLGT_RETTYPE>(x, func);
  3145 }
  3146 
  3147 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class RetType>
  3148 FastDelegate10<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, FASTDLGT_RETTYPE> 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) {
  3149 	return FastDelegate10<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, FASTDLGT_RETTYPE>(x, func);
  3150 }
  3151 
  3152 template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class RetType>
  3153 FastDelegate10<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10)) {
  3154 	return FastDelegate10<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, FASTDLGT_RETTYPE>(func);
  3155 }
  3156 
  3157 //N=11
  3158 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class RetType>
  3159 FastDelegate11<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, FASTDLGT_RETTYPE> 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)) {
  3160 	return FastDelegate11<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, FASTDLGT_RETTYPE>(x, func);
  3161 }
  3162 
  3163 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class RetType>
  3164 FastDelegate11<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, FASTDLGT_RETTYPE> 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) {
  3165 	return FastDelegate11<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, FASTDLGT_RETTYPE>(x, func);
  3166 }
  3167 
  3168 template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class RetType>
  3169 FastDelegate11<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, FASTDLGT_RETTYPE> 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)) {
  3170 	return FastDelegate11<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, FASTDLGT_RETTYPE>(func);
  3171 }
  3172 
  3173 //N=12
  3174 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class RetType>
  3175 FastDelegate12<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, FASTDLGT_RETTYPE> 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)) {
  3176 	return FastDelegate12<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, FASTDLGT_RETTYPE>(x, func);
  3177 }
  3178 
  3179 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class RetType>
  3180 FastDelegate12<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, FASTDLGT_RETTYPE> 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) {
  3181 	return FastDelegate12<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, FASTDLGT_RETTYPE>(x, func);
  3182 }
  3183 
  3184 template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class RetType>
  3185 FastDelegate12<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, FASTDLGT_RETTYPE> 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)) {
  3186 	return FastDelegate12<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, FASTDLGT_RETTYPE>(func);
  3187 }
  3188 
  3189 //N=13
  3190 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class RetType>
  3191 FastDelegate13<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, FASTDLGT_RETTYPE> 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)) {
  3192 	return FastDelegate13<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, FASTDLGT_RETTYPE>(x, func);
  3193 }
  3194 
  3195 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class RetType>
  3196 FastDelegate13<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, FASTDLGT_RETTYPE> 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) {
  3197 	return FastDelegate13<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, FASTDLGT_RETTYPE>(x, func);
  3198 }
  3199 
  3200 template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class RetType>
  3201 FastDelegate13<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, FASTDLGT_RETTYPE> 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)) {
  3202 	return FastDelegate13<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, FASTDLGT_RETTYPE>(func);
  3203 }
  3204 
  3205 //N=14
  3206 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class RetType>
  3207 FastDelegate14<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, FASTDLGT_RETTYPE> 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)) {
  3208 	return FastDelegate14<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, FASTDLGT_RETTYPE>(x, func);
  3209 }
  3210 
  3211 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class RetType>
  3212 FastDelegate14<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, FASTDLGT_RETTYPE> 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) {
  3213 	return FastDelegate14<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, FASTDLGT_RETTYPE>(x, func);
  3214 }
  3215 
  3216 template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class RetType>
  3217 FastDelegate14<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, FASTDLGT_RETTYPE> 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)) {
  3218 	return FastDelegate14<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, FASTDLGT_RETTYPE>(func);
  3219 }
  3220 
  3221 //N=15
  3222 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class RetType>
  3223 FastDelegate15<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, FASTDLGT_RETTYPE> 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)) {
  3224 	return FastDelegate15<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, FASTDLGT_RETTYPE>(x, func);
  3225 }
  3226 
  3227 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class RetType>
  3228 FastDelegate15<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, FASTDLGT_RETTYPE> 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) {
  3229 	return FastDelegate15<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, FASTDLGT_RETTYPE>(x, func);
  3230 }
  3231 
  3232 template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class RetType>
  3233 FastDelegate15<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, FASTDLGT_RETTYPE> 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)) {
  3234 	return FastDelegate15<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, FASTDLGT_RETTYPE>(func);
  3235 }
  3236 
  3237 //N=16
  3238 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16, class RetType>
  3239 FastDelegate16<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, FASTDLGT_RETTYPE> 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)) {
  3240 	return FastDelegate16<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, FASTDLGT_RETTYPE>(x, func);
  3241 }
  3242 
  3243 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16, class RetType>
  3244 FastDelegate16<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, FASTDLGT_RETTYPE> 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) {
  3245 	return FastDelegate16<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, FASTDLGT_RETTYPE>(x, func);
  3246 }
  3247 
  3248 template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16, class RetType>
  3249 FastDelegate16<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, FASTDLGT_RETTYPE> 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)) {
  3250 	return FastDelegate16<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, FASTDLGT_RETTYPE>(func);
  3251 }
  3252 
  3253 
  3254  // clean up after ourselves...
  3255 #undef FASTDLGT_RETTYPE
  3256 
  3257 } // namespace fastdelegate
  3258 
  3259 #endif // !defined(FASTDELEGATE_H)