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