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