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