sourcehook/FastDelegate.h
author Pavol Marko <pavolmarko@gmail.com>
Thu Oct 06 20:46:49 2005 +0000 (2005-10-06)
changeset 123 53e819ac032a
parent 48 a52dba4f8ed9
child 134 a9e04855f582
permissions -rw-r--r--
It seems to work, but it's not reentrant yet.
pavolmarko@123
     1
//						FastDelegate.h
pavolmarko@1
     2
//	Efficient delegates in C++ that generate only two lines of asm code!
pavolmarko@1
     3
//  Documentation is found at http://www.codeproject.com/cpp/FastDelegate.asp
pavolmarko@1
     4
//
pavolmarko@1
     5
//						- Don Clugston, Mar 2004.
pavolmarko@1
     6
//		Major contributions were made by Jody Hagins.
pavolmarko@1
     7
// History:
pavolmarko@123
     8
// 24-Apr-04 1.0  Submitted to CodeProject.
pavolmarko@1
     9
// 28-Apr-04 1.1  * Prevent most unsafe uses of evil static function hack.
pavolmarko@1
    10
//				  * Improved syntax for horrible_cast (thanks Paul Bludov).
pavolmarko@1
    11
//				  * Tested on Metrowerks MWCC and Intel ICL (IA32)
pavolmarko@1
    12
//				  * Compiled, but not run, on Comeau C++ and Intel Itanium ICL.
pavolmarko@1
    13
//	27-Jun-04 1.2 * Now works on Borland C++ Builder 5.5
pavolmarko@1
    14
//				  * Now works on /clr "managed C++" code on VC7, VC7.1
pavolmarko@1
    15
//				  * Comeau C++ now compiles without warnings.
pavolmarko@123
    16
//				  * Prevent the virtual inheritance case from being used on
pavolmarko@1
    17
//					  VC6 and earlier, which generate incorrect code.
pavolmarko@1
    18
//				  * Improved warning and error messages. Non-standard hacks
pavolmarko@1
    19
//					 now have compile-time checks to make them safer.
pavolmarko@1
    20
//				  * implicit_cast used instead of static_cast in many cases.
pavolmarko@1
    21
//				  * If calling a const member function, a const class pointer can be used.
pavolmarko@1
    22
//				  * MakeDelegate() global helper function added to simplify pass-by-value.
pavolmarko@1
    23
//				  * Added fastdelegate.clear()
pavolmarko@1
    24
// 16-Jul-04 1.2.1* Workaround for gcc bug (const member function pointers in templates)
pavolmarko@1
    25
// 30-Oct-04 1.3  * Support for (non-void) return values.
pavolmarko@1
    26
//				  * No more workarounds in client code!
pavolmarko@1
    27
//					 MSVC and Intel now use a clever hack invented by John Dlugosz:
pavolmarko@1
    28
//				     - The FASTDELEGATEDECLARE workaround is no longer necessary.
pavolmarko@1
    29
//					 - No more warning messages for VC6
pavolmarko@1
    30
//				  * Less use of macros. Error messages should be more comprehensible.
pavolmarko@1
    31
//				  * Added include guards
pavolmarko@1
    32
//				  * Added FastDelegate::empty() to test if invocation is safe (Thanks Neville Franks).
pavolmarko@1
    33
//				  * Now tested on VS 2005 Beta, PGI C++
pavolmarko@1
    34
// 24-Dec-04 1.4  * Added DelegateMemento, to allow collections of disparate delegates.
pavolmarko@1
    35
//                * <,>,<=,>= comparison operators to allow storage in ordered containers.
pavolmarko@1
    36
//				  * Substantial reduction of code size, especially the 'Closure' class.
pavolmarko@1
    37
//				  * Standardised all the compiler-specific workarounds.
pavolmarko@1
    38
//                * MFP conversion now works for CodePlay (but not yet supported in the full code).
pavolmarko@1
    39
//                * Now compiles without warnings on _any_ compiler, including BCC 5.5.1
pavolmarko@123
    40
//				  * New syntax: FastDelegate< int (char *, double) >.
pavolmarko@1
    41
pavolmarko@1
    42
#ifndef FASTDELEGATE_H
pavolmarko@1
    43
#define FASTDELEGATE_H
pavolmarko@48
    44
pavolmarko@48
    45
#ifdef _MSC_VER
pavolmarko@48
    46
# if _MSC_VER > 1000
pavolmarko@48
    47
#  pragma once
pavolmarko@48
    48
# endif // _MSC_VER > 1000
pavolmarko@48
    49
#endif // #ifdef _MSC_VER
pavolmarko@1
    50
pavolmarko@1
    51
#include <memory.h> // to allow <,> comparisons
pavolmarko@1
    52
pavolmarko@1
    53
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
    54
//						Configuration options
pavolmarko@1
    55
//
pavolmarko@1
    56
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
    57
pavolmarko@1
    58
// Uncomment the following #define for optimally-sized delegates.
pavolmarko@1
    59
// In this case, the generated asm code is almost identical to the code you'd get
pavolmarko@1
    60
// if the compiler had native support for delegates.
pavolmarko@123
    61
// It will not work on systems where sizeof(dataptr) < sizeof(codeptr).
pavolmarko@1
    62
// Thus, it will not work for DOS compilers using the medium model.
pavolmarko@1
    63
// It will also probably fail on some DSP systems.
pavolmarko@1
    64
#define FASTDELEGATE_USESTATICFUNCTIONHACK
pavolmarko@1
    65
pavolmarko@1
    66
// Uncomment the next line to allow function declarator syntax.
pavolmarko@1
    67
// It is automatically enabled for those compilers where it is known to work.
pavolmarko@1
    68
//#define FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX
pavolmarko@1
    69
pavolmarko@1
    70
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
    71
//						Compiler identification for workarounds
pavolmarko@1
    72
//
pavolmarko@1
    73
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
    74
pavolmarko@1
    75
// Compiler identification. It's not easy to identify Visual C++ because
pavolmarko@1
    76
// many vendors fraudulently define Microsoft's identifiers.
pavolmarko@1
    77
#if defined(_MSC_VER) && !defined(__MWERKS__) && !defined(__VECTOR_C) && !defined(__ICL) && !defined(__BORLANDC__)
pavolmarko@1
    78
#define FASTDLGT_ISMSVC
pavolmarko@1
    79
pavolmarko@1
    80
#if (_MSC_VER <1300) // Many workarounds are required for VC6.
pavolmarko@1
    81
#define FASTDLGT_VC6
pavolmarko@1
    82
#pragma warning(disable:4786) // disable this ridiculous warning
pavolmarko@1
    83
#endif
pavolmarko@1
    84
pavolmarko@1
    85
#endif
pavolmarko@1
    86
pavolmarko@1
    87
// Does the compiler uses Microsoft's member function pointer structure?
pavolmarko@1
    88
// If so, it needs special treatment.
pavolmarko@123
    89
// Metrowerks CodeWarrior, Intel, and CodePlay fraudulently define Microsoft's
pavolmarko@1
    90
// identifier, _MSC_VER. We need to filter Metrowerks out.
pavolmarko@1
    91
#if defined(_MSC_VER) && !defined(__MWERKS__)
pavolmarko@1
    92
#define FASTDLGT_MICROSOFT_MFP
pavolmarko@1
    93
pavolmarko@1
    94
#if !defined(__VECTOR_C)
pavolmarko@1
    95
// CodePlay doesn't have the __single/multi/virtual_inheritance keywords
pavolmarko@1
    96
#define FASTDLGT_HASINHERITANCE_KEYWORDS
pavolmarko@1
    97
#endif
pavolmarko@1
    98
#endif
pavolmarko@1
    99
pavolmarko@1
   100
// Does it allow function declarator syntax? The following compilers are known to work:
pavolmarko@1
   101
#if defined(FASTDLGT_ISMSVC) && (_MSC_VER >=1310) // VC 7.1
pavolmarko@1
   102
#define FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX
pavolmarko@1
   103
#endif
pavolmarko@1
   104
pavolmarko@1
   105
// Gcc(2.95+), and versions of Digital Mars, Intel and Comeau in common use.
pavolmarko@1
   106
#if defined (__DMC__) || defined(__GNUC__) || defined(__ICL) || defined(__COMO__)
pavolmarko@1
   107
#define FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX
pavolmarko@1
   108
#endif
pavolmarko@1
   109
pavolmarko@1
   110
// It works on Metrowerks MWCC 3.2.2. From boost.Config it should work on earlier ones too.
pavolmarko@1
   111
#if defined (__MWERKS__)
pavolmarko@1
   112
#define FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX
pavolmarko@1
   113
#endif
pavolmarko@1
   114
pavolmarko@123
   115
#ifdef __GNUC__ // Workaround GCC bug #8271
pavolmarko@1
   116
	// At present, GCC doesn't recognize constness of MFPs in templates
pavolmarko@1
   117
#define FASTDELEGATE_GCC_BUG_8271
pavolmarko@1
   118
#endif
pavolmarko@1
   119
pavolmarko@1
   120
pavolmarko@1
   121
pavolmarko@1
   122
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   123
//						General tricks used in this code
pavolmarko@1
   124
//
pavolmarko@1
   125
// (a) Error messages are generated by typdefing an array of negative size to
pavolmarko@1
   126
//     generate compile-time errors.
pavolmarko@1
   127
// (b) Warning messages on MSVC are generated by declaring unused variables, and
pavolmarko@1
   128
//	    enabling the "variable XXX is never used" warning.
pavolmarko@1
   129
// (c) Unions are used in a few compiler-specific cases to perform illegal casts.
pavolmarko@1
   130
// (d) For Microsoft and Intel, when adjusting the 'this' pointer, it's cast to
pavolmarko@1
   131
//     (char *) first to ensure that the correct number of *bytes* are added.
pavolmarko@1
   132
//
pavolmarko@1
   133
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   134
//						Helper templates
pavolmarko@1
   135
//
pavolmarko@1
   136
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   137
pavolmarko@1
   138
pavolmarko@1
   139
namespace fastdelegate {
pavolmarko@1
   140
namespace detail {	// we'll hide the implementation details in a nested namespace.
pavolmarko@1
   141
pavolmarko@1
   142
//		implicit_cast< >
pavolmarko@123
   143
// I believe this was originally going to be in the C++ standard but
pavolmarko@1
   144
// was left out by accident. It's even milder than static_cast.
pavolmarko@1
   145
// I use it instead of static_cast<> to emphasize that I'm not doing
pavolmarko@123
   146
// anything nasty.
pavolmarko@1
   147
// Usage is identical to static_cast<>
pavolmarko@1
   148
template <class OutputClass, class InputClass>
pavolmarko@1
   149
inline OutputClass implicit_cast(InputClass input){
pavolmarko@1
   150
	return input;
pavolmarko@1
   151
}
pavolmarko@1
   152
pavolmarko@1
   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@1
   156
// to perform the cast is undefined behaviour (even in C). But we can see if
pavolmarko@1
   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@1
   159
// Usage is identical to reinterpret_cast<>.
pavolmarko@1
   160
pavolmarko@1
   161
// This union is declared outside the horrible_cast because BCC 5.5.1
pavolmarko@1
   162
// can't inline a function with a nested class, and gives a warning.
pavolmarko@1
   163
template <class OutputClass, class InputClass>
pavolmarko@1
   164
union horrible_union{
pavolmarko@1
   165
	OutputClass out;
pavolmarko@1
   166
	InputClass in;
pavolmarko@1
   167
};
pavolmarko@1
   168
pavolmarko@1
   169
template <class OutputClass, class InputClass>
pavolmarko@1
   170
inline OutputClass horrible_cast(const InputClass input){
pavolmarko@1
   171
	horrible_union<OutputClass, InputClass> u;
pavolmarko@1
   172
	// Cause a compile-time error if in, out and u are not the same size.
pavolmarko@1
   173
	// If the compile fails here, it means the compiler has peculiar
pavolmarko@1
   174
	// unions which would prevent the cast from working.
pavolmarko@123
   175
	typedef int ERROR_CantUseHorrible_cast[sizeof(InputClass)==sizeof(u)
pavolmarko@1
   176
		&& sizeof(InputClass)==sizeof(OutputClass) ? 1 : -1];
pavolmarko@1
   177
	u.in = input;
pavolmarko@1
   178
	return u.out;
pavolmarko@1
   179
}
pavolmarko@1
   180
pavolmarko@1
   181
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   182
//						Workarounds
pavolmarko@1
   183
//
pavolmarko@1
   184
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   185
pavolmarko@1
   186
// Backwards compatibility: This macro used to be necessary in the virtual inheritance
pavolmarko@1
   187
// case for Intel and Microsoft. Now it just forward-declares the class.
pavolmarko@1
   188
#define FASTDELEGATEDECLARE(CLASSNAME)	class CLASSNAME;
pavolmarko@1
   189
pavolmarko@1
   190
// Prevent use of the static function hack with the DOS medium model.
pavolmarko@1
   191
#ifdef __MEDIUM__
pavolmarko@1
   192
#undef FASTDELEGATE_USESTATICFUNCTIONHACK
pavolmarko@1
   193
#endif
pavolmarko@1
   194
pavolmarko@1
   195
//			DefaultVoid - a workaround for 'void' templates in VC6.
pavolmarko@1
   196
//
pavolmarko@1
   197
//  (1) VC6 and earlier do not allow 'void' as a default template argument.
pavolmarko@1
   198
//  (2) They also doesn't allow you to return 'void' from a function.
pavolmarko@1
   199
//
pavolmarko@1
   200
// Workaround for (1): Declare a dummy type 'DefaultVoid' which we use
pavolmarko@1
   201
//   when we'd like to use 'void'. We convert it into 'void' and back
pavolmarko@1
   202
//   using the templates DefaultVoidToVoid<> and VoidToDefaultVoid<>.
pavolmarko@1
   203
// Workaround for (2): On VC6, the code for calling a void function is
pavolmarko@1
   204
//   identical to the code for calling a non-void function in which the
pavolmarko@1
   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@1
   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@1
   209
//   in any automatic conversions. But on a 16-bit compiler it might
pavolmarko@1
   210
//   cause extra code to be generated, so we disable it for all compilers
pavolmarko@1
   211
//   except for VC6 (and VC5).
pavolmarko@1
   212
#ifdef FASTDLGT_VC6
pavolmarko@1
   213
// VC6 workaround
pavolmarko@1
   214
typedef const void * DefaultVoid;
pavolmarko@1
   215
#else
pavolmarko@1
   216
// On any other compiler, just use a normal void.
pavolmarko@1
   217
typedef void DefaultVoid;
pavolmarko@1
   218
#endif
pavolmarko@1
   219
pavolmarko@1
   220
// Translate from 'DefaultVoid' to 'void'.
pavolmarko@1
   221
// Everything else is unchanged
pavolmarko@1
   222
template <class T>
pavolmarko@1
   223
struct DefaultVoidToVoid { typedef T type; };
pavolmarko@1
   224
pavolmarko@1
   225
template <>
pavolmarko@1
   226
struct DefaultVoidToVoid<DefaultVoid> {	typedef void type; };
pavolmarko@1
   227
pavolmarko@1
   228
// Translate from 'void' into 'DefaultVoid'
pavolmarko@1
   229
// Everything else is unchanged
pavolmarko@1
   230
template <class T>
pavolmarko@1
   231
struct VoidToDefaultVoid { typedef T type; };
pavolmarko@1
   232
pavolmarko@1
   233
template <>
pavolmarko@1
   234
struct VoidToDefaultVoid<void> { typedef DefaultVoid type; };
pavolmarko@1
   235
pavolmarko@1
   236
pavolmarko@1
   237
pavolmarko@1
   238
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   239
//						Fast Delegates, part 1:
pavolmarko@1
   240
//
pavolmarko@1
   241
//		Conversion of member function pointer to a standard form
pavolmarko@1
   242
//
pavolmarko@1
   243
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   244
pavolmarko@1
   245
// GenericClass is a fake class, ONLY used to provide a type.
pavolmarko@1
   246
// It is vitally important that it is never defined, so that the compiler doesn't
pavolmarko@1
   247
// think it can optimize the invocation. For example, Borland generates simpler
pavolmarko@1
   248
// code if it knows the class only uses single inheritance.
pavolmarko@1
   249
pavolmarko@1
   250
// Compilers using Microsoft's structure need to be treated as a special case.
pavolmarko@1
   251
#ifdef  FASTDLGT_MICROSOFT_MFP
pavolmarko@1
   252
pavolmarko@1
   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@1
   256
	// would give 16 byte pointers in this case....
pavolmarko@1
   257
	class __single_inheritance GenericClass;
pavolmarko@1
   258
#endif
pavolmarko@1
   259
	// ...but for Codeplay, an empty class *always* gives 4 byte pointers.
pavolmarko@1
   260
	// If compiled with the /clr option ("managed C++"), the JIT compiler thinks
pavolmarko@1
   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@1
   263
	// empty class to make it happy.
pavolmarko@1
   264
	// Codeplay and VC4 can't cope with the unknown_inheritance case either.
pavolmarko@1
   265
	class GenericClass {};
pavolmarko@1
   266
#else
pavolmarko@1
   267
	class GenericClass;
pavolmarko@1
   268
#endif
pavolmarko@1
   269
pavolmarko@1
   270
// The size of a single inheritance member function pointer.
pavolmarko@1
   271
const int SINGLE_MEMFUNCPTR_SIZE = sizeof(void (GenericClass::*)());
pavolmarko@1
   272
pavolmarko@1
   273
//						SimplifyMemFunc< >::Convert()
pavolmarko@1
   274
//
pavolmarko@123
   275
//	A template function that converts an arbitrary member function pointer into the
pavolmarko@1
   276
//	simplest possible form of member function pointer, using a supplied 'this' pointer.
pavolmarko@1
   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@1
   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@1
   282
//	template specialisation, I use full specialisation of a wrapper struct.
pavolmarko@1
   283
pavolmarko@1
   284
// general case -- don't know how to convert it. Force a compile failure
pavolmarko@1
   285
template <int N>
pavolmarko@1
   286
struct SimplifyMemFunc {
pavolmarko@1
   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@1
   290
		// Unsupported member function type -- force a compile failure.
pavolmarko@1
   291
	    // (it's illegal to have a array with negative size).
pavolmarko@1
   292
		typedef char ERROR_Unsupported_member_function_pointer_on_this_compiler[N-100];
pavolmarko@123
   293
		return 0;
pavolmarko@1
   294
	}
pavolmarko@1
   295
};
pavolmarko@1
   296
pavolmarko@1
   297
// For compilers where all member func ptrs are the same size, everything goes here.
pavolmarko@1
   298
// For non-standard compilers, only single_inheritance classes go here.
pavolmarko@1
   299
template <>
pavolmarko@123
   300
struct SimplifyMemFunc<SINGLE_MEMFUNCPTR_SIZE>  {
pavolmarko@1
   301
	template <class X, class XFuncType, class GenericMemFuncType>
pavolmarko@123
   302
	inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind,
pavolmarko@1
   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@1
   306
		// even though the standard says you can. The 32-bit compiler lets you
pavolmarko@1
   307
		// static_cast through an int, but the DOS compiler doesn't.
pavolmarko@1
   308
		bound_func = horrible_cast<GenericMemFuncType>(function_to_bind);
pavolmarko@123
   309
#else
pavolmarko@1
   310
        bound_func = reinterpret_cast<GenericMemFuncType>(function_to_bind);
pavolmarko@1
   311
#endif
pavolmarko@1
   312
        return reinterpret_cast<GenericClass *>(pthis);
pavolmarko@1
   313
	}
pavolmarko@1
   314
};
pavolmarko@1
   315
pavolmarko@1
   316
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   317
//						Fast Delegates, part 1b:
pavolmarko@1
   318
//
pavolmarko@1
   319
//					Workarounds for Microsoft and Intel
pavolmarko@1
   320
//
pavolmarko@1
   321
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   322
pavolmarko@1
   323
pavolmarko@1
   324
// Compilers with member function pointers which violate the standard (MSVC, Intel, Codeplay),
pavolmarko@1
   325
// need to be treated as a special case.
pavolmarko@1
   326
#ifdef FASTDLGT_MICROSOFT_MFP
pavolmarko@1
   327
pavolmarko@1
   328
// We use unions to perform horrible_casts. I would like to use #pragma pack(push, 1)
pavolmarko@1
   329
// at the start of each function for extra safety, but VC6 seems to ICE
pavolmarko@1
   330
// intermittently if you do this inside a template.
pavolmarko@1
   331
pavolmarko@1
   332
// __multiple_inheritance classes go here
pavolmarko@1
   333
// Nasty hack for Microsoft and Intel (IA32 and Itanium)
pavolmarko@1
   334
template<>
pavolmarko@1
   335
struct SimplifyMemFunc< SINGLE_MEMFUNCPTR_SIZE + sizeof(int) >  {
pavolmarko@1
   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@1
   339
		// We need to use a horrible_cast to do this conversion.
pavolmarko@1
   340
		// In MSVC, a multiple inheritance member pointer is internally defined as:
pavolmarko@1
   341
        union {
pavolmarko@1
   342
			XFuncType func;
pavolmarko@123
   343
			struct {
pavolmarko@1
   344
				GenericMemFuncType funcaddress; // points to the actual member function
pavolmarko@1
   345
				int delta;	     // #BYTES to be added to the 'this' pointer
pavolmarko@1
   346
			}s;
pavolmarko@1
   347
        } u;
pavolmarko@1
   348
		// Check that the horrible_cast will work
pavolmarko@1
   349
		typedef int ERROR_CantUsehorrible_cast[sizeof(function_to_bind)==sizeof(u.s)? 1 : -1];
pavolmarko@1
   350
        u.func = function_to_bind;
pavolmarko@1
   351
		bound_func = u.s.funcaddress;
pavolmarko@123
   352
		return reinterpret_cast<GenericClass *>(reinterpret_cast<char *>(pthis) + u.s.delta);
pavolmarko@1
   353
	}
pavolmarko@1
   354
};
pavolmarko@1
   355
pavolmarko@1
   356
// virtual inheritance is a real nuisance. It's inefficient and complicated.
pavolmarko@1
   357
// On MSVC and Intel, there isn't enough information in the pointer itself to
pavolmarko@1
   358
// enable conversion to a closure pointer. Earlier versions of this code didn't
pavolmarko@1
   359
// work for all cases, and generated a compile-time error instead.
pavolmarko@1
   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@1
   362
// assumptions about the calling convention that is used.
pavolmarko@1
   363
pavolmarko@123
   364
// In VC++ and ICL, a virtual_inheritance member pointer
pavolmarko@1
   365
// is internally defined as:
pavolmarko@1
   366
struct MicrosoftVirtualMFP {
pavolmarko@1
   367
	void (GenericClass::*codeptr)(); // points to the actual member function
pavolmarko@1
   368
	int delta;		// #bytes to be added to the 'this' pointer
pavolmarko@1
   369
	int vtable_index; // or 0 if no virtual inheritance
pavolmarko@1
   370
};
pavolmarko@1
   371
// The CRUCIAL feature of Microsoft/Intel MFPs which we exploit is that the
pavolmarko@1
   372
// m_codeptr member is *always* called, regardless of the values of the other
pavolmarko@1
   373
// members. (This is *not* true for other compilers, eg GCC, which obtain the
pavolmarko@1
   374
// function address from the vtable if a virtual function is being called).
pavolmarko@1
   375
// Dlugosz's trick is to make the codeptr point to a probe function which
pavolmarko@1
   376
// returns the 'this' pointer that was used.
pavolmarko@1
   377
pavolmarko@1
   378
// Define a generic class that uses virtual inheritance.
pavolmarko@1
   379
// It has a trival member function that returns the value of the 'this' pointer.
pavolmarko@1
   380
struct GenericVirtualClass : virtual public GenericClass
pavolmarko@1
   381
{
pavolmarko@1
   382
	typedef GenericVirtualClass * (GenericVirtualClass::*ProbePtrType)();
pavolmarko@1
   383
	GenericVirtualClass * GetThis() { return this; }
pavolmarko@1
   384
};
pavolmarko@1
   385
pavolmarko@1
   386
// __virtual_inheritance classes go here
pavolmarko@1
   387
template <>
pavolmarko@1
   388
struct SimplifyMemFunc<SINGLE_MEMFUNCPTR_SIZE + 2*sizeof(int) >
pavolmarko@1
   389
{
pavolmarko@1
   390
pavolmarko@1
   391
	template <class X, class XFuncType, class GenericMemFuncType>
pavolmarko@123
   392
	inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind,
pavolmarko@1
   393
		GenericMemFuncType &bound_func) {
pavolmarko@1
   394
		union {
pavolmarko@1
   395
			XFuncType func;
pavolmarko@1
   396
			GenericClass* (X::*ProbeFunc)();
pavolmarko@1
   397
			MicrosoftVirtualMFP s;
pavolmarko@1
   398
		} u;
pavolmarko@1
   399
		u.func = function_to_bind;
pavolmarko@1
   400
		bound_func = reinterpret_cast<GenericMemFuncType>(u.s.codeptr);
pavolmarko@1
   401
		union {
pavolmarko@1
   402
			GenericVirtualClass::ProbePtrType virtfunc;
pavolmarko@1
   403
			MicrosoftVirtualMFP s;
pavolmarko@1
   404
		} u2;
pavolmarko@1
   405
		// Check that the horrible_cast<>s will work
pavolmarko@1
   406
		typedef int ERROR_CantUsehorrible_cast[sizeof(function_to_bind)==sizeof(u.s)
pavolmarko@1
   407
			&& sizeof(function_to_bind)==sizeof(u.ProbeFunc)
pavolmarko@1
   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@1
   410
   // this next line can't be completely optimised away by the compiler.
pavolmarko@1
   411
		u2.virtfunc = &GenericVirtualClass::GetThis;
pavolmarko@1
   412
		u.s.codeptr = u2.s.codeptr;
pavolmarko@1
   413
		return (pthis->*u.ProbeFunc)();
pavolmarko@1
   414
	}
pavolmarko@1
   415
};
pavolmarko@1
   416
pavolmarko@1
   417
#if (_MSC_VER <1300)
pavolmarko@1
   418
pavolmarko@1
   419
// Nasty hack for Microsoft Visual C++ 6.0
pavolmarko@1
   420
// unknown_inheritance classes go here
pavolmarko@1
   421
// There is a compiler bug in MSVC6 which generates incorrect code in this case!!
pavolmarko@1
   422
template <>
pavolmarko@1
   423
struct SimplifyMemFunc<SINGLE_MEMFUNCPTR_SIZE + 3*sizeof(int) >
pavolmarko@1
   424
{
pavolmarko@1
   425
	template <class X, class XFuncType, class GenericMemFuncType>
pavolmarko@123
   426
	inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind,
pavolmarko@1
   427
		GenericMemFuncType &bound_func) {
pavolmarko@1
   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@1
   430
		// unknown_inheritance case!
pavolmarko@1
   431
		// This means that an incorrect function could be called!!!
pavolmarko@1
   432
		// Compiling with the /vmg option leads to potentially incorrect code.
pavolmarko@1
   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@1
   435
		// the command line. In VC1.5 and earlier, the compiler would ICE if it ever
pavolmarko@1
   436
		// encountered this situation.
pavolmarko@1
   437
		// It is OK to use the /vmg option if /vmm or /vms is specified.
pavolmarko@1
   438
pavolmarko@1
   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@1
   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@1
   444
		// member fpointer. Ie, if you use the base class as an interface, you'll
pavolmarko@1
   445
		// stay out of trouble.
pavolmarko@1
   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@1
   448
		// and 'vtordisp' are zero, but a virtual_inheritance pointer will be generated.
pavolmarko@1
   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@1
   452
		typedef char ERROR_VC6CompilerBug[-100];
pavolmarko@123
   453
		return 0;
pavolmarko@1
   454
	}
pavolmarko@1
   455
};
pavolmarko@1
   456
pavolmarko@1
   457
pavolmarko@123
   458
#else
pavolmarko@1
   459
pavolmarko@1
   460
// Nasty hack for Microsoft and Intel (IA32 and Itanium)
pavolmarko@123
   461
// unknown_inheritance classes go here
pavolmarko@1
   462
// This is probably the ugliest bit of code I've ever written. Look at the casts!
pavolmarko@1
   463
// There is a compiler bug in MSVC6 which prevents it from using this code.
pavolmarko@1
   464
template <>
pavolmarko@1
   465
struct SimplifyMemFunc<SINGLE_MEMFUNCPTR_SIZE + 3*sizeof(int) >
pavolmarko@1
   466
{
pavolmarko@1
   467
	template <class X, class XFuncType, class GenericMemFuncType>
pavolmarko@123
   468
	inline static GenericClass *Convert(X *pthis, XFuncType function_to_bind,
pavolmarko@1
   469
			GenericMemFuncType &bound_func) {
pavolmarko@1
   470
		// The member function pointer is 16 bytes long. We can't use a normal cast, but
pavolmarko@1
   471
		// we can use a union to do the conversion.
pavolmarko@1
   472
		union {
pavolmarko@1
   473
			XFuncType func;
pavolmarko@123
   474
			// In VC++ and ICL, an unknown_inheritance member pointer
pavolmarko@1
   475
			// is internally defined as:
pavolmarko@1
   476
			struct {
pavolmarko@1
   477
				GenericMemFuncType m_funcaddress; // points to the actual member function
pavolmarko@1
   478
				int delta;		// #bytes to be added to the 'this' pointer
pavolmarko@1
   479
				int vtordisp;		// #bytes to add to 'this' to find the vtable
pavolmarko@1
   480
				int vtable_index; // or 0 if no virtual inheritance
pavolmarko@1
   481
			} s;
pavolmarko@1
   482
		} u;
pavolmarko@1
   483
		// Check that the horrible_cast will work
pavolmarko@1
   484
		typedef int ERROR_CantUsehorrible_cast[sizeof(XFuncType)==sizeof(u.s)? 1 : -1];
pavolmarko@1
   485
		u.func = function_to_bind;
pavolmarko@1
   486
		bound_func = u.s.funcaddress;
pavolmarko@1
   487
		int virtual_delta = 0;
pavolmarko@1
   488
		if (u.s.vtable_index) { // Virtual inheritance is used
pavolmarko@123
   489
			// First, get to the vtable.
pavolmarko@1
   490
			// It is 'vtordisp' bytes from the start of the class.
pavolmarko@1
   491
			const int * vtable = *reinterpret_cast<const int *const*>(
pavolmarko@1
   492
				reinterpret_cast<const char *>(pthis) + u.s.vtordisp );
pavolmarko@1
   493
pavolmarko@1
   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@1
   496
				reinterpret_cast<const char *>(vtable) + u.s.vtable_index);
pavolmarko@1
   497
		}
pavolmarko@1
   498
		// The int at 'virtual_delta' gives us the amount to add to 'this'.
pavolmarko@1
   499
        // Finally we can add the three components together. Phew!
pavolmarko@1
   500
        return reinterpret_cast<GenericClass *>(
pavolmarko@1
   501
			reinterpret_cast<char *>(pthis) + u.s.delta + virtual_delta);
pavolmarko@1
   502
	};
pavolmarko@1
   503
};
pavolmarko@1
   504
#endif // MSVC 7 and greater
pavolmarko@1
   505
pavolmarko@1
   506
#endif // MS/Intel hacks
pavolmarko@1
   507
pavolmarko@1
   508
}  // namespace detail
pavolmarko@1
   509
pavolmarko@1
   510
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   511
//						Fast Delegates, part 2:
pavolmarko@1
   512
//
pavolmarko@1
   513
//	Define the delegate storage, and cope with static functions
pavolmarko@1
   514
//
pavolmarko@1
   515
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   516
pavolmarko@1
   517
// DelegateMemento -- an opaque structure which can hold an arbitary delegate.
pavolmarko@1
   518
// It knows nothing about the calling convention or number of arguments used by
pavolmarko@1
   519
// the function pointed to.
pavolmarko@1
   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@1
   522
//   it must be converted to a specific delegate.
pavolmarko@1
   523
pavolmarko@1
   524
// Implementation:
pavolmarko@1
   525
// There are two possible implementations: the Safe method and the Evil method.
pavolmarko@1
   526
//				DelegateMemento - Safe version
pavolmarko@1
   527
//
pavolmarko@1
   528
// This implementation is standard-compliant, but a bit tricky.
pavolmarko@123
   529
// A static function pointer is stored inside the class.
pavolmarko@1
   530
// Here are the valid values:
pavolmarko@1
   531
// +-- Static pointer --+--pThis --+-- pMemFunc-+-- Meaning------+
pavolmarko@1
   532
// |   0				|  0       |   0        | Empty          |
pavolmarko@1
   533
// |   !=0              |(dontcare)|  Invoker   | Static function|
pavolmarko@1
   534
// |   0                |  !=0     |  !=0       | Method call    |
pavolmarko@1
   535
// +--------------------+----------+------------+----------------+
pavolmarko@1
   536
// When stored stored inside a specific delegate, the 'dontcare' entries are replaced
pavolmarko@1
   537
// with a reference to the delegate itself. This complicates the = and == operators
pavolmarko@1
   538
// for the delegate class.
pavolmarko@1
   539
pavolmarko@1
   540
//				DelegateMemento - Evil version
pavolmarko@1
   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@1
   544
// horrible_cast. In this case the DelegateMemento implementation is simple:
pavolmarko@1
   545
// +--pThis --+-- pMemFunc-+-- Meaning---------------------+
pavolmarko@1
   546
// |    0     |  0         | Empty                         |
pavolmarko@1
   547
// |  !=0     |  !=0       | Static function or method call|
pavolmarko@1
   548
// +----------+------------+-------------------------------+
pavolmarko@123
   549
// Note that the Sun C++ and MSVC documentation explicitly state that they
pavolmarko@1
   550
// support static_cast between void * and function pointers.
pavolmarko@1
   551
pavolmarko@1
   552
class DelegateMemento {
pavolmarko@123
   553
protected:
pavolmarko@1
   554
	// the data is protected, not private, because many
pavolmarko@1
   555
	// compilers have problems with template friends.
pavolmarko@1
   556
	typedef void (detail::GenericClass::*GenericMemFuncType)(); // arbitrary MFP.
pavolmarko@1
   557
	detail::GenericClass *m_pthis;
pavolmarko@1
   558
	GenericMemFuncType m_pFunction;
pavolmarko@1
   559
pavolmarko@1
   560
#if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
pavolmarko@1
   561
	typedef void (*GenericFuncPtr)(); // arbitrary code pointer
pavolmarko@1
   562
	GenericFuncPtr m_pStaticFunction;
pavolmarko@1
   563
#endif
pavolmarko@1
   564
pavolmarko@1
   565
public:
pavolmarko@1
   566
#if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
pavolmarko@1
   567
	DelegateMemento() : m_pthis(0), m_pFunction(0), m_pStaticFunction(0) {};
pavolmarko@1
   568
	void clear() {
pavolmarko@1
   569
		m_pthis=0; m_pFunction=0; m_pStaticFunction=0;
pavolmarko@1
   570
	}
pavolmarko@1
   571
#else
pavolmarko@1
   572
	DelegateMemento() : m_pthis(0), m_pFunction(0) {};
pavolmarko@1
   573
	void clear() {
pavolmarko@1
   574
		m_pthis=0; m_pFunction=0;
pavolmarko@1
   575
	}
pavolmarko@1
   576
#endif
pavolmarko@1
   577
public:
pavolmarko@1
   578
#if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
pavolmarko@1
   579
	inline bool IsEqual (const DelegateMemento &x) const{
pavolmarko@1
   580
	    // We have to cope with the static function pointers as a special case
pavolmarko@1
   581
		if (m_pFunction!=x.m_pFunction) return false;
pavolmarko@1
   582
		// the static function ptrs must either both be equal, or both be 0.
pavolmarko@1
   583
		if (m_pStaticFunction!=x.m_pStaticFunction) return false;
pavolmarko@1
   584
		if (m_pStaticFunction!=0) return m_pthis==x.m_pthis;
pavolmarko@1
   585
		else return true;
pavolmarko@1
   586
	}
pavolmarko@1
   587
#else // Evil Method
pavolmarko@1
   588
	inline bool IsEqual (const DelegateMemento &x) const{
pavolmarko@1
   589
		return m_pthis==x.m_pthis && m_pFunction==x.m_pFunction;
pavolmarko@1
   590
	}
pavolmarko@1
   591
#endif
pavolmarko@1
   592
	// Provide a strict weak ordering for DelegateMementos.
pavolmarko@1
   593
	inline bool IsLess(const DelegateMemento &right) const {
pavolmarko@1
   594
		// deal with static function pointers first
pavolmarko@1
   595
#if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
pavolmarko@123
   596
		if (m_pStaticFunction !=0 || right.m_pStaticFunction!=0)
pavolmarko@1
   597
				return m_pStaticFunction < right.m_pStaticFunction;
pavolmarko@1
   598
#endif
pavolmarko@1
   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@1
   601
	// but we can fake one by comparing each byte. The resulting ordering is
pavolmarko@1
   602
	// arbitrary (and compiler-dependent), but it permits storage in ordered STL containers.
pavolmarko@1
   603
		return memcmp(&m_pFunction, &right.m_pFunction, sizeof(m_pFunction)) < 0;
pavolmarko@1
   604
pavolmarko@1
   605
	}
pavolmarko@1
   606
	inline bool operator ! () const		// Is it bound to anything?
pavolmarko@1
   607
	{ return m_pFunction==0; }
pavolmarko@1
   608
public:
pavolmarko@1
   609
	DelegateMemento & operator = (const DelegateMemento &right)  {
pavolmarko@123
   610
		SetMementoFrom(right);
pavolmarko@1
   611
		return *this;
pavolmarko@1
   612
	}
pavolmarko@1
   613
	inline bool operator <(const DelegateMemento &right) {
pavolmarko@1
   614
		return IsLess(right);
pavolmarko@1
   615
	}
pavolmarko@1
   616
	inline bool operator >(const DelegateMemento &right) {
pavolmarko@1
   617
		return right.IsLess(*this);
pavolmarko@1
   618
	}
pavolmarko@123
   619
	DelegateMemento (const DelegateMemento &right)  :
pavolmarko@123
   620
		m_pthis(right.m_pthis), m_pFunction(right.m_pFunction)
pavolmarko@1
   621
#if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
pavolmarko@1
   622
		, m_pStaticFunction (right.m_pStaticFunction)
pavolmarko@1
   623
#endif
pavolmarko@1
   624
		{}
pavolmarko@1
   625
protected:
pavolmarko@1
   626
	void SetMementoFrom(const DelegateMemento &right)  {
pavolmarko@1
   627
		m_pFunction = right.m_pFunction;
pavolmarko@1
   628
		m_pthis = right.m_pthis;
pavolmarko@1
   629
#if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
pavolmarko@1
   630
		m_pStaticFunction = right.m_pStaticFunction;
pavolmarko@1
   631
#endif
pavolmarko@1
   632
	}
pavolmarko@1
   633
};
pavolmarko@1
   634
pavolmarko@1
   635
pavolmarko@1
   636
//						ClosurePtr<>
pavolmarko@1
   637
//
pavolmarko@1
   638
// A private wrapper class that adds function signatures to DelegateMemento.
pavolmarko@1
   639
// It's the class that does most of the actual work.
pavolmarko@1
   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@1
   643
//                 as GenericMemFunc.
pavolmarko@1
   644
// UnvoidStaticFuncPtr: is the same as StaticFuncPtr, except on VC6
pavolmarko@1
   645
//                 where it never returns void (returns DefaultVoid instead).
pavolmarko@1
   646
pavolmarko@1
   647
// An outer class, FastDelegateN<>, handles the invoking and creates the
pavolmarko@1
   648
// necessary typedefs.
pavolmarko@1
   649
// This class does everything else.
pavolmarko@1
   650
pavolmarko@1
   651
namespace detail {
pavolmarko@1
   652
pavolmarko@1
   653
template < class GenericMemFunc, class StaticFuncPtr, class UnvoidStaticFuncPtr>
pavolmarko@1
   654
class ClosurePtr : public DelegateMemento {
pavolmarko@1
   655
public:
pavolmarko@1
   656
	// These functions are for setting the delegate to a member function.
pavolmarko@1
   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@1
   660
	// enforce that here. It needs to be enforced by the wrapper class.
pavolmarko@1
   661
	template < class X, class XMemFunc >
pavolmarko@1
   662
	inline void bindmemfunc(X *pthis, XMemFunc function_to_bind ) {
pavolmarko@1
   663
		m_pthis = SimplifyMemFunc< sizeof(function_to_bind) >
pavolmarko@1
   664
			::Convert(pthis, function_to_bind, m_pFunction);
pavolmarko@1
   665
#if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
pavolmarko@1
   666
		m_pStaticFunction = 0;
pavolmarko@1
   667
#endif
pavolmarko@1
   668
	}
pavolmarko@1
   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@1
   671
	// remove the const qualifier from the 'this' pointer with a const_cast.
pavolmarko@1
   672
	// VC6 has problems if we just overload 'bindmemfunc', so we give it a different name.
pavolmarko@1
   673
	template < class X, class XMemFunc>
pavolmarko@1
   674
	inline void bindconstmemfunc(const X *pthis, XMemFunc function_to_bind) {
pavolmarko@1
   675
		m_pthis= SimplifyMemFunc< sizeof(function_to_bind) >
pavolmarko@1
   676
			::Convert(const_cast<X*>(pthis), function_to_bind, m_pFunction);
pavolmarko@1
   677
#if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
pavolmarko@1
   678
		m_pStaticFunction = 0;
pavolmarko@1
   679
#endif
pavolmarko@1
   680
	}
pavolmarko@1
   681
#ifdef FASTDELEGATE_GCC_BUG_8271	// At present, GCC doesn't recognize constness of MFPs in templates
pavolmarko@1
   682
	template < class X, class XMemFunc>
pavolmarko@1
   683
	inline void bindmemfunc(const X *pthis, XMemFunc function_to_bind) {
pavolmarko@1
   684
		bindconstmemfunc(pthis, function_to_bind);
pavolmarko@1
   685
#if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
pavolmarko@1
   686
		m_pStaticFunction = 0;
pavolmarko@1
   687
#endif
pavolmarko@1
   688
	}
pavolmarko@1
   689
#endif
pavolmarko@1
   690
	// These functions are required for invoking the stored function
pavolmarko@1
   691
	inline GenericClass *GetClosureThis() const { return m_pthis; }
pavolmarko@1
   692
	inline GenericMemFunc GetClosureMemPtr() const { return reinterpret_cast<GenericMemFunc>(m_pFunction); }
pavolmarko@1
   693
pavolmarko@1
   694
// There are a few ways of dealing with static function pointers.
pavolmarko@1
   695
// There's a standard-compliant, but tricky method.
pavolmarko@1
   696
// There's also a straightforward hack, that won't work on DOS compilers using the
pavolmarko@1
   697
// medium memory model. It's so evil that I can't recommend it, but I've
pavolmarko@1
   698
// implemented it anyway because it produces very nice asm code.
pavolmarko@1
   699
pavolmarko@1
   700
#if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
pavolmarko@1
   701
pavolmarko@1
   702
//				ClosurePtr<> - Safe version
pavolmarko@1
   703
//
pavolmarko@1
   704
// This implementation is standard-compliant, but a bit tricky.
pavolmarko@1
   705
// I store the function pointer inside the class, and the delegate then
pavolmarko@1
   706
// points to itself. Whenever the delegate is copied, these self-references
pavolmarko@1
   707
// must be transformed, and this complicates the = and == operators.
pavolmarko@1
   708
public:
pavolmarko@1
   709
	// The next two functions are for operator ==, =, and the copy constructor.
pavolmarko@1
   710
	// We may need to convert the m_pthis pointers, so that
pavolmarko@1
   711
	// they remain as self-references.
pavolmarko@1
   712
	template< class DerivedClass >
pavolmarko@1
   713
	inline void CopyFrom (DerivedClass *pParent, const DelegateMemento &x) {
pavolmarko@1
   714
		SetMementoFrom(x);
pavolmarko@1
   715
		if (m_pStaticFunction!=0) {
pavolmarko@1
   716
			// transform self references...
pavolmarko@1
   717
			m_pthis=reinterpret_cast<GenericClass *>(pParent);
pavolmarko@1
   718
		}
pavolmarko@1
   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@1
   722
	// the actual function to invoke.
pavolmarko@1
   723
	template < class DerivedClass, class ParentInvokerSig >
pavolmarko@123
   724
	inline void bindstaticfunc(DerivedClass *pParent, ParentInvokerSig static_function_invoker,
pavolmarko@1
   725
				StaticFuncPtr function_to_bind ) {
pavolmarko@1
   726
		bindmemfunc(pParent, static_function_invoker);
pavolmarko@1
   727
		m_pStaticFunction=reinterpret_cast<GenericFuncPtr>(function_to_bind);
pavolmarko@1
   728
	}
pavolmarko@123
   729
	inline UnvoidStaticFuncPtr GetStaticFunction() const {
pavolmarko@123
   730
		return reinterpret_cast<UnvoidStaticFuncPtr>(m_pStaticFunction);
pavolmarko@1
   731
	}
pavolmarko@1
   732
#else
pavolmarko@1
   733
pavolmarko@1
   734
//				ClosurePtr<> - Evil version
pavolmarko@1
   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@1
   738
// horrible_cast. Invocation isn't any faster, but it saves 4 bytes, and
pavolmarko@1
   739
// speeds up comparison and assignment. If C++ provided direct language support
pavolmarko@1
   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@1
   742
// support static_cast between void * and function pointers.
pavolmarko@1
   743
pavolmarko@1
   744
	template< class DerivedClass >
pavolmarko@1
   745
	inline void CopyFrom (DerivedClass *pParent, const DelegateMemento &right) {
pavolmarko@1
   746
		SetMementoFrom(right);
pavolmarko@1
   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@1
   750
	// the actual function to invoke.
pavolmarko@1
   751
	// ******** EVIL, EVIL CODE! *******
pavolmarko@1
   752
	template < 	class DerivedClass, class ParentInvokerSig>
pavolmarko@123
   753
	inline void bindstaticfunc(DerivedClass *pParent, ParentInvokerSig static_function_invoker,
pavolmarko@1
   754
				StaticFuncPtr function_to_bind) {
pavolmarko@1
   755
		// We'll be ignoring the 'this' pointer, but we need to make sure we pass
pavolmarko@1
   756
		// a valid value to bindmemfunc().
pavolmarko@1
   757
		bindmemfunc(pParent, static_function_invoker);
pavolmarko@1
   758
pavolmarko@1
   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@1
   761
		// and data pointers have different sizes.
pavolmarko@1
   762
		// If you get this error, you need to #undef FASTDELEGATE_USESTATICFUNCTIONHACK.
pavolmarko@1
   763
		typedef int ERROR_CantUseEvilMethod[sizeof(GenericClass *)==sizeof(function_to_bind) ? 1 : -1];
pavolmarko@1
   764
		m_pthis = horrible_cast<GenericClass *>(function_to_bind);
pavolmarko@1
   765
		// MSVC, SunC++ and DMC accept the following (non-standard) code:
pavolmarko@1
   766
//		m_pthis = static_cast<GenericClass *>(static_cast<void *>(function_to_bind));
pavolmarko@1
   767
		// BCC32, Comeau and DMC accept this method. MSVC7.1 needs __int64 instead of long
pavolmarko@1
   768
//		m_pthis = reinterpret_cast<GenericClass *>(reinterpret_cast<long>(function_to_bind));
pavolmarko@1
   769
	}
pavolmarko@1
   770
	// ******** EVIL, EVIL CODE! *******
pavolmarko@1
   771
	// This function will be called with an invalid 'this' pointer!!
pavolmarko@1
   772
	// We're just returning the 'this' pointer, converted into
pavolmarko@1
   773
	// a function pointer!
pavolmarko@1
   774
	inline UnvoidStaticFuncPtr GetStaticFunction() const {
pavolmarko@123
   775
		// Ensure that there's a compilation failure if function pointers
pavolmarko@1
   776
		// and data pointers have different sizes.
pavolmarko@1
   777
		// If you get this error, you need to #undef FASTDELEGATE_USESTATICFUNCTIONHACK.
pavolmarko@1
   778
		typedef int ERROR_CantUseEvilMethod[sizeof(UnvoidStaticFuncPtr)==sizeof(this) ? 1 : -1];
pavolmarko@1
   779
		return horrible_cast<UnvoidStaticFuncPtr>(this);
pavolmarko@1
   780
	}
pavolmarko@1
   781
#endif // !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
pavolmarko@1
   782
pavolmarko@1
   783
};
pavolmarko@1
   784
pavolmarko@1
   785
pavolmarko@1
   786
} // namespace detail
pavolmarko@1
   787
pavolmarko@1
   788
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   789
//						Fast Delegates, part 3:
pavolmarko@1
   790
//
pavolmarko@1
   791
//				Wrapper classes to ensure type safety
pavolmarko@1
   792
//
pavolmarko@1
   793
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
   794
pavolmarko@1
   795
pavolmarko@1
   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@1
   798
// the classes are of the form
pavolmarko@1
   799
//   FastDelegate3<int, char *, double>
pavolmarko@1
   800
// They can cope with any combination of parameters. The max number of parameters
pavolmarko@1
   801
// allowed is 8, but it is trivial to increase this limit.
pavolmarko@1
   802
// Note that we need to treat const member functions seperately.
pavolmarko@1
   803
// All this class does is to enforce type safety, and invoke the delegate with
pavolmarko@1
   804
// the correct list of parameters.
pavolmarko@1
   805
pavolmarko@1
   806
// Because of the weird rule about the class of derived member function pointers,
pavolmarko@1
   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@1
   809
// If CDerivedClass is derived from CBaseClass, but doesn't override SimpleVirtualFunction,
pavolmarko@1
   810
// without this trick you'd need to write:
pavolmarko@1
   811
//		MyDelegate(static_cast<CBaseClass *>(&d), &CDerivedClass::SimpleVirtualFunction);
pavolmarko@1
   812
// but with the trick you can write
pavolmarko@1
   813
//		MyDelegate(&d, &CDerivedClass::SimpleVirtualFunction);
pavolmarko@1
   814
pavolmarko@1
   815
// RetType is the type the compiler uses in compiling the template. For VC6,
pavolmarko@1
   816
// it cannot be void. DesiredRetType is the real type which is returned from
pavolmarko@1
   817
// all of the functions. It can be void.
pavolmarko@1
   818
pavolmarko@1
   819
//N=0
pavolmarko@1
   820
template<class RetType=detail::DefaultVoid>
pavolmarko@1
   821
class FastDelegate0 {
pavolmarko@1
   822
private:
pavolmarko@1
   823
	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
pavolmarko@1
   824
	typedef DesiredRetType (*StaticFunctionPtr)();
pavolmarko@1
   825
	typedef RetType (*UnvoidStaticFunctionPtr)();
pavolmarko@1
   826
	typedef RetType (detail::GenericClass::*GenericMemFn)();
pavolmarko@1
   827
	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
pavolmarko@1
   828
public:
pavolmarko@1
   829
	// Typedefs to aid generic programming
pavolmarko@1
   830
	typedef FastDelegate0 type;
pavolmarko@1
   831
pavolmarko@1
   832
	// Construction and comparison functions
pavolmarko@1
   833
	FastDelegate0() { clear(); }
pavolmarko@1
   834
	FastDelegate0(const FastDelegate0 &x) {
pavolmarko@1
   835
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
   836
	void operator = (const FastDelegate0 &x)  {
pavolmarko@1
   837
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
   838
	bool operator ==(const FastDelegate0 &x) const {
pavolmarko@1
   839
		return m_Closure.IsEqual(x.m_Closure);	}
pavolmarko@1
   840
	bool operator !=(const FastDelegate0 &x) const {
pavolmarko@1
   841
		return !m_Closure.IsEqual(x.m_Closure); }
pavolmarko@1
   842
	bool operator <(const FastDelegate0 &x) const {
pavolmarko@1
   843
		return m_Closure.IsLess(x.m_Closure);	}
pavolmarko@1
   844
	bool operator >(const FastDelegate0 &x) const {
pavolmarko@1
   845
		return x.m_Closure.IsLess(m_Closure);	}
pavolmarko@1
   846
	// Binding to non-const member functions
pavolmarko@1
   847
	template < class X, class Y >
pavolmarko@1
   848
	FastDelegate0(Y *pthis, DesiredRetType (X::* function_to_bind)() ) {
pavolmarko@1
   849
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
pavolmarko@1
   850
	template < class X, class Y >
pavolmarko@1
   851
	inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)()) {
pavolmarko@1
   852
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
pavolmarko@1
   853
	// Binding to const member functions.
pavolmarko@1
   854
	template < class X, class Y >
pavolmarko@1
   855
	FastDelegate0(const Y *pthis, DesiredRetType (X::* function_to_bind)() const) {
pavolmarko@1
   856
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
pavolmarko@1
   857
	template < class X, class Y >
pavolmarko@1
   858
	inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)() const) {
pavolmarko@1
   859
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
pavolmarko@1
   860
	// Static functions. We convert them into a member function call.
pavolmarko@1
   861
	// Note that this also provides a conversion from static functions.
pavolmarko@1
   862
	FastDelegate0(DesiredRetType (*function_to_bind)() ) {
pavolmarko@1
   863
		bind(function_to_bind);	}
pavolmarko@1
   864
	inline void bind(DesiredRetType (*function_to_bind)()) {
pavolmarko@123
   865
		m_Closure.bindstaticfunc(this, &FastDelegate0::InvokeStaticFunction,
pavolmarko@1
   866
			function_to_bind); }
pavolmarko@1
   867
	RetType operator() () const { // Invoke the delegate
pavolmarko@1
   868
		// this next line is the only one that violates the standard
pavolmarko@1
   869
	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(); }
pavolmarko@1
   870
	inline bool operator ! () const	{	// Is it bound to anything?
pavolmarko@1
   871
			return !m_Closure; }
pavolmarko@1
   872
	inline bool empty() const	{
pavolmarko@1
   873
			return !m_Closure; }
pavolmarko@1
   874
	void clear() { m_Closure.clear();}
pavolmarko@1
   875
	// Conversion to and from the DelegateMemento storage class
pavolmarko@1
   876
	const DelegateMemento & GetMemento() { return m_Closure; }
pavolmarko@1
   877
	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
pavolmarko@1
   878
pavolmarko@1
   879
private:	// Invoker for static functions
pavolmarko@1
   880
	RetType InvokeStaticFunction() const {
pavolmarko@1
   881
	return (*(m_Closure.GetStaticFunction()))(); }
pavolmarko@1
   882
};
pavolmarko@1
   883
pavolmarko@1
   884
//N=1
pavolmarko@1
   885
template<class Param1, class RetType=detail::DefaultVoid>
pavolmarko@1
   886
class FastDelegate1 {
pavolmarko@1
   887
private:
pavolmarko@1
   888
	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
pavolmarko@1
   889
	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1);
pavolmarko@1
   890
	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1);
pavolmarko@1
   891
	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1);
pavolmarko@1
   892
	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
pavolmarko@1
   893
public:
pavolmarko@1
   894
	// Typedefs to aid generic programming
pavolmarko@1
   895
	typedef FastDelegate1 type;
pavolmarko@1
   896
pavolmarko@1
   897
	// Construction and comparison functions
pavolmarko@1
   898
	FastDelegate1() { clear(); }
pavolmarko@1
   899
	FastDelegate1(const FastDelegate1 &x) {
pavolmarko@1
   900
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
   901
	void operator = (const FastDelegate1 &x)  {
pavolmarko@1
   902
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
   903
	bool operator ==(const FastDelegate1 &x) const {
pavolmarko@1
   904
		return m_Closure.IsEqual(x.m_Closure);	}
pavolmarko@1
   905
	bool operator !=(const FastDelegate1 &x) const {
pavolmarko@1
   906
		return !m_Closure.IsEqual(x.m_Closure); }
pavolmarko@1
   907
	bool operator <(const FastDelegate1 &x) const {
pavolmarko@1
   908
		return m_Closure.IsLess(x.m_Closure);	}
pavolmarko@1
   909
	bool operator >(const FastDelegate1 &x) const {
pavolmarko@1
   910
		return x.m_Closure.IsLess(m_Closure);	}
pavolmarko@1
   911
	// Binding to non-const member functions
pavolmarko@1
   912
	template < class X, class Y >
pavolmarko@1
   913
	FastDelegate1(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1) ) {
pavolmarko@1
   914
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
pavolmarko@1
   915
	template < class X, class Y >
pavolmarko@1
   916
	inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1)) {
pavolmarko@1
   917
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
pavolmarko@1
   918
	// Binding to const member functions.
pavolmarko@1
   919
	template < class X, class Y >
pavolmarko@1
   920
	FastDelegate1(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1) const) {
pavolmarko@1
   921
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
pavolmarko@1
   922
	template < class X, class Y >
pavolmarko@1
   923
	inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1) const) {
pavolmarko@1
   924
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
pavolmarko@1
   925
	// Static functions. We convert them into a member function call.
pavolmarko@1
   926
	// Note that this also provides a conversion from static functions.
pavolmarko@1
   927
	FastDelegate1(DesiredRetType (*function_to_bind)(Param1 p1) ) {
pavolmarko@1
   928
		bind(function_to_bind);	}
pavolmarko@1
   929
	inline void bind(DesiredRetType (*function_to_bind)(Param1 p1)) {
pavolmarko@123
   930
		m_Closure.bindstaticfunc(this, &FastDelegate1::InvokeStaticFunction,
pavolmarko@1
   931
			function_to_bind); }
pavolmarko@1
   932
	RetType operator() (Param1 p1) const { // Invoke the delegate
pavolmarko@1
   933
		// this next line is the only one that violates the standard
pavolmarko@1
   934
	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1); }
pavolmarko@1
   935
	inline bool operator ! () const	{	// Is it bound to anything?
pavolmarko@1
   936
			return !m_Closure; }
pavolmarko@1
   937
	inline bool empty() const	{
pavolmarko@1
   938
			return !m_Closure; }
pavolmarko@1
   939
	void clear() { m_Closure.clear();}
pavolmarko@1
   940
	// Conversion to and from the DelegateMemento storage class
pavolmarko@1
   941
	const DelegateMemento & GetMemento() { return m_Closure; }
pavolmarko@1
   942
	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
pavolmarko@1
   943
pavolmarko@1
   944
private:	// Invoker for static functions
pavolmarko@1
   945
	RetType InvokeStaticFunction(Param1 p1) const {
pavolmarko@1
   946
	return (*(m_Closure.GetStaticFunction()))(p1); }
pavolmarko@1
   947
};
pavolmarko@1
   948
pavolmarko@1
   949
//N=2
pavolmarko@1
   950
template<class Param1, class Param2, class RetType=detail::DefaultVoid>
pavolmarko@1
   951
class FastDelegate2 {
pavolmarko@1
   952
private:
pavolmarko@1
   953
	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
pavolmarko@1
   954
	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2);
pavolmarko@1
   955
	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2);
pavolmarko@1
   956
	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2);
pavolmarko@1
   957
	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
pavolmarko@1
   958
public:
pavolmarko@1
   959
	// Typedefs to aid generic programming
pavolmarko@1
   960
	typedef FastDelegate2 type;
pavolmarko@1
   961
pavolmarko@1
   962
	// Construction and comparison functions
pavolmarko@1
   963
	FastDelegate2() { clear(); }
pavolmarko@1
   964
	FastDelegate2(const FastDelegate2 &x) {
pavolmarko@1
   965
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
   966
	void operator = (const FastDelegate2 &x)  {
pavolmarko@1
   967
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
   968
	bool operator ==(const FastDelegate2 &x) const {
pavolmarko@1
   969
		return m_Closure.IsEqual(x.m_Closure);	}
pavolmarko@1
   970
	bool operator !=(const FastDelegate2 &x) const {
pavolmarko@1
   971
		return !m_Closure.IsEqual(x.m_Closure); }
pavolmarko@1
   972
	bool operator <(const FastDelegate2 &x) const {
pavolmarko@1
   973
		return m_Closure.IsLess(x.m_Closure);	}
pavolmarko@1
   974
	bool operator >(const FastDelegate2 &x) const {
pavolmarko@1
   975
		return x.m_Closure.IsLess(m_Closure);	}
pavolmarko@1
   976
	// Binding to non-const member functions
pavolmarko@1
   977
	template < class X, class Y >
pavolmarko@1
   978
	FastDelegate2(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2) ) {
pavolmarko@1
   979
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
pavolmarko@1
   980
	template < class X, class Y >
pavolmarko@1
   981
	inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2)) {
pavolmarko@1
   982
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
pavolmarko@1
   983
	// Binding to const member functions.
pavolmarko@1
   984
	template < class X, class Y >
pavolmarko@1
   985
	FastDelegate2(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2) const) {
pavolmarko@1
   986
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
pavolmarko@1
   987
	template < class X, class Y >
pavolmarko@1
   988
	inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2) const) {
pavolmarko@1
   989
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
pavolmarko@1
   990
	// Static functions. We convert them into a member function call.
pavolmarko@1
   991
	// Note that this also provides a conversion from static functions.
pavolmarko@1
   992
	FastDelegate2(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2) ) {
pavolmarko@1
   993
		bind(function_to_bind);	}
pavolmarko@1
   994
	inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2)) {
pavolmarko@123
   995
		m_Closure.bindstaticfunc(this, &FastDelegate2::InvokeStaticFunction,
pavolmarko@1
   996
			function_to_bind); }
pavolmarko@1
   997
	RetType operator() (Param1 p1, Param2 p2) const { // Invoke the delegate
pavolmarko@1
   998
		// this next line is the only one that violates the standard
pavolmarko@1
   999
	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2); }
pavolmarko@1
  1000
	inline bool operator ! () const	{	// Is it bound to anything?
pavolmarko@1
  1001
			return !m_Closure; }
pavolmarko@1
  1002
	inline bool empty() const	{
pavolmarko@1
  1003
			return !m_Closure; }
pavolmarko@1
  1004
	void clear() { m_Closure.clear();}
pavolmarko@1
  1005
	// Conversion to and from the DelegateMemento storage class
pavolmarko@1
  1006
	const DelegateMemento & GetMemento() { return m_Closure; }
pavolmarko@1
  1007
	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
pavolmarko@1
  1008
pavolmarko@1
  1009
private:	// Invoker for static functions
pavolmarko@1
  1010
	RetType InvokeStaticFunction(Param1 p1, Param2 p2) const {
pavolmarko@1
  1011
	return (*(m_Closure.GetStaticFunction()))(p1, p2); }
pavolmarko@1
  1012
};
pavolmarko@1
  1013
pavolmarko@1
  1014
//N=3
pavolmarko@1
  1015
template<class Param1, class Param2, class Param3, class RetType=detail::DefaultVoid>
pavolmarko@1
  1016
class FastDelegate3 {
pavolmarko@1
  1017
private:
pavolmarko@1
  1018
	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
pavolmarko@1
  1019
	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3);
pavolmarko@1
  1020
	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3);
pavolmarko@1
  1021
	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3);
pavolmarko@1
  1022
	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
pavolmarko@1
  1023
public:
pavolmarko@1
  1024
	// Typedefs to aid generic programming
pavolmarko@1
  1025
	typedef FastDelegate3 type;
pavolmarko@1
  1026
pavolmarko@1
  1027
	// Construction and comparison functions
pavolmarko@1
  1028
	FastDelegate3() { clear(); }
pavolmarko@1
  1029
	FastDelegate3(const FastDelegate3 &x) {
pavolmarko@1
  1030
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1031
	void operator = (const FastDelegate3 &x)  {
pavolmarko@1
  1032
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1033
	bool operator ==(const FastDelegate3 &x) const {
pavolmarko@1
  1034
		return m_Closure.IsEqual(x.m_Closure);	}
pavolmarko@1
  1035
	bool operator !=(const FastDelegate3 &x) const {
pavolmarko@1
  1036
		return !m_Closure.IsEqual(x.m_Closure); }
pavolmarko@1
  1037
	bool operator <(const FastDelegate3 &x) const {
pavolmarko@1
  1038
		return m_Closure.IsLess(x.m_Closure);	}
pavolmarko@1
  1039
	bool operator >(const FastDelegate3 &x) const {
pavolmarko@1
  1040
		return x.m_Closure.IsLess(m_Closure);	}
pavolmarko@1
  1041
	// Binding to non-const member functions
pavolmarko@1
  1042
	template < class X, class Y >
pavolmarko@1
  1043
	FastDelegate3(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3) ) {
pavolmarko@1
  1044
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
pavolmarko@1
  1045
	template < class X, class Y >
pavolmarko@1
  1046
	inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3)) {
pavolmarko@1
  1047
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
pavolmarko@1
  1048
	// Binding to const member functions.
pavolmarko@1
  1049
	template < class X, class Y >
pavolmarko@1
  1050
	FastDelegate3(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3) const) {
pavolmarko@1
  1051
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
pavolmarko@1
  1052
	template < class X, class Y >
pavolmarko@1
  1053
	inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3) const) {
pavolmarko@1
  1054
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
pavolmarko@1
  1055
	// Static functions. We convert them into a member function call.
pavolmarko@1
  1056
	// Note that this also provides a conversion from static functions.
pavolmarko@1
  1057
	FastDelegate3(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3) ) {
pavolmarko@1
  1058
		bind(function_to_bind);	}
pavolmarko@1
  1059
	inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3)) {
pavolmarko@123
  1060
		m_Closure.bindstaticfunc(this, &FastDelegate3::InvokeStaticFunction,
pavolmarko@1
  1061
			function_to_bind); }
pavolmarko@1
  1062
	RetType operator() (Param1 p1, Param2 p2, Param3 p3) const { // Invoke the delegate
pavolmarko@1
  1063
		// this next line is the only one that violates the standard
pavolmarko@1
  1064
	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3); }
pavolmarko@1
  1065
	inline bool operator ! () const	{	// Is it bound to anything?
pavolmarko@1
  1066
			return !m_Closure; }
pavolmarko@1
  1067
	inline bool empty() const	{
pavolmarko@1
  1068
			return !m_Closure; }
pavolmarko@1
  1069
	void clear() { m_Closure.clear();}
pavolmarko@1
  1070
	// Conversion to and from the DelegateMemento storage class
pavolmarko@1
  1071
	const DelegateMemento & GetMemento() { return m_Closure; }
pavolmarko@1
  1072
	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
pavolmarko@1
  1073
pavolmarko@1
  1074
private:	// Invoker for static functions
pavolmarko@1
  1075
	RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3) const {
pavolmarko@1
  1076
	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3); }
pavolmarko@1
  1077
};
pavolmarko@1
  1078
pavolmarko@1
  1079
//N=4
pavolmarko@1
  1080
template<class Param1, class Param2, class Param3, class Param4, class RetType=detail::DefaultVoid>
pavolmarko@1
  1081
class FastDelegate4 {
pavolmarko@1
  1082
private:
pavolmarko@1
  1083
	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
pavolmarko@1
  1084
	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4);
pavolmarko@1
  1085
	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4);
pavolmarko@1
  1086
	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4);
pavolmarko@1
  1087
	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
pavolmarko@1
  1088
public:
pavolmarko@1
  1089
	// Typedefs to aid generic programming
pavolmarko@1
  1090
	typedef FastDelegate4 type;
pavolmarko@1
  1091
pavolmarko@1
  1092
	// Construction and comparison functions
pavolmarko@1
  1093
	FastDelegate4() { clear(); }
pavolmarko@1
  1094
	FastDelegate4(const FastDelegate4 &x) {
pavolmarko@1
  1095
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1096
	void operator = (const FastDelegate4 &x)  {
pavolmarko@1
  1097
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1098
	bool operator ==(const FastDelegate4 &x) const {
pavolmarko@1
  1099
		return m_Closure.IsEqual(x.m_Closure);	}
pavolmarko@1
  1100
	bool operator !=(const FastDelegate4 &x) const {
pavolmarko@1
  1101
		return !m_Closure.IsEqual(x.m_Closure); }
pavolmarko@1
  1102
	bool operator <(const FastDelegate4 &x) const {
pavolmarko@1
  1103
		return m_Closure.IsLess(x.m_Closure);	}
pavolmarko@1
  1104
	bool operator >(const FastDelegate4 &x) const {
pavolmarko@1
  1105
		return x.m_Closure.IsLess(m_Closure);	}
pavolmarko@1
  1106
	// Binding to non-const member functions
pavolmarko@1
  1107
	template < class X, class Y >
pavolmarko@1
  1108
	FastDelegate4(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4) ) {
pavolmarko@1
  1109
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
pavolmarko@1
  1110
	template < class X, class Y >
pavolmarko@1
  1111
	inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4)) {
pavolmarko@1
  1112
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
pavolmarko@1
  1113
	// Binding to const member functions.
pavolmarko@1
  1114
	template < class X, class Y >
pavolmarko@1
  1115
	FastDelegate4(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const) {
pavolmarko@1
  1116
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
pavolmarko@1
  1117
	template < class X, class Y >
pavolmarko@1
  1118
	inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const) {
pavolmarko@1
  1119
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
pavolmarko@1
  1120
	// Static functions. We convert them into a member function call.
pavolmarko@1
  1121
	// Note that this also provides a conversion from static functions.
pavolmarko@1
  1122
	FastDelegate4(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4) ) {
pavolmarko@1
  1123
		bind(function_to_bind);	}
pavolmarko@1
  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@1
  1126
			function_to_bind); }
pavolmarko@1
  1127
	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4) const { // Invoke the delegate
pavolmarko@1
  1128
		// this next line is the only one that violates the standard
pavolmarko@1
  1129
	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4); }
pavolmarko@1
  1130
	inline bool operator ! () const	{	// Is it bound to anything?
pavolmarko@1
  1131
			return !m_Closure; }
pavolmarko@1
  1132
	inline bool empty() const	{
pavolmarko@1
  1133
			return !m_Closure; }
pavolmarko@1
  1134
	void clear() { m_Closure.clear();}
pavolmarko@1
  1135
	// Conversion to and from the DelegateMemento storage class
pavolmarko@1
  1136
	const DelegateMemento & GetMemento() { return m_Closure; }
pavolmarko@1
  1137
	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
pavolmarko@1
  1138
pavolmarko@1
  1139
private:	// Invoker for static functions
pavolmarko@1
  1140
	RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const {
pavolmarko@1
  1141
	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4); }
pavolmarko@1
  1142
};
pavolmarko@1
  1143
pavolmarko@1
  1144
//N=5
pavolmarko@1
  1145
template<class Param1, class Param2, class Param3, class Param4, class Param5, class RetType=detail::DefaultVoid>
pavolmarko@1
  1146
class FastDelegate5 {
pavolmarko@1
  1147
private:
pavolmarko@1
  1148
	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
pavolmarko@1
  1149
	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5);
pavolmarko@1
  1150
	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5);
pavolmarko@1
  1151
	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5);
pavolmarko@1
  1152
	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
pavolmarko@1
  1153
public:
pavolmarko@1
  1154
	// Typedefs to aid generic programming
pavolmarko@1
  1155
	typedef FastDelegate5 type;
pavolmarko@1
  1156
pavolmarko@1
  1157
	// Construction and comparison functions
pavolmarko@1
  1158
	FastDelegate5() { clear(); }
pavolmarko@1
  1159
	FastDelegate5(const FastDelegate5 &x) {
pavolmarko@1
  1160
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1161
	void operator = (const FastDelegate5 &x)  {
pavolmarko@1
  1162
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1163
	bool operator ==(const FastDelegate5 &x) const {
pavolmarko@1
  1164
		return m_Closure.IsEqual(x.m_Closure);	}
pavolmarko@1
  1165
	bool operator !=(const FastDelegate5 &x) const {
pavolmarko@1
  1166
		return !m_Closure.IsEqual(x.m_Closure); }
pavolmarko@1
  1167
	bool operator <(const FastDelegate5 &x) const {
pavolmarko@1
  1168
		return m_Closure.IsLess(x.m_Closure);	}
pavolmarko@1
  1169
	bool operator >(const FastDelegate5 &x) const {
pavolmarko@1
  1170
		return x.m_Closure.IsLess(m_Closure);	}
pavolmarko@1
  1171
	// Binding to non-const member functions
pavolmarko@1
  1172
	template < class X, class Y >
pavolmarko@1
  1173
	FastDelegate5(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) ) {
pavolmarko@1
  1174
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
pavolmarko@1
  1175
	template < class X, class Y >
pavolmarko@1
  1176
	inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5)) {
pavolmarko@1
  1177
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
pavolmarko@1
  1178
	// Binding to const member functions.
pavolmarko@1
  1179
	template < class X, class Y >
pavolmarko@1
  1180
	FastDelegate5(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const) {
pavolmarko@1
  1181
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
pavolmarko@1
  1182
	template < class X, class Y >
pavolmarko@1
  1183
	inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const) {
pavolmarko@1
  1184
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
pavolmarko@1
  1185
	// Static functions. We convert them into a member function call.
pavolmarko@1
  1186
	// Note that this also provides a conversion from static functions.
pavolmarko@1
  1187
	FastDelegate5(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) ) {
pavolmarko@1
  1188
		bind(function_to_bind);	}
pavolmarko@1
  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@1
  1191
			function_to_bind); }
pavolmarko@1
  1192
	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const { // Invoke the delegate
pavolmarko@1
  1193
		// this next line is the only one that violates the standard
pavolmarko@1
  1194
	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5); }
pavolmarko@1
  1195
	inline bool operator ! () const	{	// Is it bound to anything?
pavolmarko@1
  1196
			return !m_Closure; }
pavolmarko@1
  1197
	inline bool empty() const	{
pavolmarko@1
  1198
			return !m_Closure; }
pavolmarko@1
  1199
	void clear() { m_Closure.clear();}
pavolmarko@1
  1200
	// Conversion to and from the DelegateMemento storage class
pavolmarko@1
  1201
	const DelegateMemento & GetMemento() { return m_Closure; }
pavolmarko@1
  1202
	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
pavolmarko@1
  1203
pavolmarko@1
  1204
private:	// Invoker for static functions
pavolmarko@1
  1205
	RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const {
pavolmarko@1
  1206
	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5); }
pavolmarko@1
  1207
};
pavolmarko@1
  1208
pavolmarko@1
  1209
//N=6
pavolmarko@1
  1210
template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class RetType=detail::DefaultVoid>
pavolmarko@1
  1211
class FastDelegate6 {
pavolmarko@1
  1212
private:
pavolmarko@1
  1213
	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
pavolmarko@1
  1214
	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6);
pavolmarko@1
  1215
	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6);
pavolmarko@1
  1216
	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6);
pavolmarko@1
  1217
	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
pavolmarko@1
  1218
public:
pavolmarko@1
  1219
	// Typedefs to aid generic programming
pavolmarko@1
  1220
	typedef FastDelegate6 type;
pavolmarko@1
  1221
pavolmarko@1
  1222
	// Construction and comparison functions
pavolmarko@1
  1223
	FastDelegate6() { clear(); }
pavolmarko@1
  1224
	FastDelegate6(const FastDelegate6 &x) {
pavolmarko@1
  1225
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1226
	void operator = (const FastDelegate6 &x)  {
pavolmarko@1
  1227
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1228
	bool operator ==(const FastDelegate6 &x) const {
pavolmarko@1
  1229
		return m_Closure.IsEqual(x.m_Closure);	}
pavolmarko@1
  1230
	bool operator !=(const FastDelegate6 &x) const {
pavolmarko@1
  1231
		return !m_Closure.IsEqual(x.m_Closure); }
pavolmarko@1
  1232
	bool operator <(const FastDelegate6 &x) const {
pavolmarko@1
  1233
		return m_Closure.IsLess(x.m_Closure);	}
pavolmarko@1
  1234
	bool operator >(const FastDelegate6 &x) const {
pavolmarko@1
  1235
		return x.m_Closure.IsLess(m_Closure);	}
pavolmarko@1
  1236
	// Binding to non-const member functions
pavolmarko@1
  1237
	template < class X, class Y >
pavolmarko@1
  1238
	FastDelegate6(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) ) {
pavolmarko@1
  1239
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
pavolmarko@1
  1240
	template < class X, class Y >
pavolmarko@1
  1241
	inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6)) {
pavolmarko@1
  1242
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
pavolmarko@1
  1243
	// Binding to const member functions.
pavolmarko@1
  1244
	template < class X, class Y >
pavolmarko@1
  1245
	FastDelegate6(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const) {
pavolmarko@1
  1246
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
pavolmarko@1
  1247
	template < class X, class Y >
pavolmarko@1
  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@1
  1249
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
pavolmarko@1
  1250
	// Static functions. We convert them into a member function call.
pavolmarko@1
  1251
	// Note that this also provides a conversion from static functions.
pavolmarko@1
  1252
	FastDelegate6(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) ) {
pavolmarko@1
  1253
		bind(function_to_bind);	}
pavolmarko@1
  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@1
  1256
			function_to_bind); }
pavolmarko@1
  1257
	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const { // Invoke the delegate
pavolmarko@1
  1258
		// this next line is the only one that violates the standard
pavolmarko@1
  1259
	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6); }
pavolmarko@1
  1260
	inline bool operator ! () const	{	// Is it bound to anything?
pavolmarko@1
  1261
			return !m_Closure; }
pavolmarko@1
  1262
	inline bool empty() const	{
pavolmarko@1
  1263
			return !m_Closure; }
pavolmarko@1
  1264
	void clear() { m_Closure.clear();}
pavolmarko@1
  1265
	// Conversion to and from the DelegateMemento storage class
pavolmarko@1
  1266
	const DelegateMemento & GetMemento() { return m_Closure; }
pavolmarko@1
  1267
	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
pavolmarko@1
  1268
pavolmarko@1
  1269
private:	// Invoker for static functions
pavolmarko@1
  1270
	RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const {
pavolmarko@1
  1271
	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6); }
pavolmarko@1
  1272
};
pavolmarko@1
  1273
pavolmarko@1
  1274
//N=7
pavolmarko@1
  1275
template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class RetType=detail::DefaultVoid>
pavolmarko@1
  1276
class FastDelegate7 {
pavolmarko@1
  1277
private:
pavolmarko@1
  1278
	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
pavolmarko@1
  1279
	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7);
pavolmarko@1
  1280
	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7);
pavolmarko@1
  1281
	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7);
pavolmarko@1
  1282
	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
pavolmarko@1
  1283
public:
pavolmarko@1
  1284
	// Typedefs to aid generic programming
pavolmarko@1
  1285
	typedef FastDelegate7 type;
pavolmarko@1
  1286
pavolmarko@1
  1287
	// Construction and comparison functions
pavolmarko@1
  1288
	FastDelegate7() { clear(); }
pavolmarko@1
  1289
	FastDelegate7(const FastDelegate7 &x) {
pavolmarko@1
  1290
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1291
	void operator = (const FastDelegate7 &x)  {
pavolmarko@1
  1292
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1293
	bool operator ==(const FastDelegate7 &x) const {
pavolmarko@1
  1294
		return m_Closure.IsEqual(x.m_Closure);	}
pavolmarko@1
  1295
	bool operator !=(const FastDelegate7 &x) const {
pavolmarko@1
  1296
		return !m_Closure.IsEqual(x.m_Closure); }
pavolmarko@1
  1297
	bool operator <(const FastDelegate7 &x) const {
pavolmarko@1
  1298
		return m_Closure.IsLess(x.m_Closure);	}
pavolmarko@1
  1299
	bool operator >(const FastDelegate7 &x) const {
pavolmarko@1
  1300
		return x.m_Closure.IsLess(m_Closure);	}
pavolmarko@1
  1301
	// Binding to non-const member functions
pavolmarko@1
  1302
	template < class X, class Y >
pavolmarko@1
  1303
	FastDelegate7(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) ) {
pavolmarko@1
  1304
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
pavolmarko@1
  1305
	template < class X, class Y >
pavolmarko@1
  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@1
  1307
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
pavolmarko@1
  1308
	// Binding to const member functions.
pavolmarko@1
  1309
	template < class X, class Y >
pavolmarko@1
  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@1
  1311
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
pavolmarko@1
  1312
	template < class X, class Y >
pavolmarko@1
  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@1
  1314
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
pavolmarko@1
  1315
	// Static functions. We convert them into a member function call.
pavolmarko@1
  1316
	// Note that this also provides a conversion from static functions.
pavolmarko@1
  1317
	FastDelegate7(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) ) {
pavolmarko@1
  1318
		bind(function_to_bind);	}
pavolmarko@1
  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@1
  1321
			function_to_bind); }
pavolmarko@1
  1322
	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const { // Invoke the delegate
pavolmarko@1
  1323
		// this next line is the only one that violates the standard
pavolmarko@1
  1324
	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7); }
pavolmarko@1
  1325
	inline bool operator ! () const	{	// Is it bound to anything?
pavolmarko@1
  1326
			return !m_Closure; }
pavolmarko@1
  1327
	inline bool empty() const	{
pavolmarko@1
  1328
			return !m_Closure; }
pavolmarko@1
  1329
	void clear() { m_Closure.clear();}
pavolmarko@1
  1330
	// Conversion to and from the DelegateMemento storage class
pavolmarko@1
  1331
	const DelegateMemento & GetMemento() { return m_Closure; }
pavolmarko@1
  1332
	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
pavolmarko@1
  1333
pavolmarko@1
  1334
private:	// Invoker for static functions
pavolmarko@1
  1335
	RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const {
pavolmarko@1
  1336
	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7); }
pavolmarko@1
  1337
};
pavolmarko@1
  1338
pavolmarko@1
  1339
//N=8
pavolmarko@1
  1340
template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class RetType=detail::DefaultVoid>
pavolmarko@1
  1341
class FastDelegate8 {
pavolmarko@1
  1342
private:
pavolmarko@1
  1343
	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
pavolmarko@1
  1344
	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8);
pavolmarko@1
  1345
	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8);
pavolmarko@1
  1346
	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8);
pavolmarko@1
  1347
	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
pavolmarko@1
  1348
public:
pavolmarko@1
  1349
	// Typedefs to aid generic programming
pavolmarko@1
  1350
	typedef FastDelegate8 type;
pavolmarko@1
  1351
pavolmarko@1
  1352
	// Construction and comparison functions
pavolmarko@1
  1353
	FastDelegate8() { clear(); }
pavolmarko@1
  1354
	FastDelegate8(const FastDelegate8 &x) {
pavolmarko@1
  1355
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1356
	void operator = (const FastDelegate8 &x)  {
pavolmarko@1
  1357
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1358
	bool operator ==(const FastDelegate8 &x) const {
pavolmarko@1
  1359
		return m_Closure.IsEqual(x.m_Closure);	}
pavolmarko@1
  1360
	bool operator !=(const FastDelegate8 &x) const {
pavolmarko@1
  1361
		return !m_Closure.IsEqual(x.m_Closure); }
pavolmarko@1
  1362
	bool operator <(const FastDelegate8 &x) const {
pavolmarko@1
  1363
		return m_Closure.IsLess(x.m_Closure);	}
pavolmarko@1
  1364
	bool operator >(const FastDelegate8 &x) const {
pavolmarko@1
  1365
		return x.m_Closure.IsLess(m_Closure);	}
pavolmarko@1
  1366
	// Binding to non-const member functions
pavolmarko@1
  1367
	template < class X, class Y >
pavolmarko@1
  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@1
  1369
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
pavolmarko@1
  1370
	template < class X, class Y >
pavolmarko@1
  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@1
  1372
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
pavolmarko@1
  1373
	// Binding to const member functions.
pavolmarko@1
  1374
	template < class X, class Y >
pavolmarko@1
  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@1
  1376
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
pavolmarko@1
  1377
	template < class X, class Y >
pavolmarko@1
  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@1
  1379
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
pavolmarko@1
  1380
	// Static functions. We convert them into a member function call.
pavolmarko@1
  1381
	// Note that this also provides a conversion from static functions.
pavolmarko@1
  1382
	FastDelegate8(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) ) {
pavolmarko@1
  1383
		bind(function_to_bind);	}
pavolmarko@1
  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@1
  1386
			function_to_bind); }
pavolmarko@1
  1387
	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) const { // Invoke the delegate
pavolmarko@1
  1388
		// this next line is the only one that violates the standard
pavolmarko@1
  1389
	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8); }
pavolmarko@1
  1390
	inline bool operator ! () const	{	// Is it bound to anything?
pavolmarko@1
  1391
			return !m_Closure; }
pavolmarko@1
  1392
	inline bool empty() const	{
pavolmarko@1
  1393
			return !m_Closure; }
pavolmarko@1
  1394
	void clear() { m_Closure.clear();}
pavolmarko@1
  1395
	// Conversion to and from the DelegateMemento storage class
pavolmarko@1
  1396
	const DelegateMemento & GetMemento() { return m_Closure; }
pavolmarko@1
  1397
	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
pavolmarko@1
  1398
pavolmarko@1
  1399
private:	// Invoker for static functions
pavolmarko@1
  1400
	RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) const {
pavolmarko@1
  1401
	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8); }
pavolmarko@1
  1402
};
pavolmarko@1
  1403
pavolmarko@1
  1404
//N=9
pavolmarko@1
  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@1
  1406
class FastDelegate9 {
pavolmarko@1
  1407
private:
pavolmarko@1
  1408
	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
pavolmarko@1
  1409
	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9);
pavolmarko@1
  1410
	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9);
pavolmarko@1
  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@1
  1412
	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
pavolmarko@1
  1413
public:
pavolmarko@1
  1414
	// Typedefs to aid generic programming
pavolmarko@1
  1415
	typedef FastDelegate9 type;
pavolmarko@1
  1416
pavolmarko@1
  1417
	// Construction and comparison functions
pavolmarko@1
  1418
	FastDelegate9() { clear(); }
pavolmarko@1
  1419
	FastDelegate9(const FastDelegate9 &x) {
pavolmarko@1
  1420
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1421
	void operator = (const FastDelegate9 &x)  {
pavolmarko@1
  1422
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1423
	bool operator ==(const FastDelegate9 &x) const {
pavolmarko@1
  1424
		return m_Closure.IsEqual(x.m_Closure);	}
pavolmarko@1
  1425
	bool operator !=(const FastDelegate9 &x) const {
pavolmarko@1
  1426
		return !m_Closure.IsEqual(x.m_Closure); }
pavolmarko@1
  1427
	bool operator <(const FastDelegate9 &x) const {
pavolmarko@1
  1428
		return m_Closure.IsLess(x.m_Closure);	}
pavolmarko@1
  1429
	bool operator >(const FastDelegate9 &x) const {
pavolmarko@1
  1430
		return x.m_Closure.IsLess(m_Closure);	}
pavolmarko@1
  1431
	// Binding to non-const member functions
pavolmarko@1
  1432
	template < class X, class Y >
pavolmarko@1
  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@1
  1434
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
pavolmarko@1
  1435
	template < class X, class Y >
pavolmarko@1
  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@1
  1437
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
pavolmarko@1
  1438
	// Binding to const member functions.
pavolmarko@1
  1439
	template < class X, class Y >
pavolmarko@1
  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@1
  1441
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
pavolmarko@1
  1442
	template < class X, class Y >
pavolmarko@1
  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@1
  1444
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
pavolmarko@1
  1445
	// Static functions. We convert them into a member function call.
pavolmarko@1
  1446
	// Note that this also provides a conversion from static functions.
pavolmarko@1
  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@1
  1448
		bind(function_to_bind);	}
pavolmarko@1
  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@1
  1451
			function_to_bind); }
pavolmarko@1
  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@1
  1453
		// this next line is the only one that violates the standard
pavolmarko@1
  1454
	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9); }
pavolmarko@1
  1455
	inline bool operator ! () const	{	// Is it bound to anything?
pavolmarko@1
  1456
			return !m_Closure; }
pavolmarko@1
  1457
	inline bool empty() const	{
pavolmarko@1
  1458
			return !m_Closure; }
pavolmarko@1
  1459
	void clear() { m_Closure.clear();}
pavolmarko@1
  1460
	// Conversion to and from the DelegateMemento storage class
pavolmarko@1
  1461
	const DelegateMemento & GetMemento() { return m_Closure; }
pavolmarko@1
  1462
	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
pavolmarko@1
  1463
pavolmarko@1
  1464
private:	// Invoker for static functions
pavolmarko@1
  1465
	RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9) const {
pavolmarko@1
  1466
	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9); }
pavolmarko@1
  1467
};
pavolmarko@1
  1468
pavolmarko@1
  1469
//N=10
pavolmarko@1
  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@1
  1471
class FastDelegate10 {
pavolmarko@1
  1472
private:
pavolmarko@1
  1473
	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
pavolmarko@1
  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@1
  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@1
  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@1
  1477
	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
pavolmarko@1
  1478
public:
pavolmarko@1
  1479
	// Typedefs to aid generic programming
pavolmarko@1
  1480
	typedef FastDelegate10 type;
pavolmarko@1
  1481
pavolmarko@1
  1482
	// Construction and comparison functions
pavolmarko@1
  1483
	FastDelegate10() { clear(); }
pavolmarko@1
  1484
	FastDelegate10(const FastDelegate10 &x) {
pavolmarko@1
  1485
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1486
	void operator = (const FastDelegate10 &x)  {
pavolmarko@1
  1487
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1488
	bool operator ==(const FastDelegate10 &x) const {
pavolmarko@1
  1489
		return m_Closure.IsEqual(x.m_Closure);	}
pavolmarko@1
  1490
	bool operator !=(const FastDelegate10 &x) const {
pavolmarko@1
  1491
		return !m_Closure.IsEqual(x.m_Closure); }
pavolmarko@1
  1492
	bool operator <(const FastDelegate10 &x) const {
pavolmarko@1
  1493
		return m_Closure.IsLess(x.m_Closure);	}
pavolmarko@1
  1494
	bool operator >(const FastDelegate10 &x) const {
pavolmarko@1
  1495
		return x.m_Closure.IsLess(m_Closure);	}
pavolmarko@1
  1496
	// Binding to non-const member functions
pavolmarko@1
  1497
	template < class X, class Y >
pavolmarko@1
  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@1
  1499
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
pavolmarko@1
  1500
	template < class X, class Y >
pavolmarko@1
  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@1
  1502
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
pavolmarko@1
  1503
	// Binding to const member functions.
pavolmarko@1
  1504
	template < class X, class Y >
pavolmarko@1
  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@1
  1506
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
pavolmarko@1
  1507
	template < class X, class Y >
pavolmarko@1
  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@1
  1509
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
pavolmarko@1
  1510
	// Static functions. We convert them into a member function call.
pavolmarko@1
  1511
	// Note that this also provides a conversion from static functions.
pavolmarko@1
  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@1
  1513
		bind(function_to_bind);	}
pavolmarko@1
  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@1
  1516
			function_to_bind); }
pavolmarko@1
  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@1
  1518
		// this next line is the only one that violates the standard
pavolmarko@1
  1519
	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); }
pavolmarko@1
  1520
	inline bool operator ! () const	{	// Is it bound to anything?
pavolmarko@1
  1521
			return !m_Closure; }
pavolmarko@1
  1522
	inline bool empty() const	{
pavolmarko@1
  1523
			return !m_Closure; }
pavolmarko@1
  1524
	void clear() { m_Closure.clear();}
pavolmarko@1
  1525
	// Conversion to and from the DelegateMemento storage class
pavolmarko@1
  1526
	const DelegateMemento & GetMemento() { return m_Closure; }
pavolmarko@1
  1527
	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
pavolmarko@1
  1528
pavolmarko@1
  1529
private:	// Invoker for static functions
pavolmarko@1
  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@1
  1531
	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); }
pavolmarko@1
  1532
};
pavolmarko@1
  1533
pavolmarko@1
  1534
//N=11
pavolmarko@1
  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@1
  1536
class FastDelegate11 {
pavolmarko@1
  1537
private:
pavolmarko@1
  1538
	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
pavolmarko@1
  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@1
  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@1
  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@1
  1542
	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
pavolmarko@1
  1543
public:
pavolmarko@1
  1544
	// Typedefs to aid generic programming
pavolmarko@1
  1545
	typedef FastDelegate11 type;
pavolmarko@1
  1546
pavolmarko@1
  1547
	// Construction and comparison functions
pavolmarko@1
  1548
	FastDelegate11() { clear(); }
pavolmarko@1
  1549
	FastDelegate11(const FastDelegate11 &x) {
pavolmarko@1
  1550
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1551
	void operator = (const FastDelegate11 &x)  {
pavolmarko@1
  1552
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1553
	bool operator ==(const FastDelegate11 &x) const {
pavolmarko@1
  1554
		return m_Closure.IsEqual(x.m_Closure);	}
pavolmarko@1
  1555
	bool operator !=(const FastDelegate11 &x) const {
pavolmarko@1
  1556
		return !m_Closure.IsEqual(x.m_Closure); }
pavolmarko@1
  1557
	bool operator <(const FastDelegate11 &x) const {
pavolmarko@1
  1558
		return m_Closure.IsLess(x.m_Closure);	}
pavolmarko@1
  1559
	bool operator >(const FastDelegate11 &x) const {
pavolmarko@1
  1560
		return x.m_Closure.IsLess(m_Closure);	}
pavolmarko@1
  1561
	// Binding to non-const member functions
pavolmarko@1
  1562
	template < class X, class Y >
pavolmarko@1
  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@1
  1564
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
pavolmarko@1
  1565
	template < class X, class Y >
pavolmarko@1
  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@1
  1567
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
pavolmarko@1
  1568
	// Binding to const member functions.
pavolmarko@1
  1569
	template < class X, class Y >
pavolmarko@1
  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@1
  1571
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
pavolmarko@1
  1572
	template < class X, class Y >
pavolmarko@1
  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@1
  1574
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
pavolmarko@1
  1575
	// Static functions. We convert them into a member function call.
pavolmarko@1
  1576
	// Note that this also provides a conversion from static functions.
pavolmarko@1
  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@1
  1578
		bind(function_to_bind);	}
pavolmarko@1
  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@1
  1581
			function_to_bind); }
pavolmarko@1
  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@1
  1583
		// this next line is the only one that violates the standard
pavolmarko@1
  1584
	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); }
pavolmarko@1
  1585
	inline bool operator ! () const	{	// Is it bound to anything?
pavolmarko@1
  1586
			return !m_Closure; }
pavolmarko@1
  1587
	inline bool empty() const	{
pavolmarko@1
  1588
			return !m_Closure; }
pavolmarko@1
  1589
	void clear() { m_Closure.clear();}
pavolmarko@1
  1590
	// Conversion to and from the DelegateMemento storage class
pavolmarko@1
  1591
	const DelegateMemento & GetMemento() { return m_Closure; }
pavolmarko@1
  1592
	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
pavolmarko@1
  1593
pavolmarko@1
  1594
private:	// Invoker for static functions
pavolmarko@1
  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@1
  1596
	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); }
pavolmarko@1
  1597
};
pavolmarko@1
  1598
pavolmarko@1
  1599
//N=12
pavolmarko@1
  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@1
  1601
class FastDelegate12 {
pavolmarko@1
  1602
private:
pavolmarko@1
  1603
	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
pavolmarko@1
  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@1
  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@1
  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@1
  1607
	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
pavolmarko@1
  1608
public:
pavolmarko@1
  1609
	// Typedefs to aid generic programming
pavolmarko@1
  1610
	typedef FastDelegate12 type;
pavolmarko@1
  1611
pavolmarko@1
  1612
	// Construction and comparison functions
pavolmarko@1
  1613
	FastDelegate12() { clear(); }
pavolmarko@1
  1614
	FastDelegate12(const FastDelegate12 &x) {
pavolmarko@1
  1615
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1616
	void operator = (const FastDelegate12 &x)  {
pavolmarko@1
  1617
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1618
	bool operator ==(const FastDelegate12 &x) const {
pavolmarko@1
  1619
		return m_Closure.IsEqual(x.m_Closure);	}
pavolmarko@1
  1620
	bool operator !=(const FastDelegate12 &x) const {
pavolmarko@1
  1621
		return !m_Closure.IsEqual(x.m_Closure); }
pavolmarko@1
  1622
	bool operator <(const FastDelegate12 &x) const {
pavolmarko@1
  1623
		return m_Closure.IsLess(x.m_Closure);	}
pavolmarko@1
  1624
	bool operator >(const FastDelegate12 &x) const {
pavolmarko@1
  1625
		return x.m_Closure.IsLess(m_Closure);	}
pavolmarko@1
  1626
	// Binding to non-const member functions
pavolmarko@1
  1627
	template < class X, class Y >
pavolmarko@1
  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@1
  1629
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
pavolmarko@1
  1630
	template < class X, class Y >
pavolmarko@1
  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@1
  1632
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
pavolmarko@1
  1633
	// Binding to const member functions.
pavolmarko@1
  1634
	template < class X, class Y >
pavolmarko@1
  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@1
  1636
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
pavolmarko@1
  1637
	template < class X, class Y >
pavolmarko@1
  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@1
  1639
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
pavolmarko@1
  1640
	// Static functions. We convert them into a member function call.
pavolmarko@1
  1641
	// Note that this also provides a conversion from static functions.
pavolmarko@1
  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@1
  1643
		bind(function_to_bind);	}
pavolmarko@1
  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@1
  1646
			function_to_bind); }
pavolmarko@1
  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@1
  1648
		// this next line is the only one that violates the standard
pavolmarko@1
  1649
	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); }
pavolmarko@1
  1650
	inline bool operator ! () const	{	// Is it bound to anything?
pavolmarko@1
  1651
			return !m_Closure; }
pavolmarko@1
  1652
	inline bool empty() const	{
pavolmarko@1
  1653
			return !m_Closure; }
pavolmarko@1
  1654
	void clear() { m_Closure.clear();}
pavolmarko@1
  1655
	// Conversion to and from the DelegateMemento storage class
pavolmarko@1
  1656
	const DelegateMemento & GetMemento() { return m_Closure; }
pavolmarko@1
  1657
	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
pavolmarko@1
  1658
pavolmarko@1
  1659
private:	// Invoker for static functions
pavolmarko@1
  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@1
  1661
	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); }
pavolmarko@1
  1662
};
pavolmarko@1
  1663
pavolmarko@1
  1664
//N=13
pavolmarko@1
  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@1
  1666
class FastDelegate13 {
pavolmarko@1
  1667
private:
pavolmarko@1
  1668
	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
pavolmarko@1
  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@1
  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@1
  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@1
  1672
	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
pavolmarko@1
  1673
public:
pavolmarko@1
  1674
	// Typedefs to aid generic programming
pavolmarko@1
  1675
	typedef FastDelegate13 type;
pavolmarko@1
  1676
pavolmarko@1
  1677
	// Construction and comparison functions
pavolmarko@1
  1678
	FastDelegate13() { clear(); }
pavolmarko@1
  1679
	FastDelegate13(const FastDelegate13 &x) {
pavolmarko@1
  1680
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1681
	void operator = (const FastDelegate13 &x)  {
pavolmarko@1
  1682
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1683
	bool operator ==(const FastDelegate13 &x) const {
pavolmarko@1
  1684
		return m_Closure.IsEqual(x.m_Closure);	}
pavolmarko@1
  1685
	bool operator !=(const FastDelegate13 &x) const {
pavolmarko@1
  1686
		return !m_Closure.IsEqual(x.m_Closure); }
pavolmarko@1
  1687
	bool operator <(const FastDelegate13 &x) const {
pavolmarko@1
  1688
		return m_Closure.IsLess(x.m_Closure);	}
pavolmarko@1
  1689
	bool operator >(const FastDelegate13 &x) const {
pavolmarko@1
  1690
		return x.m_Closure.IsLess(m_Closure);	}
pavolmarko@1
  1691
	// Binding to non-const member functions
pavolmarko@1
  1692
	template < class X, class Y >
pavolmarko@1
  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@1
  1694
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
pavolmarko@1
  1695
	template < class X, class Y >
pavolmarko@1
  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@1
  1697
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
pavolmarko@1
  1698
	// Binding to const member functions.
pavolmarko@1
  1699
	template < class X, class Y >
pavolmarko@1
  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@1
  1701
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
pavolmarko@1
  1702
	template < class X, class Y >
pavolmarko@1
  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@1
  1704
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
pavolmarko@1
  1705
	// Static functions. We convert them into a member function call.
pavolmarko@1
  1706
	// Note that this also provides a conversion from static functions.
pavolmarko@1
  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@1
  1708
		bind(function_to_bind);	}
pavolmarko@1
  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@1
  1711
			function_to_bind); }
pavolmarko@1
  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@1
  1713
		// this next line is the only one that violates the standard
pavolmarko@1
  1714
	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); }
pavolmarko@1
  1715
	inline bool operator ! () const	{	// Is it bound to anything?
pavolmarko@1
  1716
			return !m_Closure; }
pavolmarko@1
  1717
	inline bool empty() const	{
pavolmarko@1
  1718
			return !m_Closure; }
pavolmarko@1
  1719
	void clear() { m_Closure.clear();}
pavolmarko@1
  1720
	// Conversion to and from the DelegateMemento storage class
pavolmarko@1
  1721
	const DelegateMemento & GetMemento() { return m_Closure; }
pavolmarko@1
  1722
	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
pavolmarko@1
  1723
pavolmarko@1
  1724
private:	// Invoker for static functions
pavolmarko@1
  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@1
  1726
	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); }
pavolmarko@1
  1727
};
pavolmarko@1
  1728
pavolmarko@1
  1729
//N=14
pavolmarko@1
  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@1
  1731
class FastDelegate14 {
pavolmarko@1
  1732
private:
pavolmarko@1
  1733
	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
pavolmarko@1
  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@1
  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@1
  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@1
  1737
	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
pavolmarko@1
  1738
public:
pavolmarko@1
  1739
	// Typedefs to aid generic programming
pavolmarko@1
  1740
	typedef FastDelegate14 type;
pavolmarko@1
  1741
pavolmarko@1
  1742
	// Construction and comparison functions
pavolmarko@1
  1743
	FastDelegate14() { clear(); }
pavolmarko@1
  1744
	FastDelegate14(const FastDelegate14 &x) {
pavolmarko@1
  1745
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1746
	void operator = (const FastDelegate14 &x)  {
pavolmarko@1
  1747
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1748
	bool operator ==(const FastDelegate14 &x) const {
pavolmarko@1
  1749
		return m_Closure.IsEqual(x.m_Closure);	}
pavolmarko@1
  1750
	bool operator !=(const FastDelegate14 &x) const {
pavolmarko@1
  1751
		return !m_Closure.IsEqual(x.m_Closure); }
pavolmarko@1
  1752
	bool operator <(const FastDelegate14 &x) const {
pavolmarko@1
  1753
		return m_Closure.IsLess(x.m_Closure);	}
pavolmarko@1
  1754
	bool operator >(const FastDelegate14 &x) const {
pavolmarko@1
  1755
		return x.m_Closure.IsLess(m_Closure);	}
pavolmarko@1
  1756
	// Binding to non-const member functions
pavolmarko@1
  1757
	template < class X, class Y >
pavolmarko@1
  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@1
  1759
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
pavolmarko@1
  1760
	template < class X, class Y >
pavolmarko@1
  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@1
  1762
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
pavolmarko@1
  1763
	// Binding to const member functions.
pavolmarko@1
  1764
	template < class X, class Y >
pavolmarko@1
  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@1
  1766
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
pavolmarko@1
  1767
	template < class X, class Y >
pavolmarko@1
  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@1
  1769
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
pavolmarko@1
  1770
	// Static functions. We convert them into a member function call.
pavolmarko@1
  1771
	// Note that this also provides a conversion from static functions.
pavolmarko@1
  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@1
  1773
		bind(function_to_bind);	}
pavolmarko@1
  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@1
  1776
			function_to_bind); }
pavolmarko@1
  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@1
  1778
		// this next line is the only one that violates the standard
pavolmarko@1
  1779
	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); }
pavolmarko@1
  1780
	inline bool operator ! () const	{	// Is it bound to anything?
pavolmarko@1
  1781
			return !m_Closure; }
pavolmarko@1
  1782
	inline bool empty() const	{
pavolmarko@1
  1783
			return !m_Closure; }
pavolmarko@1
  1784
	void clear() { m_Closure.clear();}
pavolmarko@1
  1785
	// Conversion to and from the DelegateMemento storage class
pavolmarko@1
  1786
	const DelegateMemento & GetMemento() { return m_Closure; }
pavolmarko@1
  1787
	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
pavolmarko@1
  1788
pavolmarko@1
  1789
private:	// Invoker for static functions
pavolmarko@1
  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@1
  1791
	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); }
pavolmarko@1
  1792
};
pavolmarko@1
  1793
pavolmarko@1
  1794
//N=15
pavolmarko@1
  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@1
  1796
class FastDelegate15 {
pavolmarko@1
  1797
private:
pavolmarko@1
  1798
	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
pavolmarko@1
  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@1
  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@1
  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@1
  1802
	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
pavolmarko@1
  1803
public:
pavolmarko@1
  1804
	// Typedefs to aid generic programming
pavolmarko@1
  1805
	typedef FastDelegate15 type;
pavolmarko@1
  1806
pavolmarko@1
  1807
	// Construction and comparison functions
pavolmarko@1
  1808
	FastDelegate15() { clear(); }
pavolmarko@1
  1809
	FastDelegate15(const FastDelegate15 &x) {
pavolmarko@1
  1810
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1811
	void operator = (const FastDelegate15 &x)  {
pavolmarko@1
  1812
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1813
	bool operator ==(const FastDelegate15 &x) const {
pavolmarko@1
  1814
		return m_Closure.IsEqual(x.m_Closure);	}
pavolmarko@1
  1815
	bool operator !=(const FastDelegate15 &x) const {
pavolmarko@1
  1816
		return !m_Closure.IsEqual(x.m_Closure); }
pavolmarko@1
  1817
	bool operator <(const FastDelegate15 &x) const {
pavolmarko@1
  1818
		return m_Closure.IsLess(x.m_Closure);	}
pavolmarko@1
  1819
	bool operator >(const FastDelegate15 &x) const {
pavolmarko@1
  1820
		return x.m_Closure.IsLess(m_Closure);	}
pavolmarko@1
  1821
	// Binding to non-const member functions
pavolmarko@1
  1822
	template < class X, class Y >
pavolmarko@1
  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@1
  1824
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
pavolmarko@1
  1825
	template < class X, class Y >
pavolmarko@1
  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@1
  1827
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
pavolmarko@1
  1828
	// Binding to const member functions.
pavolmarko@1
  1829
	template < class X, class Y >
pavolmarko@1
  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@1
  1831
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
pavolmarko@1
  1832
	template < class X, class Y >
pavolmarko@1
  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@1
  1834
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
pavolmarko@1
  1835
	// Static functions. We convert them into a member function call.
pavolmarko@1
  1836
	// Note that this also provides a conversion from static functions.
pavolmarko@1
  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@1
  1838
		bind(function_to_bind);	}
pavolmarko@1
  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@1
  1841
			function_to_bind); }
pavolmarko@1
  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@1
  1843
		// this next line is the only one that violates the standard
pavolmarko@1
  1844
	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); }
pavolmarko@1
  1845
	inline bool operator ! () const	{	// Is it bound to anything?
pavolmarko@1
  1846
			return !m_Closure; }
pavolmarko@1
  1847
	inline bool empty() const	{
pavolmarko@1
  1848
			return !m_Closure; }
pavolmarko@1
  1849
	void clear() { m_Closure.clear();}
pavolmarko@1
  1850
	// Conversion to and from the DelegateMemento storage class
pavolmarko@1
  1851
	const DelegateMemento & GetMemento() { return m_Closure; }
pavolmarko@1
  1852
	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
pavolmarko@1
  1853
pavolmarko@1
  1854
private:	// Invoker for static functions
pavolmarko@1
  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@1
  1856
	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); }
pavolmarko@1
  1857
};
pavolmarko@1
  1858
pavolmarko@1
  1859
//N=16
pavolmarko@1
  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@1
  1861
class FastDelegate16 {
pavolmarko@1
  1862
private:
pavolmarko@1
  1863
	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
pavolmarko@1
  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@1
  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@1
  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@1
  1867
	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
pavolmarko@1
  1868
public:
pavolmarko@1
  1869
	// Typedefs to aid generic programming
pavolmarko@1
  1870
	typedef FastDelegate16 type;
pavolmarko@1
  1871
pavolmarko@1
  1872
	// Construction and comparison functions
pavolmarko@1
  1873
	FastDelegate16() { clear(); }
pavolmarko@1
  1874
	FastDelegate16(const FastDelegate16 &x) {
pavolmarko@1
  1875
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1876
	void operator = (const FastDelegate16 &x)  {
pavolmarko@1
  1877
		m_Closure.CopyFrom(this, x.m_Closure); }
pavolmarko@1
  1878
	bool operator ==(const FastDelegate16 &x) const {
pavolmarko@1
  1879
		return m_Closure.IsEqual(x.m_Closure);	}
pavolmarko@1
  1880
	bool operator !=(const FastDelegate16 &x) const {
pavolmarko@1
  1881
		return !m_Closure.IsEqual(x.m_Closure); }
pavolmarko@1
  1882
	bool operator <(const FastDelegate16 &x) const {
pavolmarko@1
  1883
		return m_Closure.IsLess(x.m_Closure);	}
pavolmarko@1
  1884
	bool operator >(const FastDelegate16 &x) const {
pavolmarko@1
  1885
		return x.m_Closure.IsLess(m_Closure);	}
pavolmarko@1
  1886
	// Binding to non-const member functions
pavolmarko@1
  1887
	template < class X, class Y >
pavolmarko@1
  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@1
  1889
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
pavolmarko@1
  1890
	template < class X, class Y >
pavolmarko@1
  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@1
  1892
		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
pavolmarko@1
  1893
	// Binding to const member functions.
pavolmarko@1
  1894
	template < class X, class Y >
pavolmarko@1
  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@1
  1896
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
pavolmarko@1
  1897
	template < class X, class Y >
pavolmarko@1
  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@1
  1899
		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
pavolmarko@1
  1900
	// Static functions. We convert them into a member function call.
pavolmarko@1
  1901
	// Note that this also provides a conversion from static functions.
pavolmarko@1
  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@1
  1903
		bind(function_to_bind);	}
pavolmarko@1
  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@1
  1906
			function_to_bind); }
pavolmarko@1
  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@1
  1908
		// this next line is the only one that violates the standard
pavolmarko@1
  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@1
  1910
	inline bool operator ! () const	{	// Is it bound to anything?
pavolmarko@1
  1911
			return !m_Closure; }
pavolmarko@1
  1912
	inline bool empty() const	{
pavolmarko@1
  1913
			return !m_Closure; }
pavolmarko@1
  1914
	void clear() { m_Closure.clear();}
pavolmarko@1
  1915
	// Conversion to and from the DelegateMemento storage class
pavolmarko@1
  1916
	const DelegateMemento & GetMemento() { return m_Closure; }
pavolmarko@1
  1917
	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
pavolmarko@1
  1918
pavolmarko@1
  1919
private:	// Invoker for static functions
pavolmarko@1
  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@1
  1921
	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16); }
pavolmarko@1
  1922
};
pavolmarko@1
  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@1
  2184
pavolmarko@1
  2185
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
  2186
//						Fast Delegates, part 4:
pavolmarko@123
  2187
//
pavolmarko@1
  2188
//				FastDelegate<> class (Original author: Jody Hagins)
pavolmarko@1
  2189
//	Allows boost::function style syntax like:
pavolmarko@1
  2190
//			FastDelegate< double (int, long) >
pavolmarko@1
  2191
// instead of:
pavolmarko@1
  2192
//			FastDelegate2< int, long, double >
pavolmarko@1
  2193
//
pavolmarko@1
  2194
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
  2195
pavolmarko@1
  2196
#ifdef FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX
pavolmarko@1
  2197
pavolmarko@1
  2198
// Declare FastDelegate as a class template.  It will be specialized
pavolmarko@1
  2199
// later for all number of arguments.
pavolmarko@1
  2200
template <typename Signature>
pavolmarko@1
  2201
class FastDelegate;
pavolmarko@1
  2202
pavolmarko@1
  2203
//N=0
pavolmarko@1
  2204
// Specialization to allow use of
pavolmarko@1
  2205
// FastDelegate< R (  ) >
pavolmarko@1
  2206
// instead of
pavolmarko@1
  2207
// FastDelegate0 < R >
pavolmarko@1
  2208
template<typename R>
pavolmarko@1
  2209
class FastDelegate< R (  ) >
pavolmarko@1
  2210
  // Inherit from FastDelegate0 so that it can be treated just
pavolmarko@1
  2211
  // like a FastDelegate0
pavolmarko@1
  2212
  : public FastDelegate0 < R >
pavolmarko@1
  2213
{
pavolmarko@1
  2214
public:
pavolmarko@1
  2215
  // Make using the base type a bit easier via typedef.
pavolmarko@1
  2216
  typedef FastDelegate0 < R > BaseType;
pavolmarko@1
  2217
pavolmarko@1
  2218
  // Allow users access to the specific type of this delegate.
pavolmarko@1
  2219
  typedef FastDelegate SelfType;
pavolmarko@1
  2220
pavolmarko@1
  2221
  // Mimic the base class constructors.
pavolmarko@1
  2222
  FastDelegate() : BaseType() { }
pavolmarko@1
  2223
pavolmarko@1
  2224
  template < class X, class Y >
pavolmarko@123
  2225
  FastDelegate(Y * pthis,
pavolmarko@1
  2226
    R (X::* function_to_bind)(  ))
pavolmarko@1
  2227
    : BaseType(pthis, function_to_bind)  { }
pavolmarko@1
  2228
pavolmarko@1
  2229
  template < class X, class Y >
pavolmarko@1
  2230
  FastDelegate(const Y *pthis,
pavolmarko@1
  2231
      R (X::* function_to_bind)(  ) const)
pavolmarko@1
  2232
    : BaseType(pthis, function_to_bind)
pavolmarko@1
  2233
  {  }
pavolmarko@1
  2234
pavolmarko@1
  2235
  FastDelegate(R (*function_to_bind)(  ))
pavolmarko@1
  2236
    : BaseType(function_to_bind)  { }
pavolmarko@123
  2237
  void operator = (const BaseType &x)  {
pavolmarko@1
  2238
		*static_cast<BaseType*>(this) = x; }
pavolmarko@1
  2239
};
pavolmarko@1
  2240
pavolmarko@1
  2241
//N=1
pavolmarko@1
  2242
// Specialization to allow use of
pavolmarko@1
  2243
// FastDelegate< R ( Param1 ) >
pavolmarko@1
  2244
// instead of
pavolmarko@1
  2245
// FastDelegate1 < Param1, R >
pavolmarko@1
  2246
template<typename R, class Param1>
pavolmarko@1
  2247
class FastDelegate< R ( Param1 ) >
pavolmarko@1
  2248
  // Inherit from FastDelegate1 so that it can be treated just
pavolmarko@1
  2249
  // like a FastDelegate1
pavolmarko@1
  2250
  : public FastDelegate1 < Param1, R >
pavolmarko@1
  2251
{
pavolmarko@1
  2252
public:
pavolmarko@1
  2253
  // Make using the base type a bit easier via typedef.
pavolmarko@1
  2254
  typedef FastDelegate1 < Param1, R > BaseType;
pavolmarko@1
  2255
pavolmarko@1
  2256
  // Allow users access to the specific type of this delegate.
pavolmarko@1
  2257
  typedef FastDelegate SelfType;
pavolmarko@1
  2258
pavolmarko@1
  2259
  // Mimic the base class constructors.
pavolmarko@1
  2260
  FastDelegate() : BaseType() { }
pavolmarko@1
  2261
pavolmarko@1
  2262
  template < class X, class Y >
pavolmarko@123
  2263
  FastDelegate(Y * pthis,
pavolmarko@1
  2264
    R (X::* function_to_bind)( Param1 p1 ))
pavolmarko@1
  2265
    : BaseType(pthis, function_to_bind)  { }
pavolmarko@1
  2266
pavolmarko@1
  2267
  template < class X, class Y >
pavolmarko@1
  2268
  FastDelegate(const Y *pthis,
pavolmarko@1
  2269
      R (X::* function_to_bind)( Param1 p1 ) const)
pavolmarko@1
  2270
    : BaseType(pthis, function_to_bind)
pavolmarko@1
  2271
  {  }
pavolmarko@1
  2272
pavolmarko@1
  2273
  FastDelegate(R (*function_to_bind)( Param1 p1 ))
pavolmarko@1
  2274
    : BaseType(function_to_bind)  { }
pavolmarko@123
  2275
  void operator = (const BaseType &x)  {
pavolmarko@1
  2276
		*static_cast<BaseType*>(this) = x; }
pavolmarko@1
  2277
};
pavolmarko@1
  2278
pavolmarko@1
  2279
//N=2
pavolmarko@1
  2280
// Specialization to allow use of
pavolmarko@1
  2281
// FastDelegate< R ( Param1, Param2 ) >
pavolmarko@1
  2282
// instead of
pavolmarko@1
  2283
// FastDelegate2 < Param1, Param2, R >
pavolmarko@1
  2284
template<typename R, class Param1, class Param2>
pavolmarko@1
  2285
class FastDelegate< R ( Param1, Param2 ) >
pavolmarko@1
  2286
  // Inherit from FastDelegate2 so that it can be treated just
pavolmarko@1
  2287
  // like a FastDelegate2
pavolmarko@1
  2288
  : public FastDelegate2 < Param1, Param2, R >
pavolmarko@1
  2289
{
pavolmarko@1
  2290
public:
pavolmarko@1
  2291
  // Make using the base type a bit easier via typedef.
pavolmarko@1
  2292
  typedef FastDelegate2 < Param1, Param2, R > BaseType;
pavolmarko@1
  2293
pavolmarko@1
  2294
  // Allow users access to the specific type of this delegate.
pavolmarko@1
  2295
  typedef FastDelegate SelfType;
pavolmarko@1
  2296
pavolmarko@1
  2297
  // Mimic the base class constructors.
pavolmarko@1
  2298
  FastDelegate() : BaseType() { }
pavolmarko@1
  2299
pavolmarko@1
  2300
  template < class X, class Y >
pavolmarko@123
  2301
  FastDelegate(Y * pthis,
pavolmarko@1
  2302
    R (X::* function_to_bind)( Param1 p1, Param2 p2 ))
pavolmarko@1
  2303
    : BaseType(pthis, function_to_bind)  { }
pavolmarko@1
  2304
pavolmarko@1
  2305
  template < class X, class Y >
pavolmarko@1
  2306
  FastDelegate(const Y *pthis,
pavolmarko@1
  2307
      R (X::* function_to_bind)( Param1 p1, Param2 p2 ) const)
pavolmarko@1
  2308
    : BaseType(pthis, function_to_bind)
pavolmarko@1
  2309
  {  }
pavolmarko@1
  2310
pavolmarko@1
  2311
  FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2 ))
pavolmarko@1
  2312
    : BaseType(function_to_bind)  { }
pavolmarko@123
  2313
  void operator = (const BaseType &x)  {
pavolmarko@1
  2314
		*static_cast<BaseType*>(this) = x; }
pavolmarko@1
  2315
};
pavolmarko@1
  2316
pavolmarko@1
  2317
//N=3
pavolmarko@1
  2318
// Specialization to allow use of
pavolmarko@1
  2319
// FastDelegate< R ( Param1, Param2, Param3 ) >
pavolmarko@1
  2320
// instead of
pavolmarko@1
  2321
// FastDelegate3 < Param1, Param2, Param3, R >
pavolmarko@1
  2322
template<typename R, class Param1, class Param2, class Param3>
pavolmarko@1
  2323
class FastDelegate< R ( Param1, Param2, Param3 ) >
pavolmarko@1
  2324
  // Inherit from FastDelegate3 so that it can be treated just
pavolmarko@1
  2325
  // like a FastDelegate3
pavolmarko@1
  2326
  : public FastDelegate3 < Param1, Param2, Param3, R >
pavolmarko@1
  2327
{
pavolmarko@1
  2328
public:
pavolmarko@1
  2329
  // Make using the base type a bit easier via typedef.
pavolmarko@1
  2330
  typedef FastDelegate3 < Param1, Param2, Param3, R > BaseType;
pavolmarko@1
  2331
pavolmarko@1
  2332
  // Allow users access to the specific type of this delegate.
pavolmarko@1
  2333
  typedef FastDelegate SelfType;
pavolmarko@1
  2334
pavolmarko@1
  2335
  // Mimic the base class constructors.
pavolmarko@1
  2336
  FastDelegate() : BaseType() { }
pavolmarko@1
  2337
pavolmarko@1
  2338
  template < class X, class Y >
pavolmarko@123
  2339
  FastDelegate(Y * pthis,
pavolmarko@1
  2340
    R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3 ))
pavolmarko@1
  2341
    : BaseType(pthis, function_to_bind)  { }
pavolmarko@1
  2342
pavolmarko@1
  2343
  template < class X, class Y >
pavolmarko@1
  2344
  FastDelegate(const Y *pthis,
pavolmarko@1
  2345
      R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3 ) const)
pavolmarko@1
  2346
    : BaseType(pthis, function_to_bind)
pavolmarko@1
  2347
  {  }
pavolmarko@1
  2348
pavolmarko@1
  2349
  FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3 ))
pavolmarko@1
  2350
    : BaseType(function_to_bind)  { }
pavolmarko@123
  2351
  void operator = (const BaseType &x)  {
pavolmarko@1
  2352
		*static_cast<BaseType*>(this) = x; }
pavolmarko@1
  2353
};
pavolmarko@1
  2354
pavolmarko@1
  2355
//N=4
pavolmarko@1
  2356
// Specialization to allow use of
pavolmarko@1
  2357
// FastDelegate< R ( Param1, Param2, Param3, Param4 ) >
pavolmarko@1
  2358
// instead of
pavolmarko@1
  2359
// FastDelegate4 < Param1, Param2, Param3, Param4, R >
pavolmarko@1
  2360
template<typename R, class Param1, class Param2, class Param3, class Param4>
pavolmarko@1
  2361
class FastDelegate< R ( Param1, Param2, Param3, Param4 ) >
pavolmarko@1
  2362
  // Inherit from FastDelegate4 so that it can be treated just
pavolmarko@1
  2363
  // like a FastDelegate4
pavolmarko@1
  2364
  : public FastDelegate4 < Param1, Param2, Param3, Param4, R >
pavolmarko@1
  2365
{
pavolmarko@1
  2366
public:
pavolmarko@1
  2367
  // Make using the base type a bit easier via typedef.
pavolmarko@1
  2368
  typedef FastDelegate4 < Param1, Param2, Param3, Param4, R > BaseType;
pavolmarko@1
  2369
pavolmarko@1
  2370
  // Allow users access to the specific type of this delegate.
pavolmarko@1
  2371
  typedef FastDelegate SelfType;
pavolmarko@1
  2372
pavolmarko@1
  2373
  // Mimic the base class constructors.
pavolmarko@1
  2374
  FastDelegate() : BaseType() { }
pavolmarko@1
  2375
pavolmarko@1
  2376
  template < class X, class Y >
pavolmarko@123
  2377
  FastDelegate(Y * pthis,
pavolmarko@1
  2378
    R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4 ))
pavolmarko@1
  2379
    : BaseType(pthis, function_to_bind)  { }
pavolmarko@1
  2380
pavolmarko@1
  2381
  template < class X, class Y >
pavolmarko@1
  2382
  FastDelegate(const Y *pthis,
pavolmarko@1
  2383
      R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4 ) const)
pavolmarko@1
  2384
    : BaseType(pthis, function_to_bind)
pavolmarko@1
  2385
  {  }
pavolmarko@1
  2386
pavolmarko@1
  2387
  FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4 ))
pavolmarko@1
  2388
    : BaseType(function_to_bind)  { }
pavolmarko@123
  2389
  void operator = (const BaseType &x)  {
pavolmarko@1
  2390
		*static_cast<BaseType*>(this) = x; }
pavolmarko@1
  2391
};
pavolmarko@1
  2392
pavolmarko@1
  2393
//N=5
pavolmarko@1
  2394
// Specialization to allow use of
pavolmarko@1
  2395
// FastDelegate< R ( Param1, Param2, Param3, Param4, Param5 ) >
pavolmarko@1
  2396
// instead of
pavolmarko@1
  2397
// FastDelegate5 < Param1, Param2, Param3, Param4, Param5, R >
pavolmarko@1
  2398
template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5>
pavolmarko@1
  2399
class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5 ) >
pavolmarko@1
  2400
  // Inherit from FastDelegate5 so that it can be treated just
pavolmarko@1
  2401
  // like a FastDelegate5
pavolmarko@1
  2402
  : public FastDelegate5 < Param1, Param2, Param3, Param4, Param5, R >
pavolmarko@1
  2403
{
pavolmarko@1
  2404
public:
pavolmarko@1
  2405
  // Make using the base type a bit easier via typedef.
pavolmarko@1
  2406
  typedef FastDelegate5 < Param1, Param2, Param3, Param4, Param5, R > BaseType;
pavolmarko@1
  2407
pavolmarko@1
  2408
  // Allow users access to the specific type of this delegate.
pavolmarko@1
  2409
  typedef FastDelegate SelfType;
pavolmarko@1
  2410
pavolmarko@1
  2411
  // Mimic the base class constructors.
pavolmarko@1
  2412
  FastDelegate() : BaseType() { }
pavolmarko@1
  2413
pavolmarko@1
  2414
  template < class X, class Y >
pavolmarko@123
  2415
  FastDelegate(Y * pthis,
pavolmarko@1
  2416
    R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5 ))
pavolmarko@1
  2417
    : BaseType(pthis, function_to_bind)  { }
pavolmarko@1
  2418
pavolmarko@1
  2419
  template < class X, class Y >
pavolmarko@1
  2420
  FastDelegate(const Y *pthis,
pavolmarko@1
  2421
      R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5 ) const)
pavolmarko@1
  2422
    : BaseType(pthis, function_to_bind)
pavolmarko@1
  2423
  {  }
pavolmarko@1
  2424
pavolmarko@1
  2425
  FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5 ))
pavolmarko@1
  2426
    : BaseType(function_to_bind)  { }
pavolmarko@123
  2427
  void operator = (const BaseType &x)  {
pavolmarko@1
  2428
		*static_cast<BaseType*>(this) = x; }
pavolmarko@1
  2429
};
pavolmarko@1
  2430
pavolmarko@1
  2431
//N=6
pavolmarko@1
  2432
// Specialization to allow use of
pavolmarko@1
  2433
// FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6 ) >
pavolmarko@1
  2434
// instead of
pavolmarko@1
  2435
// FastDelegate6 < Param1, Param2, Param3, Param4, Param5, Param6, R >
pavolmarko@1
  2436
template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
pavolmarko@1
  2437
class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6 ) >
pavolmarko@1
  2438
  // Inherit from FastDelegate6 so that it can be treated just
pavolmarko@1
  2439
  // like a FastDelegate6
pavolmarko@1
  2440
  : public FastDelegate6 < Param1, Param2, Param3, Param4, Param5, Param6, R >
pavolmarko@1
  2441
{
pavolmarko@1
  2442
public:
pavolmarko@1
  2443
  // Make using the base type a bit easier via typedef.
pavolmarko@1
  2444
  typedef FastDelegate6 < Param1, Param2, Param3, Param4, Param5, Param6, R > BaseType;
pavolmarko@1
  2445
pavolmarko@1
  2446
  // Allow users access to the specific type of this delegate.
pavolmarko@1
  2447
  typedef FastDelegate SelfType;
pavolmarko@1
  2448
pavolmarko@1
  2449
  // Mimic the base class constructors.
pavolmarko@1
  2450
  FastDelegate() : BaseType() { }
pavolmarko@1
  2451
pavolmarko@1
  2452
  template < class X, class Y >
pavolmarko@123
  2453
  FastDelegate(Y * pthis,
pavolmarko@1
  2454
    R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6 ))
pavolmarko@1
  2455
    : BaseType(pthis, function_to_bind)  { }
pavolmarko@1
  2456
pavolmarko@1
  2457
  template < class X, class Y >
pavolmarko@1
  2458
  FastDelegate(const Y *pthis,
pavolmarko@1
  2459
      R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6 ) const)
pavolmarko@1
  2460
    : BaseType(pthis, function_to_bind)
pavolmarko@1
  2461
  {  }
pavolmarko@1
  2462
pavolmarko@1
  2463
  FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6 ))
pavolmarko@1
  2464
    : BaseType(function_to_bind)  { }
pavolmarko@123
  2465
  void operator = (const BaseType &x)  {
pavolmarko@1
  2466
		*static_cast<BaseType*>(this) = x; }
pavolmarko@1
  2467
};
pavolmarko@1
  2468
pavolmarko@1
  2469
//N=7
pavolmarko@1
  2470
// Specialization to allow use of
pavolmarko@1
  2471
// FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7 ) >
pavolmarko@1
  2472
// instead of
pavolmarko@1
  2473
// FastDelegate7 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, R >
pavolmarko@1
  2474
template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
pavolmarko@1
  2475
class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7 ) >
pavolmarko@1
  2476
  // Inherit from FastDelegate7 so that it can be treated just
pavolmarko@1
  2477
  // like a FastDelegate7
pavolmarko@1
  2478
  : public FastDelegate7 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, R >
pavolmarko@1
  2479
{
pavolmarko@1
  2480
public:
pavolmarko@1
  2481
  // Make using the base type a bit easier via typedef.
pavolmarko@1
  2482
  typedef FastDelegate7 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, R > BaseType;
pavolmarko@1
  2483
pavolmarko@1
  2484
  // Allow users access to the specific type of this delegate.
pavolmarko@1
  2485
  typedef FastDelegate SelfType;
pavolmarko@1
  2486
pavolmarko@1
  2487
  // Mimic the base class constructors.
pavolmarko@1
  2488
  FastDelegate() : BaseType() { }
pavolmarko@1
  2489
pavolmarko@1
  2490
  template < class X, class Y >
pavolmarko@123
  2491
  FastDelegate(Y * pthis,
pavolmarko@1
  2492
    R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7 ))
pavolmarko@1
  2493
    : BaseType(pthis, function_to_bind)  { }
pavolmarko@1
  2494
pavolmarko@1
  2495
  template < class X, class Y >
pavolmarko@1
  2496
  FastDelegate(const Y *pthis,
pavolmarko@1
  2497
      R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7 ) const)
pavolmarko@1
  2498
    : BaseType(pthis, function_to_bind)
pavolmarko@1
  2499
  {  }
pavolmarko@1
  2500
pavolmarko@1
  2501
  FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7 ))
pavolmarko@1
  2502
    : BaseType(function_to_bind)  { }
pavolmarko@123
  2503
  void operator = (const BaseType &x)  {
pavolmarko@1
  2504
		*static_cast<BaseType*>(this) = x; }
pavolmarko@1
  2505
};
pavolmarko@1
  2506
pavolmarko@1
  2507
//N=8
pavolmarko@1
  2508
// Specialization to allow use of
pavolmarko@1
  2509
// FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8 ) >
pavolmarko@1
  2510
// instead of
pavolmarko@1
  2511
// FastDelegate8 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, R >
pavolmarko@1
  2512
template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
pavolmarko@1
  2513
class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8 ) >
pavolmarko@1
  2514
  // Inherit from FastDelegate8 so that it can be treated just
pavolmarko@1
  2515
  // like a FastDelegate8
pavolmarko@1
  2516
  : public FastDelegate8 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, R >
pavolmarko@1
  2517
{
pavolmarko@1
  2518
public:
pavolmarko@1
  2519
  // Make using the base type a bit easier via typedef.
pavolmarko@1
  2520
  typedef FastDelegate8 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, R > BaseType;
pavolmarko@1
  2521
pavolmarko@1
  2522
  // Allow users access to the specific type of this delegate.
pavolmarko@1
  2523
  typedef FastDelegate SelfType;
pavolmarko@1
  2524
pavolmarko@1
  2525
  // Mimic the base class constructors.
pavolmarko@1
  2526
  FastDelegate() : BaseType() { }
pavolmarko@1
  2527
pavolmarko@1
  2528
  template < class X, class Y >
pavolmarko@123
  2529
  FastDelegate(Y * pthis,
pavolmarko@1
  2530
    R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8 ))
pavolmarko@1
  2531
    : BaseType(pthis, function_to_bind)  { }
pavolmarko@1
  2532
pavolmarko@1
  2533
  template < class X, class Y >
pavolmarko@1
  2534
  FastDelegate(const Y *pthis,
pavolmarko@1
  2535
      R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8 ) const)
pavolmarko@1
  2536
    : BaseType(pthis, function_to_bind)
pavolmarko@1
  2537
  {  }
pavolmarko@1
  2538
pavolmarko@1
  2539
  FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8 ))
pavolmarko@1
  2540
    : BaseType(function_to_bind)  { }
pavolmarko@123
  2541
  void operator = (const BaseType &x)  {
pavolmarko@1
  2542
		*static_cast<BaseType*>(this) = x; }
pavolmarko@1
  2543
};
pavolmarko@1
  2544
pavolmarko@1
  2545
//N=9
pavolmarko@1
  2546
// Specialization to allow use of
pavolmarko@1
  2547
// FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9 ) >
pavolmarko@1
  2548
// instead of
pavolmarko@1
  2549
// FastDelegate9 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, R >
pavolmarko@1
  2550
template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9>
pavolmarko@1
  2551
class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9 ) >
pavolmarko@1
  2552
  // Inherit from FastDelegate9 so that it can be treated just
pavolmarko@1
  2553
  // like a FastDelegate9
pavolmarko@1
  2554
  : public FastDelegate9 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, R >
pavolmarko@1
  2555
{
pavolmarko@1
  2556
public:
pavolmarko@1
  2557
  // Make using the base type a bit easier via typedef.
pavolmarko@1
  2558
  typedef FastDelegate9 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, R > BaseType;
pavolmarko@1
  2559
pavolmarko@1
  2560
  // Allow users access to the specific type of this delegate.
pavolmarko@1
  2561
  typedef FastDelegate SelfType;
pavolmarko@1
  2562
pavolmarko@1
  2563
  // Mimic the base class constructors.
pavolmarko@1
  2564
  FastDelegate() : BaseType() { }
pavolmarko@1
  2565
pavolmarko@1
  2566
  template < class X, class Y >
pavolmarko@123
  2567
  FastDelegate(Y * pthis,
pavolmarko@1
  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@1
  2569
    : BaseType(pthis, function_to_bind)  { }
pavolmarko@1
  2570
pavolmarko@1
  2571
  template < class X, class Y >
pavolmarko@1
  2572
  FastDelegate(const Y *pthis,
pavolmarko@1
  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@1
  2574
    : BaseType(pthis, function_to_bind)
pavolmarko@1
  2575
  {  }
pavolmarko@1
  2576
pavolmarko@1
  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@1
  2578
    : BaseType(function_to_bind)  { }
pavolmarko@123
  2579
  void operator = (const BaseType &x)  {
pavolmarko@1
  2580
		*static_cast<BaseType*>(this) = x; }
pavolmarko@1
  2581
};
pavolmarko@1
  2582
pavolmarko@1
  2583
//N=10
pavolmarko@1
  2584
// Specialization to allow use of
pavolmarko@1
  2585
// FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10 ) >
pavolmarko@1
  2586
// instead of
pavolmarko@1
  2587
// FastDelegate10 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, R >
pavolmarko@1
  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@1
  2589
class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10 ) >
pavolmarko@1
  2590
  // Inherit from FastDelegate10 so that it can be treated just
pavolmarko@1
  2591
  // like a FastDelegate10
pavolmarko@1
  2592
  : public FastDelegate10 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, R >
pavolmarko@1
  2593
{
pavolmarko@1
  2594
public:
pavolmarko@1
  2595
  // Make using the base type a bit easier via typedef.
pavolmarko@1
  2596
  typedef FastDelegate10 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, R > BaseType;
pavolmarko@1
  2597
pavolmarko@1
  2598
  // Allow users access to the specific type of this delegate.
pavolmarko@1
  2599
  typedef FastDelegate SelfType;
pavolmarko@1
  2600
pavolmarko@1
  2601
  // Mimic the base class constructors.
pavolmarko@1
  2602
  FastDelegate() : BaseType() { }
pavolmarko@1
  2603
pavolmarko@1
  2604
  template < class X, class Y >
pavolmarko@123
  2605
  FastDelegate(Y * pthis,
pavolmarko@1
  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@1
  2607
    : BaseType(pthis, function_to_bind)  { }
pavolmarko@1
  2608
pavolmarko@1
  2609
  template < class X, class Y >
pavolmarko@1
  2610
  FastDelegate(const Y *pthis,
pavolmarko@1
  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@1
  2612
    : BaseType(pthis, function_to_bind)
pavolmarko@1
  2613
  {  }
pavolmarko@1
  2614
pavolmarko@1
  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@1
  2616
    : BaseType(function_to_bind)  { }
pavolmarko@123
  2617
  void operator = (const BaseType &x)  {
pavolmarko@1
  2618
		*static_cast<BaseType*>(this) = x; }
pavolmarko@1
  2619
};
pavolmarko@1
  2620
pavolmarko@1
  2621
//N=11
pavolmarko@1
  2622
// Specialization to allow use of
pavolmarko@1
  2623
// FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11 ) >
pavolmarko@1
  2624
// instead of
pavolmarko@1
  2625
// FastDelegate11 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, R >
pavolmarko@1
  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@1
  2627
class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11 ) >
pavolmarko@1
  2628
  // Inherit from FastDelegate11 so that it can be treated just
pavolmarko@1
  2629
  // like a FastDelegate11
pavolmarko@1
  2630
  : public FastDelegate11 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, R >
pavolmarko@1
  2631
{
pavolmarko@1
  2632
public:
pavolmarko@1
  2633
  // Make using the base type a bit easier via typedef.
pavolmarko@1
  2634
  typedef FastDelegate11 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, R > BaseType;
pavolmarko@1
  2635
pavolmarko@1
  2636
  // Allow users access to the specific type of this delegate.
pavolmarko@1
  2637
  typedef FastDelegate SelfType;
pavolmarko@1
  2638
pavolmarko@1
  2639
  // Mimic the base class constructors.
pavolmarko@1
  2640
  FastDelegate() : BaseType() { }
pavolmarko@1
  2641
pavolmarko@1
  2642
  template < class X, class Y >
pavolmarko@123
  2643
  FastDelegate(Y * pthis,
pavolmarko@1
  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@1
  2645
    : BaseType(pthis, function_to_bind)  { }
pavolmarko@1
  2646
pavolmarko@1
  2647
  template < class X, class Y >
pavolmarko@1
  2648
  FastDelegate(const Y *pthis,
pavolmarko@1
  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@1
  2650
    : BaseType(pthis, function_to_bind)
pavolmarko@1
  2651
  {  }
pavolmarko@1
  2652
pavolmarko@1
  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@1
  2654
    : BaseType(function_to_bind)  { }
pavolmarko@123
  2655
  void operator = (const BaseType &x)  {
pavolmarko@1
  2656
		*static_cast<BaseType*>(this) = x; }
pavolmarko@1
  2657
};
pavolmarko@1
  2658
pavolmarko@1
  2659
//N=12
pavolmarko@1
  2660
// Specialization to allow use of
pavolmarko@1
  2661
// FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12 ) >
pavolmarko@1
  2662
// instead of
pavolmarko@1
  2663
// FastDelegate12 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, R >
pavolmarko@1
  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@1
  2665
class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12 ) >
pavolmarko@1
  2666
  // Inherit from FastDelegate12 so that it can be treated just
pavolmarko@1
  2667
  // like a FastDelegate12
pavolmarko@1
  2668
  : public FastDelegate12 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, R >
pavolmarko@1
  2669
{
pavolmarko@1
  2670
public:
pavolmarko@1
  2671
  // Make using the base type a bit easier via typedef.
pavolmarko@1
  2672
  typedef FastDelegate12 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, R > BaseType;
pavolmarko@1
  2673
pavolmarko@1
  2674
  // Allow users access to the specific type of this delegate.
pavolmarko@1
  2675
  typedef FastDelegate SelfType;
pavolmarko@1
  2676
pavolmarko@1
  2677
  // Mimic the base class constructors.
pavolmarko@1
  2678
  FastDelegate() : BaseType() { }
pavolmarko@1
  2679
pavolmarko@1
  2680
  template < class X, class Y >
pavolmarko@123
  2681
  FastDelegate(Y * pthis,
pavolmarko@1
  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@1
  2683
    : BaseType(pthis, function_to_bind)  { }
pavolmarko@1
  2684
pavolmarko@1
  2685
  template < class X, class Y >
pavolmarko@1
  2686
  FastDelegate(const Y *pthis,
pavolmarko@1
  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@1
  2688
    : BaseType(pthis, function_to_bind)
pavolmarko@1
  2689
  {  }
pavolmarko@1
  2690
pavolmarko@1
  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@1
  2692
    : BaseType(function_to_bind)  { }
pavolmarko@123
  2693
  void operator = (const BaseType &x)  {
pavolmarko@1
  2694
		*static_cast<BaseType*>(this) = x; }
pavolmarko@1
  2695
};
pavolmarko@1
  2696
pavolmarko@1
  2697
//N=13
pavolmarko@1
  2698
// Specialization to allow use of
pavolmarko@1
  2699
// FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13 ) >
pavolmarko@1
  2700
// instead of
pavolmarko@1
  2701
// FastDelegate13 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, R >
pavolmarko@1
  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@1
  2703
class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13 ) >
pavolmarko@1
  2704
  // Inherit from FastDelegate13 so that it can be treated just
pavolmarko@1
  2705
  // like a FastDelegate13
pavolmarko@1
  2706
  : public FastDelegate13 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, R >
pavolmarko@1
  2707
{
pavolmarko@1
  2708
public:
pavolmarko@1
  2709
  // Make using the base type a bit easier via typedef.
pavolmarko@1
  2710
  typedef FastDelegate13 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, R > BaseType;
pavolmarko@1
  2711
pavolmarko@1
  2712
  // Allow users access to the specific type of this delegate.
pavolmarko@1
  2713
  typedef FastDelegate SelfType;
pavolmarko@1
  2714
pavolmarko@1
  2715
  // Mimic the base class constructors.
pavolmarko@1
  2716
  FastDelegate() : BaseType() { }
pavolmarko@1
  2717
pavolmarko@1
  2718
  template < class X, class Y >
pavolmarko@123
  2719
  FastDelegate(Y * pthis,
pavolmarko@1
  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@1
  2721
    : BaseType(pthis, function_to_bind)  { }
pavolmarko@1
  2722
pavolmarko@1
  2723
  template < class X, class Y >
pavolmarko@1
  2724
  FastDelegate(const Y *pthis,
pavolmarko@1
  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@1
  2726
    : BaseType(pthis, function_to_bind)
pavolmarko@1
  2727
  {  }
pavolmarko@1
  2728
pavolmarko@1
  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@1
  2730
    : BaseType(function_to_bind)  { }
pavolmarko@123
  2731
  void operator = (const BaseType &x)  {
pavolmarko@1
  2732
		*static_cast<BaseType*>(this) = x; }
pavolmarko@1
  2733
};
pavolmarko@1
  2734
pavolmarko@1
  2735
//N=14
pavolmarko@1
  2736
// Specialization to allow use of
pavolmarko@1
  2737
// FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14 ) >
pavolmarko@1
  2738
// instead of
pavolmarko@1
  2739
// FastDelegate14 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, R >
pavolmarko@1
  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@1
  2741
class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14 ) >
pavolmarko@1
  2742
  // Inherit from FastDelegate14 so that it can be treated just
pavolmarko@1
  2743
  // like a FastDelegate14
pavolmarko@1
  2744
  : public FastDelegate14 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, R >
pavolmarko@1
  2745
{
pavolmarko@1
  2746
public:
pavolmarko@1
  2747
  // Make using the base type a bit easier via typedef.
pavolmarko@1
  2748
  typedef FastDelegate14 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, R > BaseType;
pavolmarko@1
  2749
pavolmarko@1
  2750
  // Allow users access to the specific type of this delegate.
pavolmarko@1
  2751
  typedef FastDelegate SelfType;
pavolmarko@1
  2752
pavolmarko@1
  2753
  // Mimic the base class constructors.
pavolmarko@1
  2754
  FastDelegate() : BaseType() { }
pavolmarko@1
  2755
pavolmarko@1
  2756
  template < class X, class Y >
pavolmarko@123
  2757
  FastDelegate(Y * pthis,
pavolmarko@1
  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@1
  2759
    : BaseType(pthis, function_to_bind)  { }
pavolmarko@1
  2760
pavolmarko@1
  2761
  template < class X, class Y >
pavolmarko@1
  2762
  FastDelegate(const Y *pthis,
pavolmarko@1
  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@1
  2764
    : BaseType(pthis, function_to_bind)
pavolmarko@1
  2765
  {  }
pavolmarko@1
  2766
pavolmarko@1
  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@1
  2768
    : BaseType(function_to_bind)  { }
pavolmarko@123
  2769
  void operator = (const BaseType &x)  {
pavolmarko@1
  2770
		*static_cast<BaseType*>(this) = x; }
pavolmarko@1
  2771
};
pavolmarko@1
  2772
pavolmarko@1
  2773
//N=15
pavolmarko@1
  2774
// Specialization to allow use of
pavolmarko@1
  2775
// FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15 ) >
pavolmarko@1
  2776
// instead of
pavolmarko@1
  2777
// FastDelegate15 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, R >
pavolmarko@1
  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@1
  2779
class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15 ) >
pavolmarko@1
  2780
  // Inherit from FastDelegate15 so that it can be treated just
pavolmarko@1
  2781
  // like a FastDelegate15
pavolmarko@1
  2782
  : public FastDelegate15 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, R >
pavolmarko@1
  2783
{
pavolmarko@1
  2784
public:
pavolmarko@1
  2785
  // Make using the base type a bit easier via typedef.
pavolmarko@1
  2786
  typedef FastDelegate15 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, R > BaseType;
pavolmarko@1
  2787
pavolmarko@1
  2788
  // Allow users access to the specific type of this delegate.
pavolmarko@1
  2789
  typedef FastDelegate SelfType;
pavolmarko@1
  2790
pavolmarko@1
  2791
  // Mimic the base class constructors.
pavolmarko@1
  2792
  FastDelegate() : BaseType() { }
pavolmarko@1
  2793
pavolmarko@1
  2794
  template < class X, class Y >
pavolmarko@123
  2795
  FastDelegate(Y * pthis,
pavolmarko@1
  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@1
  2797
    : BaseType(pthis, function_to_bind)  { }
pavolmarko@1
  2798
pavolmarko@1
  2799
  template < class X, class Y >
pavolmarko@1
  2800
  FastDelegate(const Y *pthis,
pavolmarko@1
  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@1
  2802
    : BaseType(pthis, function_to_bind)
pavolmarko@1
  2803
  {  }
pavolmarko@1
  2804
pavolmarko@1
  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@1
  2806
    : BaseType(function_to_bind)  { }
pavolmarko@123
  2807
  void operator = (const BaseType &x)  {
pavolmarko@1
  2808
		*static_cast<BaseType*>(this) = x; }
pavolmarko@1
  2809
};
pavolmarko@1
  2810
pavolmarko@1
  2811
//N=16
pavolmarko@1
  2812
// Specialization to allow use of
pavolmarko@1
  2813
// FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16 ) >
pavolmarko@1
  2814
// instead of
pavolmarko@1
  2815
// FastDelegate16 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, R >
pavolmarko@1
  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@1
  2817
class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16 ) >
pavolmarko@1
  2818
  // Inherit from FastDelegate16 so that it can be treated just
pavolmarko@1
  2819
  // like a FastDelegate16
pavolmarko@1
  2820
  : public FastDelegate16 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, R >
pavolmarko@1
  2821
{
pavolmarko@1
  2822
public:
pavolmarko@1
  2823
  // Make using the base type a bit easier via typedef.
pavolmarko@1
  2824
  typedef FastDelegate16 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, R > BaseType;
pavolmarko@1
  2825
pavolmarko@1
  2826
  // Allow users access to the specific type of this delegate.
pavolmarko@1
  2827
  typedef FastDelegate SelfType;
pavolmarko@1
  2828
pavolmarko@1
  2829
  // Mimic the base class constructors.
pavolmarko@1
  2830
  FastDelegate() : BaseType() { }
pavolmarko@1
  2831
pavolmarko@1
  2832
  template < class X, class Y >
pavolmarko@123
  2833
  FastDelegate(Y * pthis,
pavolmarko@1
  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@1
  2835
    : BaseType(pthis, function_to_bind)  { }
pavolmarko@1
  2836
pavolmarko@1
  2837
  template < class X, class Y >
pavolmarko@1
  2838
  FastDelegate(const Y *pthis,
pavolmarko@1
  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@1
  2840
    : BaseType(pthis, function_to_bind)
pavolmarko@1
  2841
  {  }
pavolmarko@1
  2842
pavolmarko@1
  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@1
  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@1
  2998
		*static_cast<BaseType*>(this) = x; }
pavolmarko@1
  2999
};
pavolmarko@1
  3000
pavolmarko@1
  3001
pavolmarko@1
  3002
#endif //FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX
pavolmarko@1
  3003
pavolmarko@1
  3004
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
  3005
//						Fast Delegates, part 5:
pavolmarko@1
  3006
//
pavolmarko@1
  3007
//				MakeDelegate() helper function
pavolmarko@1
  3008
//
pavolmarko@1
  3009
//			MakeDelegate(&x, &X::func) returns a fastdelegate of the type
pavolmarko@1
  3010
//			necessary for calling x.func() with the correct number of arguments.
pavolmarko@1
  3011
//			This makes it possible to eliminate many typedefs from user code.
pavolmarko@1
  3012
//
pavolmarko@1
  3013
////////////////////////////////////////////////////////////////////////////////
pavolmarko@1
  3014
pavolmarko@123
  3015
// Also declare overloads of a MakeDelegate() global function to
pavolmarko@1
  3016
// reduce the need for typedefs.
pavolmarko@1
  3017
// We need seperate overloads for const and non-const member functions.
pavolmarko@1
  3018
// Also, because of the weird rule about the class of derived member function pointers,
pavolmarko@1
  3019
// implicit downcasts may need to be applied later to the 'this' pointer.
pavolmarko@1
  3020
// That's why two classes (X and Y) appear in the definitions. Y must be implicitly
pavolmarko@1
  3021
// castable to X.
pavolmarko@1
  3022
pavolmarko@1
  3023
// Workaround for VC6. VC6 needs void return types converted into DefaultVoid.
pavolmarko@1
  3024
// GCC 3.2 and later won't compile this unless it's preceded by 'typename',
pavolmarko@1
  3025
// but VC6 doesn't allow 'typename' in this context.
pavolmarko@1
  3026
// So, I have to use a macro.
pavolmarko@1
  3027
pavolmarko@1
  3028
#ifdef FASTDLGT_VC6
pavolmarko@1
  3029
#define FASTDLGT_RETTYPE detail::VoidToDefaultVoid<RetType>::type
pavolmarko@123
  3030
#else
pavolmarko@1
  3031
#define FASTDLGT_RETTYPE RetType
pavolmarko@1
  3032
#endif
pavolmarko@1
  3033
pavolmarko@1
  3034
//N=0
pavolmarko@1
  3035
template <class X, class Y, class RetType>
pavolmarko@123
  3036
FastDelegate0<FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)()) {
pavolmarko@1
  3037
	return FastDelegate0<FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3038
}
pavolmarko@1
  3039
pavolmarko@1
  3040
template <class X, class Y, class RetType>
pavolmarko@123
  3041
FastDelegate0<FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)() const) {
pavolmarko@1
  3042
	return FastDelegate0<FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3043
}
pavolmarko@1
  3044
pavolmarko@45
  3045
template <class RetType>
pavolmarko@123
  3046
FastDelegate0<FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)()) {
pavolmarko@45
  3047
	return FastDelegate0<FASTDLGT_RETTYPE>(func);
pavolmarko@45
  3048
}
pavolmarko@45
  3049
pavolmarko@1
  3050
//N=1
pavolmarko@1
  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@1
  3053
	return FastDelegate1<Param1, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3054
}
pavolmarko@1
  3055
pavolmarko@1
  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@1
  3058
	return FastDelegate1<Param1, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3059
}
pavolmarko@1
  3060
pavolmarko@45
  3061
template <class Param1, class RetType>
pavolmarko@123
  3062
FastDelegate1<Param1, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(Param1 p1)) {
pavolmarko@45
  3063
	return FastDelegate1<Param1, FASTDLGT_RETTYPE>(func);
pavolmarko@45
  3064
}
pavolmarko@45
  3065
pavolmarko@1
  3066
//N=2
pavolmarko@1
  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@1
  3069
	return FastDelegate2<Param1, Param2, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3070
}
pavolmarko@1
  3071
pavolmarko@1
  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@1
  3074
	return FastDelegate2<Param1, Param2, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3075
}
pavolmarko@1
  3076
pavolmarko@45
  3077
template <class Param1, class Param2, class RetType>
pavolmarko@123
  3078
FastDelegate2<Param1, Param2, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(Param1 p1, Param2 p2)) {
pavolmarko@45
  3079
	return FastDelegate2<Param1, Param2, FASTDLGT_RETTYPE>(func);
pavolmarko@45
  3080
}
pavolmarko@45
  3081
pavolmarko@1
  3082
//N=3
pavolmarko@1
  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@1
  3085
	return FastDelegate3<Param1, Param2, Param3, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3086
}
pavolmarko@1
  3087
pavolmarko@1
  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@1
  3090
	return FastDelegate3<Param1, Param2, Param3, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3091
}
pavolmarko@1
  3092
pavolmarko@45
  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@45
  3095
	return FastDelegate3<Param1, Param2, Param3, FASTDLGT_RETTYPE>(func);
pavolmarko@45
  3096
}
pavolmarko@45
  3097
pavolmarko@1
  3098
//N=4
pavolmarko@1
  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@1
  3101
	return FastDelegate4<Param1, Param2, Param3, Param4, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3102
}
pavolmarko@1
  3103
pavolmarko@1
  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@1
  3106
	return FastDelegate4<Param1, Param2, Param3, Param4, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3107
}
pavolmarko@1
  3108
pavolmarko@45
  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@45
  3111
	return FastDelegate4<Param1, Param2, Param3, Param4, FASTDLGT_RETTYPE>(func);
pavolmarko@45
  3112
}
pavolmarko@45
  3113
pavolmarko@1
  3114
//N=5
pavolmarko@1
  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@1
  3117
	return FastDelegate5<Param1, Param2, Param3, Param4, Param5, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3118
}
pavolmarko@1
  3119
pavolmarko@1
  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@1
  3122
	return FastDelegate5<Param1, Param2, Param3, Param4, Param5, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3123
}
pavolmarko@1
  3124
pavolmarko@45
  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@45
  3127
	return FastDelegate5<Param1, Param2, Param3, Param4, Param5, FASTDLGT_RETTYPE>(func);
pavolmarko@45
  3128
}
pavolmarko@45
  3129
pavolmarko@1
  3130
//N=6
pavolmarko@1
  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@1
  3133
	return FastDelegate6<Param1, Param2, Param3, Param4, Param5, Param6, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3134
}
pavolmarko@1
  3135
pavolmarko@1
  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@1
  3138
	return FastDelegate6<Param1, Param2, Param3, Param4, Param5, Param6, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3139
}
pavolmarko@1
  3140
pavolmarko@45
  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@45
  3143
	return FastDelegate6<Param1, Param2, Param3, Param4, Param5, Param6, FASTDLGT_RETTYPE>(func);
pavolmarko@45
  3144
}
pavolmarko@45
  3145
pavolmarko@1
  3146
//N=7
pavolmarko@1
  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@1
  3149
	return FastDelegate7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3150
}
pavolmarko@1
  3151
pavolmarko@1
  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@1
  3154
	return FastDelegate7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3155
}
pavolmarko@1
  3156
pavolmarko@45
  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@45
  3159
	return FastDelegate7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, FASTDLGT_RETTYPE>(func);
pavolmarko@45
  3160
}
pavolmarko@45
  3161
pavolmarko@1
  3162
//N=8
pavolmarko@1
  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@1
  3165
	return FastDelegate8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3166
}
pavolmarko@1
  3167
pavolmarko@1
  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@1
  3170
	return FastDelegate8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3171
}
pavolmarko@1
  3172
pavolmarko@45
  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@45
  3175
	return FastDelegate8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, FASTDLGT_RETTYPE>(func);
pavolmarko@45
  3176
}
pavolmarko@45
  3177
pavolmarko@1
  3178
//N=9
pavolmarko@1
  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@1
  3181
	return FastDelegate9<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3182
}
pavolmarko@1
  3183
pavolmarko@1
  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@1
  3186
	return FastDelegate9<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3187
}
pavolmarko@1
  3188
pavolmarko@45
  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@45
  3191
	return FastDelegate9<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, FASTDLGT_RETTYPE>(func);
pavolmarko@45
  3192
}
pavolmarko@45
  3193
pavolmarko@1
  3194
//N=10
pavolmarko@1
  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@1
  3197
	return FastDelegate10<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3198
}
pavolmarko@1
  3199
pavolmarko@1
  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@1
  3202
	return FastDelegate10<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3203
}
pavolmarko@1
  3204
pavolmarko@45
  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@45
  3207
	return FastDelegate10<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, FASTDLGT_RETTYPE>(func);
pavolmarko@45
  3208
}
pavolmarko@45
  3209
pavolmarko@1
  3210
//N=11
pavolmarko@1
  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@1
  3213
	return FastDelegate11<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3214
}
pavolmarko@1
  3215
pavolmarko@1
  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@1
  3218
	return FastDelegate11<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3219
}
pavolmarko@1
  3220
pavolmarko@45
  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@45
  3223
	return FastDelegate11<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, FASTDLGT_RETTYPE>(func);
pavolmarko@45
  3224
}
pavolmarko@45
  3225
pavolmarko@1
  3226
//N=12
pavolmarko@1
  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@1
  3229
	return FastDelegate12<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3230
}
pavolmarko@1
  3231
pavolmarko@1
  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@1
  3234
	return FastDelegate12<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3235
}
pavolmarko@1
  3236
pavolmarko@45
  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@45
  3239
	return FastDelegate12<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, FASTDLGT_RETTYPE>(func);
pavolmarko@45
  3240
}
pavolmarko@45
  3241
pavolmarko@1
  3242
//N=13
pavolmarko@1
  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@1
  3245
	return FastDelegate13<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3246
}
pavolmarko@1
  3247
pavolmarko@1
  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@1
  3250
	return FastDelegate13<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3251
}
pavolmarko@1
  3252
pavolmarko@45
  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@45
  3255
	return FastDelegate13<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, FASTDLGT_RETTYPE>(func);
pavolmarko@45
  3256
}
pavolmarko@45
  3257
pavolmarko@1
  3258
//N=14
pavolmarko@1
  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@1
  3261
	return FastDelegate14<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3262
}
pavolmarko@1
  3263
pavolmarko@1
  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@1
  3266
	return FastDelegate14<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3267
}
pavolmarko@1
  3268
pavolmarko@45
  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@45
  3271
	return FastDelegate14<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, FASTDLGT_RETTYPE>(func);
pavolmarko@45
  3272
}
pavolmarko@45
  3273
pavolmarko@1
  3274
//N=15
pavolmarko@1
  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@1
  3277
	return FastDelegate15<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3278
}
pavolmarko@1
  3279
pavolmarko@1
  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@1
  3282
	return FastDelegate15<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3283
}
pavolmarko@1
  3284
pavolmarko@45
  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@45
  3287
	return FastDelegate15<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, FASTDLGT_RETTYPE>(func);
pavolmarko@45
  3288
}
pavolmarko@45
  3289
pavolmarko@1
  3290
//N=16
pavolmarko@1
  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@1
  3293
	return FastDelegate16<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3294
}
pavolmarko@1
  3295
pavolmarko@1
  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@1
  3298
	return FastDelegate16<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, FASTDLGT_RETTYPE>(x, func);
pavolmarko@1
  3299
}
pavolmarko@1
  3300
pavolmarko@45
  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@45
  3303
	return FastDelegate16<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, FASTDLGT_RETTYPE>(func);
pavolmarko@45
  3304
}
pavolmarko@45
  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@1
  3370
pavolmarko@1
  3371
 // clean up after ourselves...
pavolmarko@1
  3372
#undef FASTDLGT_RETTYPE
pavolmarko@1
  3373
pavolmarko@1
  3374
} // namespace fastdelegate
pavolmarko@1
  3375
pavolmarko@1
  3376
#endif // !defined(FASTDELEGATE_H)
pavolmarko@1
  3377