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