core/sourcehook/FastDelegate.h
author Nicholas Hastings <skamonkey@gmail.com>
Sat Oct 27 11:48:06 2012 -0400 (2012-10-27)
changeset 810 09ccbe5acc93
parent 780 35f2a207badf
permissions -rw-r--r--
Updated Makefiles (NPOTB).
     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 //N=17 (!)
  2301 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 Param17, class RetType=detail::DefaultVoid>
  2302 class FastDelegate17 {
  2303 private:
  2304 	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
  2305 	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17);
  2306 	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17);
  2307 	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17);
  2308 	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
  2309 	ClosureType m_Closure;
  2310 public:
  2311 	// Typedefs to aid generic programming
  2312 	typedef FastDelegate17 type;
  2313 
  2314 	// Construction and comparison functions
  2315 	FastDelegate17() { clear(); }
  2316 	FastDelegate17(const FastDelegate17 &x) {
  2317 		m_Closure.CopyFrom(this, x.m_Closure); }
  2318 	void operator = (const FastDelegate17 &x)  {
  2319 		m_Closure.CopyFrom(this, x.m_Closure); }
  2320 	bool operator ==(const FastDelegate17 &x) const {
  2321 		return m_Closure.IsEqual(x.m_Closure);	}
  2322 	bool operator !=(const FastDelegate17 &x) const {
  2323 		return !m_Closure.IsEqual(x.m_Closure); }
  2324 	bool operator <(const FastDelegate17 &x) const {
  2325 		return m_Closure.IsLess(x.m_Closure);	}
  2326 	bool operator >(const FastDelegate17 &x) const {
  2327 		return x.m_Closure.IsLess(m_Closure);	}
  2328 	// Binding to non-const member functions
  2329 	template < class X, class Y >
  2330 	FastDelegate17(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17) ) {
  2331 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
  2332 	template < class X, class Y >
  2333 	inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17)) {
  2334 		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
  2335 	// Binding to const member functions.
  2336 	template < class X, class Y >
  2337 	FastDelegate17(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17) const) {
  2338 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
  2339 	template < class X, class Y >
  2340 	inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17) const) {
  2341 		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
  2342 	// Static functions. We convert them into a member function call.
  2343 	// This constructor also provides implicit conversion
  2344 	FastDelegate17(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17) ) {
  2345 		bind(function_to_bind);	}
  2346 	// for efficiency, prevent creation of a temporary
  2347 	void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17) ) {
  2348 		bind(function_to_bind);	}
  2349 	inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17)) {
  2350 		m_Closure.bindstaticfunc(this, &FastDelegate17::InvokeStaticFunction,
  2351 			function_to_bind); }
  2352 	// Invoke the delegate
  2353 	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17) const {
  2354 	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17); }
  2355 	// Implicit conversion to "bool" using the safe_bool idiom
  2356 private:
  2357 	typedef struct SafeBoolStruct {
  2358 		int a_data_pointer_to_this_is_0_on_buggy_compilers;
  2359 		StaticFunctionPtr m_nonzero;
  2360 	} UselessTypedef;
  2361     typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  2362 public:
  2363 	operator unspecified_bool_type() const {
  2364         return empty()? 0: &SafeBoolStruct::m_nonzero;
  2365     }
  2366 	// necessary to allow ==0 to work despite the safe_bool idiom
  2367 	inline bool operator==(StaticFunctionPtr funcptr) {
  2368 		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
  2369 	inline bool operator!=(StaticFunctionPtr funcptr) { 
  2370 		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
  2371 	inline bool operator ! () const	{	// Is it bound to anything?
  2372 			return !m_Closure; }
  2373 	inline bool empty() const	{
  2374 			return !m_Closure; }
  2375 	void clear() { m_Closure.clear();}
  2376 	// Conversion to and from the DelegateMemento storage class
  2377 	const DelegateMemento & GetMemento() { return m_Closure; }
  2378 	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
  2379 
  2380 private:	// Invoker for static functions
  2381 	RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17) const {
  2382 	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17); }
  2383 };
  2384 
  2385 
  2386 ////////////////////////////////////////////////////////////////////////////////
  2387 //						Fast Delegates, part 4:
  2388 //
  2389 //				FastDelegate<> class (Original author: Jody Hagins)
  2390 //	Allows boost::function style syntax like:
  2391 //			FastDelegate< double (int, long) >
  2392 // instead of:
  2393 //			FastDelegate2< int, long, double >
  2394 //
  2395 ////////////////////////////////////////////////////////////////////////////////
  2396 
  2397 #ifdef FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX
  2398 
  2399 // Declare FastDelegate as a class template.  It will be specialized
  2400 // later for all number of arguments.
  2401 template <typename Signature>
  2402 class FastDelegate;
  2403 
  2404 //N=0
  2405 // Specialization to allow use of
  2406 // FastDelegate< R (  ) >
  2407 // instead of
  2408 // FastDelegate0 < R >
  2409 template<typename R>
  2410 class FastDelegate< R (  ) >
  2411   // Inherit from FastDelegate0 so that it can be treated just like a FastDelegate0
  2412   : public FastDelegate0 < R >
  2413 {
  2414 public:
  2415   // Make using the base type a bit easier via typedef.
  2416   typedef FastDelegate0 < R > BaseType;
  2417 
  2418   // Allow users access to the specific type of this delegate.
  2419   typedef FastDelegate SelfType;
  2420 
  2421   // Mimic the base class constructors.
  2422   FastDelegate() : BaseType() { }
  2423 
  2424   template < class X, class Y >
  2425   FastDelegate(Y * pthis,
  2426     R (X::* function_to_bind)(  ))
  2427     : BaseType(pthis, function_to_bind)  { }
  2428 
  2429   template < class X, class Y >
  2430   FastDelegate(const Y *pthis,
  2431       R (X::* function_to_bind)(  ) const)
  2432     : BaseType(pthis, function_to_bind)
  2433   {  }
  2434 
  2435   FastDelegate(R (*function_to_bind)(  ))
  2436     : BaseType(function_to_bind)  { }
  2437   void operator = (const BaseType &x)  {
  2438 		*static_cast<BaseType*>(this) = x; }
  2439 };
  2440 
  2441 //N=1
  2442 // Specialization to allow use of
  2443 // FastDelegate< R ( Param1 ) >
  2444 // instead of
  2445 // FastDelegate1 < Param1, R >
  2446 template<typename R, class Param1>
  2447 class FastDelegate< R ( Param1 ) >
  2448   // Inherit from FastDelegate1 so that it can be treated just like a FastDelegate1
  2449   : public FastDelegate1 < Param1, R >
  2450 {
  2451 public:
  2452   // Make using the base type a bit easier via typedef.
  2453   typedef FastDelegate1 < Param1, R > BaseType;
  2454 
  2455   // Allow users access to the specific type of this delegate.
  2456   typedef FastDelegate SelfType;
  2457 
  2458   // Mimic the base class constructors.
  2459   FastDelegate() : BaseType() { }
  2460 
  2461   template < class X, class Y >
  2462   FastDelegate(Y * pthis,
  2463     R (X::* function_to_bind)( Param1 p1 ))
  2464     : BaseType(pthis, function_to_bind)  { }
  2465 
  2466   template < class X, class Y >
  2467   FastDelegate(const Y *pthis,
  2468       R (X::* function_to_bind)( Param1 p1 ) const)
  2469     : BaseType(pthis, function_to_bind)
  2470   {  }
  2471 
  2472   FastDelegate(R (*function_to_bind)( Param1 p1 ))
  2473     : BaseType(function_to_bind)  { }
  2474   void operator = (const BaseType &x)  {
  2475 		*static_cast<BaseType*>(this) = x; }
  2476 };
  2477 
  2478 //N=2
  2479 // Specialization to allow use of
  2480 // FastDelegate< R ( Param1, Param2 ) >
  2481 // instead of
  2482 // FastDelegate2 < Param1, Param2, R >
  2483 template<typename R, class Param1, class Param2>
  2484 class FastDelegate< R ( Param1, Param2 ) >
  2485   // Inherit from FastDelegate2 so that it can be treated just like a FastDelegate2
  2486   : public FastDelegate2 < Param1, Param2, R >
  2487 {
  2488 public:
  2489   // Make using the base type a bit easier via typedef.
  2490   typedef FastDelegate2 < Param1, Param2, R > BaseType;
  2491 
  2492   // Allow users access to the specific type of this delegate.
  2493   typedef FastDelegate SelfType;
  2494 
  2495   // Mimic the base class constructors.
  2496   FastDelegate() : BaseType() { }
  2497 
  2498   template < class X, class Y >
  2499   FastDelegate(Y * pthis,
  2500     R (X::* function_to_bind)( Param1 p1, Param2 p2 ))
  2501     : BaseType(pthis, function_to_bind)  { }
  2502 
  2503   template < class X, class Y >
  2504   FastDelegate(const Y *pthis,
  2505       R (X::* function_to_bind)( Param1 p1, Param2 p2 ) const)
  2506     : BaseType(pthis, function_to_bind)
  2507   {  }
  2508 
  2509   FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2 ))
  2510     : BaseType(function_to_bind)  { }
  2511   void operator = (const BaseType &x)  {
  2512 		*static_cast<BaseType*>(this) = x; }
  2513 };
  2514 
  2515 //N=3
  2516 // Specialization to allow use of
  2517 // FastDelegate< R ( Param1, Param2, Param3 ) >
  2518 // instead of
  2519 // FastDelegate3 < Param1, Param2, Param3, R >
  2520 template<typename R, class Param1, class Param2, class Param3>
  2521 class FastDelegate< R ( Param1, Param2, Param3 ) >
  2522   // Inherit from FastDelegate3 so that it can be treated just like a FastDelegate3
  2523   : public FastDelegate3 < Param1, Param2, Param3, R >
  2524 {
  2525 public:
  2526   // Make using the base type a bit easier via typedef.
  2527   typedef FastDelegate3 < Param1, Param2, Param3, R > BaseType;
  2528 
  2529   // Allow users access to the specific type of this delegate.
  2530   typedef FastDelegate SelfType;
  2531 
  2532   // Mimic the base class constructors.
  2533   FastDelegate() : BaseType() { }
  2534 
  2535   template < class X, class Y >
  2536   FastDelegate(Y * pthis,
  2537     R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3 ))
  2538     : BaseType(pthis, function_to_bind)  { }
  2539 
  2540   template < class X, class Y >
  2541   FastDelegate(const Y *pthis,
  2542       R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3 ) const)
  2543     : BaseType(pthis, function_to_bind)
  2544   {  }
  2545 
  2546   FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3 ))
  2547     : BaseType(function_to_bind)  { }
  2548   void operator = (const BaseType &x)  {
  2549 		*static_cast<BaseType*>(this) = x; }
  2550 };
  2551 
  2552 //N=4
  2553 // Specialization to allow use of
  2554 // FastDelegate< R ( Param1, Param2, Param3, Param4 ) >
  2555 // instead of
  2556 // FastDelegate4 < Param1, Param2, Param3, Param4, R >
  2557 template<typename R, class Param1, class Param2, class Param3, class Param4>
  2558 class FastDelegate< R ( Param1, Param2, Param3, Param4 ) >
  2559   // Inherit from FastDelegate4 so that it can be treated just like a FastDelegate4
  2560   : public FastDelegate4 < Param1, Param2, Param3, Param4, R >
  2561 {
  2562 public:
  2563   // Make using the base type a bit easier via typedef.
  2564   typedef FastDelegate4 < Param1, Param2, Param3, Param4, R > BaseType;
  2565 
  2566   // Allow users access to the specific type of this delegate.
  2567   typedef FastDelegate SelfType;
  2568 
  2569   // Mimic the base class constructors.
  2570   FastDelegate() : BaseType() { }
  2571 
  2572   template < class X, class Y >
  2573   FastDelegate(Y * pthis,
  2574     R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4 ))
  2575     : BaseType(pthis, function_to_bind)  { }
  2576 
  2577   template < class X, class Y >
  2578   FastDelegate(const Y *pthis,
  2579       R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4 ) const)
  2580     : BaseType(pthis, function_to_bind)
  2581   {  }
  2582 
  2583   FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4 ))
  2584     : BaseType(function_to_bind)  { }
  2585   void operator = (const BaseType &x)  {
  2586 		*static_cast<BaseType*>(this) = x; }
  2587 };
  2588 
  2589 //N=5
  2590 // Specialization to allow use of
  2591 // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5 ) >
  2592 // instead of
  2593 // FastDelegate5 < Param1, Param2, Param3, Param4, Param5, R >
  2594 template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5>
  2595 class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5 ) >
  2596   // Inherit from FastDelegate5 so that it can be treated just like a FastDelegate5
  2597   : public FastDelegate5 < Param1, Param2, Param3, Param4, Param5, R >
  2598 {
  2599 public:
  2600   // Make using the base type a bit easier via typedef.
  2601   typedef FastDelegate5 < Param1, Param2, Param3, Param4, Param5, R > BaseType;
  2602 
  2603   // Allow users access to the specific type of this delegate.
  2604   typedef FastDelegate SelfType;
  2605 
  2606   // Mimic the base class constructors.
  2607   FastDelegate() : BaseType() { }
  2608 
  2609   template < class X, class Y >
  2610   FastDelegate(Y * pthis,
  2611     R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5 ))
  2612     : BaseType(pthis, function_to_bind)  { }
  2613 
  2614   template < class X, class Y >
  2615   FastDelegate(const Y *pthis,
  2616       R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5 ) const)
  2617     : BaseType(pthis, function_to_bind)
  2618   {  }
  2619 
  2620   FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5 ))
  2621     : BaseType(function_to_bind)  { }
  2622   void operator = (const BaseType &x)  {
  2623 		*static_cast<BaseType*>(this) = x; }
  2624 };
  2625 
  2626 //N=6
  2627 // Specialization to allow use of
  2628 // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6 ) >
  2629 // instead of
  2630 // FastDelegate6 < Param1, Param2, Param3, Param4, Param5, Param6, R >
  2631 template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
  2632 class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6 ) >
  2633   // Inherit from FastDelegate6 so that it can be treated just like a FastDelegate6
  2634   : public FastDelegate6 < Param1, Param2, Param3, Param4, Param5, Param6, R >
  2635 {
  2636 public:
  2637   // Make using the base type a bit easier via typedef.
  2638   typedef FastDelegate6 < Param1, Param2, Param3, Param4, Param5, Param6, R > BaseType;
  2639 
  2640   // Allow users access to the specific type of this delegate.
  2641   typedef FastDelegate SelfType;
  2642 
  2643   // Mimic the base class constructors.
  2644   FastDelegate() : BaseType() { }
  2645 
  2646   template < class X, class Y >
  2647   FastDelegate(Y * pthis,
  2648     R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6 ))
  2649     : BaseType(pthis, function_to_bind)  { }
  2650 
  2651   template < class X, class Y >
  2652   FastDelegate(const Y *pthis,
  2653       R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6 ) const)
  2654     : BaseType(pthis, function_to_bind)
  2655   {  }
  2656 
  2657   FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6 ))
  2658     : BaseType(function_to_bind)  { }
  2659   void operator = (const BaseType &x)  {
  2660 		*static_cast<BaseType*>(this) = x; }
  2661 };
  2662 
  2663 //N=7
  2664 // Specialization to allow use of
  2665 // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7 ) >
  2666 // instead of
  2667 // FastDelegate7 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, R >
  2668 template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
  2669 class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7 ) >
  2670   // Inherit from FastDelegate7 so that it can be treated just like a FastDelegate7
  2671   : public FastDelegate7 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, R >
  2672 {
  2673 public:
  2674   // Make using the base type a bit easier via typedef.
  2675   typedef FastDelegate7 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, R > BaseType;
  2676 
  2677   // Allow users access to the specific type of this delegate.
  2678   typedef FastDelegate SelfType;
  2679 
  2680   // Mimic the base class constructors.
  2681   FastDelegate() : BaseType() { }
  2682 
  2683   template < class X, class Y >
  2684   FastDelegate(Y * pthis,
  2685     R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7 ))
  2686     : BaseType(pthis, function_to_bind)  { }
  2687 
  2688   template < class X, class Y >
  2689   FastDelegate(const Y *pthis,
  2690       R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7 ) const)
  2691     : BaseType(pthis, function_to_bind)
  2692   {  }
  2693 
  2694   FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7 ))
  2695     : BaseType(function_to_bind)  { }
  2696   void operator = (const BaseType &x)  {
  2697 		*static_cast<BaseType*>(this) = x; }
  2698 };
  2699 
  2700 //N=8
  2701 // Specialization to allow use of
  2702 // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8 ) >
  2703 // instead of
  2704 // FastDelegate8 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, R >
  2705 template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
  2706 class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8 ) >
  2707   // Inherit from FastDelegate8 so that it can be treated just like a FastDelegate8
  2708   : public FastDelegate8 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, R >
  2709 {
  2710 public:
  2711   // Make using the base type a bit easier via typedef.
  2712   typedef FastDelegate8 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, R > BaseType;
  2713 
  2714   // Allow users access to the specific type of this delegate.
  2715   typedef FastDelegate SelfType;
  2716 
  2717   // Mimic the base class constructors.
  2718   FastDelegate() : BaseType() { }
  2719 
  2720   template < class X, class Y >
  2721   FastDelegate(Y * pthis,
  2722     R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8 ))
  2723     : BaseType(pthis, function_to_bind)  { }
  2724 
  2725   template < class X, class Y >
  2726   FastDelegate(const Y *pthis,
  2727       R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8 ) const)
  2728     : BaseType(pthis, function_to_bind)
  2729   {  }
  2730 
  2731   FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8 ))
  2732     : BaseType(function_to_bind)  { }
  2733   void operator = (const BaseType &x)  {
  2734 		*static_cast<BaseType*>(this) = x; }
  2735 };
  2736 
  2737 //N=9
  2738 // Specialization to allow use of
  2739 // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9 ) >
  2740 // instead of
  2741 // FastDelegate9 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, R >
  2742 template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9>
  2743 class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9 ) >
  2744   // Inherit from FastDelegate9 so that it can be treated just like a FastDelegate9
  2745   : public FastDelegate9 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, R >
  2746 {
  2747 public:
  2748   // Make using the base type a bit easier via typedef.
  2749   typedef FastDelegate9 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, R > BaseType;
  2750 
  2751   // Allow users access to the specific type of this delegate.
  2752   typedef FastDelegate SelfType;
  2753 
  2754   // Mimic the base class constructors.
  2755   FastDelegate() : BaseType() { }
  2756 
  2757   template < class X, class Y >
  2758   FastDelegate(Y * pthis,
  2759     R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9 ))
  2760     : BaseType(pthis, function_to_bind)  { }
  2761 
  2762   template < class X, class Y >
  2763   FastDelegate(const Y *pthis,
  2764       R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9 ) const)
  2765     : BaseType(pthis, function_to_bind)
  2766   {  }
  2767 
  2768   FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9 ))
  2769     : BaseType(function_to_bind)  { }
  2770   void operator = (const BaseType &x)  {
  2771 		*static_cast<BaseType*>(this) = x; }
  2772 };
  2773 
  2774 //N=10
  2775 // Specialization to allow use of
  2776 // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10 ) >
  2777 // instead of
  2778 // FastDelegate10 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, R >
  2779 template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10>
  2780 class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10 ) >
  2781   // Inherit from FastDelegate10 so that it can be treated just like a FastDelegate10
  2782   : public FastDelegate10 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, R >
  2783 {
  2784 public:
  2785   // Make using the base type a bit easier via typedef.
  2786   typedef FastDelegate10 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, R > BaseType;
  2787 
  2788   // Allow users access to the specific type of this delegate.
  2789   typedef FastDelegate SelfType;
  2790 
  2791   // Mimic the base class constructors.
  2792   FastDelegate() : BaseType() { }
  2793 
  2794   template < class X, class Y >
  2795   FastDelegate(Y * pthis,
  2796     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 ))
  2797     : BaseType(pthis, function_to_bind)  { }
  2798 
  2799   template < class X, class Y >
  2800   FastDelegate(const Y *pthis,
  2801       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)
  2802     : BaseType(pthis, function_to_bind)
  2803   {  }
  2804 
  2805   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 ))
  2806     : BaseType(function_to_bind)  { }
  2807   void operator = (const BaseType &x)  {
  2808 		*static_cast<BaseType*>(this) = x; }
  2809 };
  2810 
  2811 //N=11
  2812 // Specialization to allow use of
  2813 // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11 ) >
  2814 // instead of
  2815 // FastDelegate11 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, R >
  2816 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>
  2817 class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11 ) >
  2818   // Inherit from FastDelegate11 so that it can be treated just like a FastDelegate11
  2819   : public FastDelegate11 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, R >
  2820 {
  2821 public:
  2822   // Make using the base type a bit easier via typedef.
  2823   typedef FastDelegate11 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, R > BaseType;
  2824 
  2825   // Allow users access to the specific type of this delegate.
  2826   typedef FastDelegate SelfType;
  2827 
  2828   // Mimic the base class constructors.
  2829   FastDelegate() : BaseType() { }
  2830 
  2831   template < class X, class Y >
  2832   FastDelegate(Y * pthis,
  2833     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 ))
  2834     : BaseType(pthis, function_to_bind)  { }
  2835 
  2836   template < class X, class Y >
  2837   FastDelegate(const Y *pthis,
  2838       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)
  2839     : BaseType(pthis, function_to_bind)
  2840   {  }
  2841 
  2842   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 ))
  2843     : BaseType(function_to_bind)  { }
  2844   void operator = (const BaseType &x)  {
  2845 		*static_cast<BaseType*>(this) = x; }
  2846 };
  2847 
  2848 //N=12
  2849 // Specialization to allow use of
  2850 // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12 ) >
  2851 // instead of
  2852 // FastDelegate12 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, R >
  2853 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>
  2854 class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12 ) >
  2855   // Inherit from FastDelegate12 so that it can be treated just like a FastDelegate12
  2856   : public FastDelegate12 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, R >
  2857 {
  2858 public:
  2859   // Make using the base type a bit easier via typedef.
  2860   typedef FastDelegate12 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, R > BaseType;
  2861 
  2862   // Allow users access to the specific type of this delegate.
  2863   typedef FastDelegate SelfType;
  2864 
  2865   // Mimic the base class constructors.
  2866   FastDelegate() : BaseType() { }
  2867 
  2868   template < class X, class Y >
  2869   FastDelegate(Y * pthis,
  2870     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 ))
  2871     : BaseType(pthis, function_to_bind)  { }
  2872 
  2873   template < class X, class Y >
  2874   FastDelegate(const Y *pthis,
  2875       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)
  2876     : BaseType(pthis, function_to_bind)
  2877   {  }
  2878 
  2879   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 ))
  2880     : BaseType(function_to_bind)  { }
  2881   void operator = (const BaseType &x)  {
  2882 		*static_cast<BaseType*>(this) = x; }
  2883 };
  2884 
  2885 //N=13
  2886 // Specialization to allow use of
  2887 // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13 ) >
  2888 // instead of
  2889 // FastDelegate13 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, R >
  2890 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>
  2891 class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13 ) >
  2892   // Inherit from FastDelegate13 so that it can be treated just like a FastDelegate13
  2893   : public FastDelegate13 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, R >
  2894 {
  2895 public:
  2896   // Make using the base type a bit easier via typedef.
  2897   typedef FastDelegate13 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, R > BaseType;
  2898 
  2899   // Allow users access to the specific type of this delegate.
  2900   typedef FastDelegate SelfType;
  2901 
  2902   // Mimic the base class constructors.
  2903   FastDelegate() : BaseType() { }
  2904 
  2905   template < class X, class Y >
  2906   FastDelegate(Y * pthis,
  2907     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 ))
  2908     : BaseType(pthis, function_to_bind)  { }
  2909 
  2910   template < class X, class Y >
  2911   FastDelegate(const Y *pthis,
  2912       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)
  2913     : BaseType(pthis, function_to_bind)
  2914   {  }
  2915 
  2916   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 ))
  2917     : BaseType(function_to_bind)  { }
  2918   void operator = (const BaseType &x)  {
  2919 		*static_cast<BaseType*>(this) = x; }
  2920 };
  2921 
  2922 //N=14
  2923 // Specialization to allow use of
  2924 // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14 ) >
  2925 // instead of
  2926 // FastDelegate14 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, R >
  2927 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>
  2928 class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14 ) >
  2929   // Inherit from FastDelegate14 so that it can be treated just like a FastDelegate14
  2930   : public FastDelegate14 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, R >
  2931 {
  2932 public:
  2933   // Make using the base type a bit easier via typedef.
  2934   typedef FastDelegate14 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, R > BaseType;
  2935 
  2936   // Allow users access to the specific type of this delegate.
  2937   typedef FastDelegate SelfType;
  2938 
  2939   // Mimic the base class constructors.
  2940   FastDelegate() : BaseType() { }
  2941 
  2942   template < class X, class Y >
  2943   FastDelegate(Y * pthis,
  2944     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 ))
  2945     : BaseType(pthis, function_to_bind)  { }
  2946 
  2947   template < class X, class Y >
  2948   FastDelegate(const Y *pthis,
  2949       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)
  2950     : BaseType(pthis, function_to_bind)
  2951   {  }
  2952 
  2953   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 ))
  2954     : BaseType(function_to_bind)  { }
  2955   void operator = (const BaseType &x)  {
  2956 		*static_cast<BaseType*>(this) = x; }
  2957 };
  2958 
  2959 //N=15
  2960 // Specialization to allow use of
  2961 // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15 ) >
  2962 // instead of
  2963 // FastDelegate15 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, R >
  2964 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>
  2965 class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15 ) >
  2966   // Inherit from FastDelegate15 so that it can be treated just like a FastDelegate15
  2967   : public FastDelegate15 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, R >
  2968 {
  2969 public:
  2970   // Make using the base type a bit easier via typedef.
  2971   typedef FastDelegate15 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, R > BaseType;
  2972 
  2973   // Allow users access to the specific type of this delegate.
  2974   typedef FastDelegate SelfType;
  2975 
  2976   // Mimic the base class constructors.
  2977   FastDelegate() : BaseType() { }
  2978 
  2979   template < class X, class Y >
  2980   FastDelegate(Y * pthis,
  2981     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 ))
  2982     : BaseType(pthis, function_to_bind)  { }
  2983 
  2984   template < class X, class Y >
  2985   FastDelegate(const Y *pthis,
  2986       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)
  2987     : BaseType(pthis, function_to_bind)
  2988   {  }
  2989 
  2990   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 ))
  2991     : BaseType(function_to_bind)  { }
  2992   void operator = (const BaseType &x)  {
  2993 		*static_cast<BaseType*>(this) = x; }
  2994 };
  2995 
  2996 //N=16
  2997 // Specialization to allow use of
  2998 // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16 ) >
  2999 // instead of
  3000 // FastDelegate16 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, R >
  3001 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>
  3002 class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16 ) >
  3003   // Inherit from FastDelegate16 so that it can be treated just like a FastDelegate16
  3004   : public FastDelegate16 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, R >
  3005 {
  3006 public:
  3007   // Make using the base type a bit easier via typedef.
  3008   typedef FastDelegate16 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, R > BaseType;
  3009 
  3010   // Allow users access to the specific type of this delegate.
  3011   typedef FastDelegate SelfType;
  3012 
  3013   // Mimic the base class constructors.
  3014   FastDelegate() : BaseType() { }
  3015 
  3016   template < class X, class Y >
  3017   FastDelegate(Y * pthis,
  3018     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 ))
  3019     : BaseType(pthis, function_to_bind)  { }
  3020 
  3021   template < class X, class Y >
  3022   FastDelegate(const Y *pthis,
  3023       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)
  3024     : BaseType(pthis, function_to_bind)
  3025   {  }
  3026 
  3027   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 ))
  3028     : BaseType(function_to_bind)  { }
  3029   void operator = (const BaseType &x)  {
  3030 		*static_cast<BaseType*>(this) = x; }
  3031 };
  3032 
  3033 //N=17
  3034 // Specialization to allow use of
  3035 // FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17 ) >
  3036 // instead of
  3037 // FastDelegate17 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, R >
  3038 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, class Param17>
  3039 class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17 ) >
  3040   // Inherit from FastDelegate17 so that it can be treated just like a FastDelegate17
  3041   : public FastDelegate17 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, R >
  3042 {
  3043 public:
  3044   // Make using the base type a bit easier via typedef.
  3045   typedef FastDelegate17 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, R > BaseType;
  3046 
  3047   // Allow users access to the specific type of this delegate.
  3048   typedef FastDelegate SelfType;
  3049 
  3050   // Mimic the base class constructors.
  3051   FastDelegate() : BaseType() { }
  3052 
  3053   template < class X, class Y >
  3054   FastDelegate(Y * pthis,
  3055     R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17 ))
  3056     : BaseType(pthis, function_to_bind)  { }
  3057 
  3058   template < class X, class Y >
  3059   FastDelegate(const Y *pthis,
  3060       R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17 ) const)
  3061     : BaseType(pthis, function_to_bind)
  3062   {  }
  3063 
  3064   FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16, Param17 p17 ))
  3065     : BaseType(function_to_bind)  { }
  3066   void operator = (const BaseType &x)  {
  3067 		*static_cast<BaseType*>(this) = x; }
  3068 };
  3069 
  3070 
  3071 #endif //FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX
  3072 
  3073 ////////////////////////////////////////////////////////////////////////////////
  3074 //						Fast Delegates, part 5:
  3075 //
  3076 //				MakeDelegate() helper function
  3077 //
  3078 //			MakeDelegate(&x, &X::func) returns a fastdelegate of the type
  3079 //			necessary for calling x.func() with the correct number of arguments.
  3080 //			This makes it possible to eliminate many typedefs from user code.
  3081 //
  3082 ////////////////////////////////////////////////////////////////////////////////
  3083 
  3084 // Also declare overloads of a MakeDelegate() global function to
  3085 // reduce the need for typedefs.
  3086 // We need seperate overloads for const and non-const member functions.
  3087 // Also, because of the weird rule about the class of derived member function pointers,
  3088 // implicit downcasts may need to be applied later to the 'this' pointer.
  3089 // That's why two classes (X and Y) appear in the definitions. Y must be implicitly
  3090 // castable to X.
  3091 
  3092 // Workaround for VC6. VC6 needs void return types converted into DefaultVoid.
  3093 // GCC 3.2 and later won't compile this unless it's preceded by 'typename',
  3094 // but VC6 doesn't allow 'typename' in this context.
  3095 // So, I have to use a macro.
  3096 
  3097 #ifdef FASTDLGT_VC6
  3098 #define FASTDLGT_RETTYPE detail::VoidToDefaultVoid<RetType>::type
  3099 #else
  3100 #define FASTDLGT_RETTYPE RetType
  3101 #endif
  3102 
  3103 //N=0
  3104 template <class X, class Y, class RetType>
  3105 FastDelegate0<FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)()) {
  3106 	return FastDelegate0<FASTDLGT_RETTYPE>(x, func);
  3107 }
  3108 
  3109 template <class X, class Y, class RetType>
  3110 FastDelegate0<FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)() const) {
  3111 	return FastDelegate0<FASTDLGT_RETTYPE>(x, func);
  3112 }
  3113 
  3114 template <class RetType>
  3115 FastDelegate0<FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)()) {
  3116 	return FastDelegate0<FASTDLGT_RETTYPE>(func);
  3117 }
  3118 
  3119 //N=1
  3120 template <class X, class Y, class Param1, class RetType>
  3121 FastDelegate1<Param1, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1)) {
  3122 	return FastDelegate1<Param1, FASTDLGT_RETTYPE>(x, func);
  3123 }
  3124 
  3125 template <class X, class Y, class Param1, class RetType>
  3126 FastDelegate1<Param1, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1) const) {
  3127 	return FastDelegate1<Param1, FASTDLGT_RETTYPE>(x, func);
  3128 }
  3129 
  3130 template <class Param1, class RetType>
  3131 FastDelegate1<Param1, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(Param1 p1)) {
  3132 	return FastDelegate1<Param1, FASTDLGT_RETTYPE>(func);
  3133 }
  3134 
  3135 //N=2
  3136 template <class X, class Y, class Param1, class Param2, class RetType>
  3137 FastDelegate2<Param1, Param2, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2)) {
  3138 	return FastDelegate2<Param1, Param2, FASTDLGT_RETTYPE>(x, func);
  3139 }
  3140 
  3141 template <class X, class Y, class Param1, class Param2, class RetType>
  3142 FastDelegate2<Param1, Param2, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2) const) {
  3143 	return FastDelegate2<Param1, Param2, FASTDLGT_RETTYPE>(x, func);
  3144 }
  3145 
  3146 template <class Param1, class Param2, class RetType>
  3147 FastDelegate2<Param1, Param2, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(Param1 p1, Param2 p2)) {
  3148 	return FastDelegate2<Param1, Param2, FASTDLGT_RETTYPE>(func);
  3149 }
  3150 
  3151 //N=3
  3152 template <class X, class Y, class Param1, class Param2, class Param3, class RetType>
  3153 FastDelegate3<Param1, Param2, Param3, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3)) {
  3154 	return FastDelegate3<Param1, Param2, Param3, FASTDLGT_RETTYPE>(x, func);
  3155 }
  3156 
  3157 template <class X, class Y, class Param1, class Param2, class Param3, class RetType>
  3158 FastDelegate3<Param1, Param2, Param3, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3) const) {
  3159 	return FastDelegate3<Param1, Param2, Param3, FASTDLGT_RETTYPE>(x, func);
  3160 }
  3161 
  3162 template <class Param1, class Param2, class Param3, class RetType>
  3163 FastDelegate3<Param1, Param2, Param3, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3)) {
  3164 	return FastDelegate3<Param1, Param2, Param3, FASTDLGT_RETTYPE>(func);
  3165 }
  3166 
  3167 //N=4
  3168 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class RetType>
  3169 FastDelegate4<Param1, Param2, Param3, Param4, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4)) {
  3170 	return FastDelegate4<Param1, Param2, Param3, Param4, FASTDLGT_RETTYPE>(x, func);
  3171 }
  3172 
  3173 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class RetType>
  3174 FastDelegate4<Param1, Param2, Param3, Param4, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const) {
  3175 	return FastDelegate4<Param1, Param2, Param3, Param4, FASTDLGT_RETTYPE>(x, func);
  3176 }
  3177 
  3178 template <class Param1, class Param2, class Param3, class Param4, class RetType>
  3179 FastDelegate4<Param1, Param2, Param3, Param4, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4)) {
  3180 	return FastDelegate4<Param1, Param2, Param3, Param4, FASTDLGT_RETTYPE>(func);
  3181 }
  3182 
  3183 //N=5
  3184 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class RetType>
  3185 FastDelegate5<Param1, Param2, Param3, Param4, Param5, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5)) {
  3186 	return FastDelegate5<Param1, Param2, Param3, Param4, Param5, FASTDLGT_RETTYPE>(x, func);
  3187 }
  3188 
  3189 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class RetType>
  3190 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) {
  3191 	return FastDelegate5<Param1, Param2, Param3, Param4, Param5, FASTDLGT_RETTYPE>(x, func);
  3192 }
  3193 
  3194 template <class Param1, class Param2, class Param3, class Param4, class Param5, class RetType>
  3195 FastDelegate5<Param1, Param2, Param3, Param4, Param5, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5)) {
  3196 	return FastDelegate5<Param1, Param2, Param3, Param4, Param5, FASTDLGT_RETTYPE>(func);
  3197 }
  3198 
  3199 //N=6
  3200 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class RetType>
  3201 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)) {
  3202 	return FastDelegate6<Param1, Param2, Param3, Param4, Param5, Param6, FASTDLGT_RETTYPE>(x, func);
  3203 }
  3204 
  3205 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class RetType>
  3206 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) {
  3207 	return FastDelegate6<Param1, Param2, Param3, Param4, Param5, Param6, FASTDLGT_RETTYPE>(x, func);
  3208 }
  3209 
  3210 template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class RetType>
  3211 FastDelegate6<Param1, Param2, Param3, Param4, Param5, Param6, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6)) {
  3212 	return FastDelegate6<Param1, Param2, Param3, Param4, Param5, Param6, FASTDLGT_RETTYPE>(func);
  3213 }
  3214 
  3215 //N=7
  3216 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class RetType>
  3217 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)) {
  3218 	return FastDelegate7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, FASTDLGT_RETTYPE>(x, func);
  3219 }
  3220 
  3221 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class RetType>
  3222 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) {
  3223 	return FastDelegate7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, FASTDLGT_RETTYPE>(x, func);
  3224 }
  3225 
  3226 template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class RetType>
  3227 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)) {
  3228 	return FastDelegate7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, FASTDLGT_RETTYPE>(func);
  3229 }
  3230 
  3231 //N=8
  3232 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class RetType>
  3233 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)) {
  3234 	return FastDelegate8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, FASTDLGT_RETTYPE>(x, func);
  3235 }
  3236 
  3237 template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class RetType>
  3238 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) {
  3239 	return FastDelegate8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, FASTDLGT_RETTYPE>(x, func);
  3240 }
  3241 
  3242 template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class RetType>
  3243 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)) {
  3244 	return FastDelegate8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, FASTDLGT_RETTYPE>(func);
  3245 }
  3246 
  3247 //N=9
  3248 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>
  3249 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)) {
  3250 	return FastDelegate9<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, FASTDLGT_RETTYPE>(x, func);
  3251 }
  3252 
  3253 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>
  3254 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) {
  3255 	return FastDelegate9<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, FASTDLGT_RETTYPE>(x, func);
  3256 }
  3257 
  3258 template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class RetType>
  3259 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)) {
  3260 	return FastDelegate9<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, FASTDLGT_RETTYPE>(func);
  3261 }
  3262 
  3263 //N=10
  3264 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>
  3265 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)) {
  3266 	return FastDelegate10<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, FASTDLGT_RETTYPE>(x, func);
  3267 }
  3268 
  3269 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>
  3270 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) {
  3271 	return FastDelegate10<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, FASTDLGT_RETTYPE>(x, func);
  3272 }
  3273 
  3274 template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class RetType>
  3275 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)) {
  3276 	return FastDelegate10<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, FASTDLGT_RETTYPE>(func);
  3277 }
  3278 
  3279 //N=11
  3280 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>
  3281 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)) {
  3282 	return FastDelegate11<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, FASTDLGT_RETTYPE>(x, func);
  3283 }
  3284 
  3285 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>
  3286 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) {
  3287 	return FastDelegate11<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, FASTDLGT_RETTYPE>(x, func);
  3288 }
  3289 
  3290 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>
  3291 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)) {
  3292 	return FastDelegate11<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, FASTDLGT_RETTYPE>(func);
  3293 }
  3294 
  3295 //N=12
  3296 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>
  3297 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)) {
  3298 	return FastDelegate12<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, FASTDLGT_RETTYPE>(x, func);
  3299 }
  3300 
  3301 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>
  3302 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) {
  3303 	return FastDelegate12<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, FASTDLGT_RETTYPE>(x, func);
  3304 }
  3305 
  3306 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>
  3307 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)) {
  3308 	return FastDelegate12<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, FASTDLGT_RETTYPE>(func);
  3309 }
  3310 
  3311 //N=13
  3312 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>
  3313 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)) {
  3314 	return FastDelegate13<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, FASTDLGT_RETTYPE>(x, func);
  3315 }
  3316 
  3317 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>
  3318 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) {
  3319 	return FastDelegate13<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, FASTDLGT_RETTYPE>(x, func);
  3320 }
  3321 
  3322 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>
  3323 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)) {
  3324 	return FastDelegate13<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, FASTDLGT_RETTYPE>(func);
  3325 }
  3326 
  3327 //N=14
  3328 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>
  3329 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)) {
  3330 	return FastDelegate14<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, FASTDLGT_RETTYPE>(x, func);
  3331 }
  3332 
  3333 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>
  3334 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) {
  3335 	return FastDelegate14<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, FASTDLGT_RETTYPE>(x, func);
  3336 }
  3337 
  3338 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>
  3339 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)) {
  3340 	return FastDelegate14<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, FASTDLGT_RETTYPE>(func);
  3341 }
  3342 
  3343 //N=15
  3344 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>
  3345 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)) {
  3346 	return FastDelegate15<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, FASTDLGT_RETTYPE>(x, func);
  3347 }
  3348 
  3349 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>
  3350 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) {
  3351 	return FastDelegate15<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, FASTDLGT_RETTYPE>(x, func);
  3352 }
  3353 
  3354 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>
  3355 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)) {
  3356 	return FastDelegate15<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, FASTDLGT_RETTYPE>(func);
  3357 }
  3358 
  3359 //N=16
  3360 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>
  3361 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)) {
  3362 	return FastDelegate16<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, FASTDLGT_RETTYPE>(x, func);
  3363 }
  3364 
  3365 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>
  3366 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) {
  3367 	return FastDelegate16<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, FASTDLGT_RETTYPE>(x, func);
  3368 }
  3369 
  3370 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>
  3371 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)) {
  3372 	return FastDelegate16<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, FASTDLGT_RETTYPE>(func);
  3373 }
  3374 
  3375 //N=17
  3376 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 Param17, class RetType>
  3377 FastDelegate17<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, 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, Param17 p17)) {
  3378 	return FastDelegate17<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, FASTDLGT_RETTYPE>(x, func);
  3379 }
  3380 
  3381 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 Param17, class RetType>
  3382 FastDelegate17<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, 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, Param17 p17) const) {
  3383 	return FastDelegate17<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, FASTDLGT_RETTYPE>(x, func);
  3384 }
  3385 
  3386 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 Param17, class RetType>
  3387 FastDelegate17<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, 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, Param17 p17)) {
  3388 	return FastDelegate17<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, FASTDLGT_RETTYPE>(func);
  3389 }
  3390 
  3391 
  3392  // clean up after ourselves...
  3393 #undef FASTDLGT_RETTYPE
  3394 
  3395 } // namespace fastdelegate
  3396 
  3397 #endif // !defined(FASTDELEGATE_H)