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