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