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