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