sourcehook/FastDelegate.h
changeset 134 a9e04855f582
parent 123 53e819ac032a
child 294 0d87bc8606f8
     1.1 --- a/sourcehook/FastDelegate.h	Fri Oct 14 17:45:36 2005 +0000
     1.2 +++ b/sourcehook/FastDelegate.h	Fri Oct 14 20:57:43 2005 +0000
     1.3 @@ -5,7 +5,7 @@
     1.4  //						- Don Clugston, Mar 2004.
     1.5  //		Major contributions were made by Jody Hagins.
     1.6  // History:
     1.7 -// 24-Apr-04 1.0  Submitted to CodeProject.
     1.8 +// 24-Apr-04 1.0  * Submitted to CodeProject.
     1.9  // 28-Apr-04 1.1  * Prevent most unsafe uses of evil static function hack.
    1.10  //				  * Improved syntax for horrible_cast (thanks Paul Bludov).
    1.11  //				  * Tested on Metrowerks MWCC and Intel ICL (IA32)
    1.12 @@ -30,14 +30,20 @@
    1.13  //				  * Less use of macros. Error messages should be more comprehensible.
    1.14  //				  * Added include guards
    1.15  //				  * Added FastDelegate::empty() to test if invocation is safe (Thanks Neville Franks).
    1.16 -//				  * Now tested on VS 2005 Beta, PGI C++
    1.17 +//				  * Now tested on VS 2005 Express Beta, PGI C++
    1.18  // 24-Dec-04 1.4  * Added DelegateMemento, to allow collections of disparate delegates.
    1.19  //                * <,>,<=,>= comparison operators to allow storage in ordered containers.
    1.20  //				  * Substantial reduction of code size, especially the 'Closure' class.
    1.21  //				  * Standardised all the compiler-specific workarounds.
    1.22  //                * MFP conversion now works for CodePlay (but not yet supported in the full code).
    1.23 -//                * Now compiles without warnings on _any_ compiler, including BCC 5.5.1
    1.24 +//                * Now compiles without warnings on _any_ supported compiler, including BCC 5.5.1
    1.25  //				  * New syntax: FastDelegate< int (char *, double) >.
    1.26 +// 14-Feb-05 1.4.1* Now treats =0 as equivalent to .clear(), ==0 as equivalent to .empty(). (Thanks elfric).
    1.27 +//				  * Now tested on Intel ICL for AMD64, VS2005 Beta for AMD64 and Itanium.
    1.28 +// 30-Mar-05 1.5  * Safebool idiom: "if (dg)" is now equivalent to "if (!dg.empty())"
    1.29 +//				  * Fully supported by CodePlay VectorC
    1.30 +//                * Bugfix for Metrowerks: empty() was buggy because a valid MFP can be 0 on MWCC!
    1.31 +//                * More optimal assignment,== and != operators for static function pointers.
    1.32  
    1.33  #ifndef FASTDELEGATE_H
    1.34  #define FASTDELEGATE_H
    1.35 @@ -531,8 +537,10 @@
    1.36  // +-- Static pointer --+--pThis --+-- pMemFunc-+-- Meaning------+
    1.37  // |   0				|  0       |   0        | Empty          |
    1.38  // |   !=0              |(dontcare)|  Invoker   | Static function|
    1.39 -// |   0                |  !=0     |  !=0       | Method call    |
    1.40 +// |   0                |  !=0     |  !=0*      | Method call    |
    1.41  // +--------------------+----------+------------+----------------+
    1.42 +//  * For Metrowerks, this can be 0. (first virtual function in a 
    1.43 +//       single_inheritance class).
    1.44  // When stored stored inside a specific delegate, the 'dontcare' entries are replaced
    1.45  // with a reference to the delegate itself. This complicates the = and == operators
    1.46  // for the delegate class.
    1.47 @@ -544,9 +552,11 @@
    1.48  // horrible_cast. In this case the DelegateMemento implementation is simple:
    1.49  // +--pThis --+-- pMemFunc-+-- Meaning---------------------+
    1.50  // |    0     |  0         | Empty                         |
    1.51 -// |  !=0     |  !=0       | Static function or method call|
    1.52 +// |  !=0     |  !=0*      | Static function or method call|
    1.53  // +----------+------------+-------------------------------+
    1.54 -// Note that the Sun C++ and MSVC documentation explicitly state that they
    1.55 +//  * For Metrowerks, this can be 0. (first virtual function in a 
    1.56 +//       single_inheritance class).
    1.57 +// Note that the Sun C++ and MSVC documentation explicitly state that they 
    1.58  // support static_cast between void * and function pointers.
    1.59  
    1.60  class DelegateMemento {
    1.61 @@ -570,9 +580,7 @@
    1.62  	}
    1.63  #else
    1.64  	DelegateMemento() : m_pthis(0), m_pFunction(0) {};
    1.65 -	void clear() {
    1.66 -		m_pthis=0; m_pFunction=0;
    1.67 -	}
    1.68 +	void clear() {	m_pthis=0; m_pFunction=0;	}
    1.69  #endif
    1.70  public:
    1.71  #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
    1.72 @@ -603,8 +611,13 @@
    1.73  		return memcmp(&m_pFunction, &right.m_pFunction, sizeof(m_pFunction)) < 0;
    1.74  
    1.75  	}
    1.76 +	// BUGFIX (Mar 2005):
    1.77 +	// We can't just compare m_pFunction because on Metrowerks,
    1.78 +	// m_pFunction can be zero even if the delegate is not empty!
    1.79  	inline bool operator ! () const		// Is it bound to anything?
    1.80 -	{ return m_pFunction==0; }
    1.81 +	{ return m_pthis==0 && m_pFunction==0; }
    1.82 +	inline bool empty() const		// Is it bound to anything?
    1.83 +	{ return m_pthis==0 && m_pFunction==0; }
    1.84  public:
    1.85  	DelegateMemento & operator = (const DelegateMemento &right)  {
    1.86  		SetMementoFrom(right);
    1.87 @@ -723,7 +736,11 @@
    1.88  	template < class DerivedClass, class ParentInvokerSig >
    1.89  	inline void bindstaticfunc(DerivedClass *pParent, ParentInvokerSig static_function_invoker,
    1.90  				StaticFuncPtr function_to_bind ) {
    1.91 -		bindmemfunc(pParent, static_function_invoker);
    1.92 +		if (function_to_bind==0) { // cope with assignment to 0
    1.93 +			m_pFunction=0;
    1.94 +		} else {
    1.95 +			bindmemfunc(pParent, static_function_invoker);
    1.96 +        }
    1.97  		m_pStaticFunction=reinterpret_cast<GenericFuncPtr>(function_to_bind);
    1.98  	}
    1.99  	inline UnvoidStaticFuncPtr GetStaticFunction() const {
   1.100 @@ -752,9 +769,13 @@
   1.101  	template < 	class DerivedClass, class ParentInvokerSig>
   1.102  	inline void bindstaticfunc(DerivedClass *pParent, ParentInvokerSig static_function_invoker,
   1.103  				StaticFuncPtr function_to_bind) {
   1.104 -		// We'll be ignoring the 'this' pointer, but we need to make sure we pass
   1.105 -		// a valid value to bindmemfunc().
   1.106 -		bindmemfunc(pParent, static_function_invoker);
   1.107 +		if (function_to_bind==0) { // cope with assignment to 0
   1.108 +			m_pFunction=0;
   1.109 +		} else { 
   1.110 +		   // We'll be ignoring the 'this' pointer, but we need to make sure we pass
   1.111 +		   // a valid value to bindmemfunc().
   1.112 +			bindmemfunc(pParent, static_function_invoker);
   1.113 +        }
   1.114  
   1.115  		// WARNING! Evil hack. We store the function in the 'this' pointer!
   1.116  		// Ensure that there's a compilation failure if function pointers
   1.117 @@ -780,6 +801,13 @@
   1.118  	}
   1.119  #endif // !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
   1.120  
   1.121 +	// Does the closure contain this static function?
   1.122 +	inline bool IsEqualToStaticFuncPtr(StaticFuncPtr funcptr){
   1.123 +		if (funcptr==0) return empty();
   1.124 +	// For the Evil method, if it doesn't actually contain a static function, this will return an arbitrary
   1.125 +	// value that is not equal to any valid function pointer.
   1.126 +		else return funcptr==reinterpret_cast<StaticFuncPtr>(GetStaticFunction());
   1.127 +	}
   1.128  };
   1.129  
   1.130  
   1.131 @@ -816,6 +844,14 @@
   1.132  // it cannot be void. DesiredRetType is the real type which is returned from
   1.133  // all of the functions. It can be void.
   1.134  
   1.135 +// Implicit conversion to "bool" is achieved using the safe_bool idiom,
   1.136 +// using member data pointers (MDP). This allows "if (dg)..." syntax
   1.137 +// Because some compilers (eg codeplay) don't have a unique value for a zero
   1.138 +// MDP, an extra padding member is added to the SafeBool struct.
   1.139 +// Some compilers (eg VC6) won't implicitly convert from 0 to an MDP, so
   1.140 +// in that case the static function constructor is not made explicit; this
   1.141 +// allows "if (dg==0) ..." to compile.
   1.142 +
   1.143  //N=0
   1.144  template<class RetType=detail::DefaultVoid>
   1.145  class FastDelegate0 {
   1.146 @@ -824,7 +860,8 @@
   1.147  	typedef DesiredRetType (*StaticFunctionPtr)();
   1.148  	typedef RetType (*UnvoidStaticFunctionPtr)();
   1.149  	typedef RetType (detail::GenericClass::*GenericMemFn)();
   1.150 -	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
   1.151 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   1.152 +	ClosureType m_Closure;
   1.153  public:
   1.154  	// Typedefs to aid generic programming
   1.155  	typedef FastDelegate0 type;
   1.156 @@ -858,15 +895,34 @@
   1.157  	inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)() const) {
   1.158  		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   1.159  	// Static functions. We convert them into a member function call.
   1.160 -	// Note that this also provides a conversion from static functions.
   1.161 +	// This constructor also provides implicit conversion
   1.162  	FastDelegate0(DesiredRetType (*function_to_bind)() ) {
   1.163  		bind(function_to_bind);	}
   1.164 +	// for efficiency, prevent creation of a temporary
   1.165 +	void operator = (DesiredRetType (*function_to_bind)() ) {
   1.166 +		bind(function_to_bind);	}
   1.167  	inline void bind(DesiredRetType (*function_to_bind)()) {
   1.168  		m_Closure.bindstaticfunc(this, &FastDelegate0::InvokeStaticFunction,
   1.169  			function_to_bind); }
   1.170 -	RetType operator() () const { // Invoke the delegate
   1.171 -		// this next line is the only one that violates the standard
   1.172 +	// Invoke the delegate
   1.173 +	RetType operator() () const {
   1.174  	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(); }
   1.175 +	// Implicit conversion to "bool" using the safe_bool idiom
   1.176 +private:
   1.177 +	typedef struct SafeBoolStruct {
   1.178 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   1.179 +		StaticFunctionPtr m_nonzero;
   1.180 +	} UselessTypedef;
   1.181 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   1.182 +public:
   1.183 +	operator unspecified_bool_type() const {
   1.184 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
   1.185 +    }
   1.186 +	// necessary to allow ==0 to work despite the safe_bool idiom
   1.187 +	inline bool operator==(StaticFunctionPtr funcptr) {
   1.188 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
   1.189 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
   1.190 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
   1.191  	inline bool operator ! () const	{	// Is it bound to anything?
   1.192  			return !m_Closure; }
   1.193  	inline bool empty() const	{
   1.194 @@ -889,7 +945,8 @@
   1.195  	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1);
   1.196  	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1);
   1.197  	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1);
   1.198 -	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
   1.199 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   1.200 +	ClosureType m_Closure;
   1.201  public:
   1.202  	// Typedefs to aid generic programming
   1.203  	typedef FastDelegate1 type;
   1.204 @@ -923,15 +980,34 @@
   1.205  	inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1) const) {
   1.206  		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   1.207  	// Static functions. We convert them into a member function call.
   1.208 -	// Note that this also provides a conversion from static functions.
   1.209 +	// This constructor also provides implicit conversion
   1.210  	FastDelegate1(DesiredRetType (*function_to_bind)(Param1 p1) ) {
   1.211  		bind(function_to_bind);	}
   1.212 +	// for efficiency, prevent creation of a temporary
   1.213 +	void operator = (DesiredRetType (*function_to_bind)(Param1 p1) ) {
   1.214 +		bind(function_to_bind);	}
   1.215  	inline void bind(DesiredRetType (*function_to_bind)(Param1 p1)) {
   1.216  		m_Closure.bindstaticfunc(this, &FastDelegate1::InvokeStaticFunction,
   1.217  			function_to_bind); }
   1.218 -	RetType operator() (Param1 p1) const { // Invoke the delegate
   1.219 -		// this next line is the only one that violates the standard
   1.220 +	// Invoke the delegate
   1.221 +	RetType operator() (Param1 p1) const {
   1.222  	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1); }
   1.223 +	// Implicit conversion to "bool" using the safe_bool idiom
   1.224 +private:
   1.225 +	typedef struct SafeBoolStruct {
   1.226 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   1.227 +		StaticFunctionPtr m_nonzero;
   1.228 +	} UselessTypedef;
   1.229 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   1.230 +public:
   1.231 +	operator unspecified_bool_type() const {
   1.232 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
   1.233 +    }
   1.234 +	// necessary to allow ==0 to work despite the safe_bool idiom
   1.235 +	inline bool operator==(StaticFunctionPtr funcptr) {
   1.236 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
   1.237 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
   1.238 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
   1.239  	inline bool operator ! () const	{	// Is it bound to anything?
   1.240  			return !m_Closure; }
   1.241  	inline bool empty() const	{
   1.242 @@ -954,7 +1030,8 @@
   1.243  	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2);
   1.244  	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2);
   1.245  	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2);
   1.246 -	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
   1.247 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   1.248 +	ClosureType m_Closure;
   1.249  public:
   1.250  	// Typedefs to aid generic programming
   1.251  	typedef FastDelegate2 type;
   1.252 @@ -988,15 +1065,34 @@
   1.253  	inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2) const) {
   1.254  		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   1.255  	// Static functions. We convert them into a member function call.
   1.256 -	// Note that this also provides a conversion from static functions.
   1.257 +	// This constructor also provides implicit conversion
   1.258  	FastDelegate2(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2) ) {
   1.259  		bind(function_to_bind);	}
   1.260 +	// for efficiency, prevent creation of a temporary
   1.261 +	void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2) ) {
   1.262 +		bind(function_to_bind);	}
   1.263  	inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2)) {
   1.264  		m_Closure.bindstaticfunc(this, &FastDelegate2::InvokeStaticFunction,
   1.265  			function_to_bind); }
   1.266 -	RetType operator() (Param1 p1, Param2 p2) const { // Invoke the delegate
   1.267 -		// this next line is the only one that violates the standard
   1.268 +	// Invoke the delegate
   1.269 +	RetType operator() (Param1 p1, Param2 p2) const {
   1.270  	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2); }
   1.271 +	// Implicit conversion to "bool" using the safe_bool idiom
   1.272 +private:
   1.273 +	typedef struct SafeBoolStruct {
   1.274 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   1.275 +		StaticFunctionPtr m_nonzero;
   1.276 +	} UselessTypedef;
   1.277 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   1.278 +public:
   1.279 +	operator unspecified_bool_type() const {
   1.280 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
   1.281 +    }
   1.282 +	// necessary to allow ==0 to work despite the safe_bool idiom
   1.283 +	inline bool operator==(StaticFunctionPtr funcptr) {
   1.284 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
   1.285 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
   1.286 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
   1.287  	inline bool operator ! () const	{	// Is it bound to anything?
   1.288  			return !m_Closure; }
   1.289  	inline bool empty() const	{
   1.290 @@ -1019,7 +1115,8 @@
   1.291  	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3);
   1.292  	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3);
   1.293  	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3);
   1.294 -	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
   1.295 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   1.296 +	ClosureType m_Closure;
   1.297  public:
   1.298  	// Typedefs to aid generic programming
   1.299  	typedef FastDelegate3 type;
   1.300 @@ -1053,15 +1150,34 @@
   1.301  	inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3) const) {
   1.302  		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   1.303  	// Static functions. We convert them into a member function call.
   1.304 -	// Note that this also provides a conversion from static functions.
   1.305 +	// This constructor also provides implicit conversion
   1.306  	FastDelegate3(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3) ) {
   1.307  		bind(function_to_bind);	}
   1.308 +	// for efficiency, prevent creation of a temporary
   1.309 +	void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3) ) {
   1.310 +		bind(function_to_bind);	}
   1.311  	inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3)) {
   1.312  		m_Closure.bindstaticfunc(this, &FastDelegate3::InvokeStaticFunction,
   1.313  			function_to_bind); }
   1.314 -	RetType operator() (Param1 p1, Param2 p2, Param3 p3) const { // Invoke the delegate
   1.315 -		// this next line is the only one that violates the standard
   1.316 +	// Invoke the delegate
   1.317 +	RetType operator() (Param1 p1, Param2 p2, Param3 p3) const {
   1.318  	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3); }
   1.319 +	// Implicit conversion to "bool" using the safe_bool idiom
   1.320 +private:
   1.321 +	typedef struct SafeBoolStruct {
   1.322 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   1.323 +		StaticFunctionPtr m_nonzero;
   1.324 +	} UselessTypedef;
   1.325 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   1.326 +public:
   1.327 +	operator unspecified_bool_type() const {
   1.328 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
   1.329 +    }
   1.330 +	// necessary to allow ==0 to work despite the safe_bool idiom
   1.331 +	inline bool operator==(StaticFunctionPtr funcptr) {
   1.332 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
   1.333 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
   1.334 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
   1.335  	inline bool operator ! () const	{	// Is it bound to anything?
   1.336  			return !m_Closure; }
   1.337  	inline bool empty() const	{
   1.338 @@ -1084,7 +1200,8 @@
   1.339  	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4);
   1.340  	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4);
   1.341  	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4);
   1.342 -	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
   1.343 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   1.344 +	ClosureType m_Closure;
   1.345  public:
   1.346  	// Typedefs to aid generic programming
   1.347  	typedef FastDelegate4 type;
   1.348 @@ -1118,15 +1235,34 @@
   1.349  	inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const) {
   1.350  		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   1.351  	// Static functions. We convert them into a member function call.
   1.352 -	// Note that this also provides a conversion from static functions.
   1.353 +	// This constructor also provides implicit conversion
   1.354  	FastDelegate4(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4) ) {
   1.355  		bind(function_to_bind);	}
   1.356 +	// for efficiency, prevent creation of a temporary
   1.357 +	void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4) ) {
   1.358 +		bind(function_to_bind);	}
   1.359  	inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4)) {
   1.360  		m_Closure.bindstaticfunc(this, &FastDelegate4::InvokeStaticFunction,
   1.361  			function_to_bind); }
   1.362 -	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4) const { // Invoke the delegate
   1.363 -		// this next line is the only one that violates the standard
   1.364 +	// Invoke the delegate
   1.365 +	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4) const {
   1.366  	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4); }
   1.367 +	// Implicit conversion to "bool" using the safe_bool idiom
   1.368 +private:
   1.369 +	typedef struct SafeBoolStruct {
   1.370 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   1.371 +		StaticFunctionPtr m_nonzero;
   1.372 +	} UselessTypedef;
   1.373 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   1.374 +public:
   1.375 +	operator unspecified_bool_type() const {
   1.376 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
   1.377 +    }
   1.378 +	// necessary to allow ==0 to work despite the safe_bool idiom
   1.379 +	inline bool operator==(StaticFunctionPtr funcptr) {
   1.380 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
   1.381 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
   1.382 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
   1.383  	inline bool operator ! () const	{	// Is it bound to anything?
   1.384  			return !m_Closure; }
   1.385  	inline bool empty() const	{
   1.386 @@ -1149,7 +1285,8 @@
   1.387  	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5);
   1.388  	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5);
   1.389  	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5);
   1.390 -	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
   1.391 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   1.392 +	ClosureType m_Closure;
   1.393  public:
   1.394  	// Typedefs to aid generic programming
   1.395  	typedef FastDelegate5 type;
   1.396 @@ -1183,15 +1320,34 @@
   1.397  	inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const) {
   1.398  		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   1.399  	// Static functions. We convert them into a member function call.
   1.400 -	// Note that this also provides a conversion from static functions.
   1.401 +	// This constructor also provides implicit conversion
   1.402  	FastDelegate5(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) ) {
   1.403  		bind(function_to_bind);	}
   1.404 +	// for efficiency, prevent creation of a temporary
   1.405 +	void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) ) {
   1.406 +		bind(function_to_bind);	}
   1.407  	inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5)) {
   1.408  		m_Closure.bindstaticfunc(this, &FastDelegate5::InvokeStaticFunction,
   1.409  			function_to_bind); }
   1.410 -	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const { // Invoke the delegate
   1.411 -		// this next line is the only one that violates the standard
   1.412 +	// Invoke the delegate
   1.413 +	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const {
   1.414  	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5); }
   1.415 +	// Implicit conversion to "bool" using the safe_bool idiom
   1.416 +private:
   1.417 +	typedef struct SafeBoolStruct {
   1.418 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   1.419 +		StaticFunctionPtr m_nonzero;
   1.420 +	} UselessTypedef;
   1.421 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   1.422 +public:
   1.423 +	operator unspecified_bool_type() const {
   1.424 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
   1.425 +    }
   1.426 +	// necessary to allow ==0 to work despite the safe_bool idiom
   1.427 +	inline bool operator==(StaticFunctionPtr funcptr) {
   1.428 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
   1.429 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
   1.430 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
   1.431  	inline bool operator ! () const	{	// Is it bound to anything?
   1.432  			return !m_Closure; }
   1.433  	inline bool empty() const	{
   1.434 @@ -1214,7 +1370,8 @@
   1.435  	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6);
   1.436  	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6);
   1.437  	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6);
   1.438 -	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
   1.439 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   1.440 +	ClosureType m_Closure;
   1.441  public:
   1.442  	// Typedefs to aid generic programming
   1.443  	typedef FastDelegate6 type;
   1.444 @@ -1248,15 +1405,34 @@
   1.445  	inline void bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const) {
   1.446  		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   1.447  	// Static functions. We convert them into a member function call.
   1.448 -	// Note that this also provides a conversion from static functions.
   1.449 +	// This constructor also provides implicit conversion
   1.450  	FastDelegate6(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) ) {
   1.451  		bind(function_to_bind);	}
   1.452 +	// for efficiency, prevent creation of a temporary
   1.453 +	void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) ) {
   1.454 +		bind(function_to_bind);	}
   1.455  	inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6)) {
   1.456  		m_Closure.bindstaticfunc(this, &FastDelegate6::InvokeStaticFunction,
   1.457  			function_to_bind); }
   1.458 -	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const { // Invoke the delegate
   1.459 -		// this next line is the only one that violates the standard
   1.460 +	// Invoke the delegate
   1.461 +	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const {
   1.462  	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6); }
   1.463 +	// Implicit conversion to "bool" using the safe_bool idiom
   1.464 +private:
   1.465 +	typedef struct SafeBoolStruct {
   1.466 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   1.467 +		StaticFunctionPtr m_nonzero;
   1.468 +	} UselessTypedef;
   1.469 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   1.470 +public:
   1.471 +	operator unspecified_bool_type() const {
   1.472 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
   1.473 +    }
   1.474 +	// necessary to allow ==0 to work despite the safe_bool idiom
   1.475 +	inline bool operator==(StaticFunctionPtr funcptr) {
   1.476 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
   1.477 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
   1.478 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
   1.479  	inline bool operator ! () const	{	// Is it bound to anything?
   1.480  			return !m_Closure; }
   1.481  	inline bool empty() const	{
   1.482 @@ -1279,7 +1455,8 @@
   1.483  	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7);
   1.484  	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7);
   1.485  	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7);
   1.486 -	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
   1.487 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   1.488 +	ClosureType m_Closure;
   1.489  public:
   1.490  	// Typedefs to aid generic programming
   1.491  	typedef FastDelegate7 type;
   1.492 @@ -1313,15 +1490,34 @@
   1.493  	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) {
   1.494  		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   1.495  	// Static functions. We convert them into a member function call.
   1.496 -	// Note that this also provides a conversion from static functions.
   1.497 +	// This constructor also provides implicit conversion
   1.498  	FastDelegate7(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) ) {
   1.499  		bind(function_to_bind);	}
   1.500 +	// for efficiency, prevent creation of a temporary
   1.501 +	void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) ) {
   1.502 +		bind(function_to_bind);	}
   1.503  	inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7)) {
   1.504  		m_Closure.bindstaticfunc(this, &FastDelegate7::InvokeStaticFunction,
   1.505  			function_to_bind); }
   1.506 -	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const { // Invoke the delegate
   1.507 -		// this next line is the only one that violates the standard
   1.508 +	// Invoke the delegate
   1.509 +	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const {
   1.510  	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7); }
   1.511 +	// Implicit conversion to "bool" using the safe_bool idiom
   1.512 +private:
   1.513 +	typedef struct SafeBoolStruct {
   1.514 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   1.515 +		StaticFunctionPtr m_nonzero;
   1.516 +	} UselessTypedef;
   1.517 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   1.518 +public:
   1.519 +	operator unspecified_bool_type() const {
   1.520 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
   1.521 +    }
   1.522 +	// necessary to allow ==0 to work despite the safe_bool idiom
   1.523 +	inline bool operator==(StaticFunctionPtr funcptr) {
   1.524 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
   1.525 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
   1.526 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
   1.527  	inline bool operator ! () const	{	// Is it bound to anything?
   1.528  			return !m_Closure; }
   1.529  	inline bool empty() const	{
   1.530 @@ -1344,7 +1540,8 @@
   1.531  	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8);
   1.532  	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8);
   1.533  	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8);
   1.534 -	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
   1.535 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   1.536 +	ClosureType m_Closure;
   1.537  public:
   1.538  	// Typedefs to aid generic programming
   1.539  	typedef FastDelegate8 type;
   1.540 @@ -1378,15 +1575,34 @@
   1.541  	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) {
   1.542  		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   1.543  	// Static functions. We convert them into a member function call.
   1.544 -	// Note that this also provides a conversion from static functions.
   1.545 +	// This constructor also provides implicit conversion
   1.546  	FastDelegate8(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) ) {
   1.547  		bind(function_to_bind);	}
   1.548 +	// for efficiency, prevent creation of a temporary
   1.549 +	void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) ) {
   1.550 +		bind(function_to_bind);	}
   1.551  	inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8)) {
   1.552  		m_Closure.bindstaticfunc(this, &FastDelegate8::InvokeStaticFunction,
   1.553  			function_to_bind); }
   1.554 -	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) const { // Invoke the delegate
   1.555 -		// this next line is the only one that violates the standard
   1.556 +	// Invoke the delegate
   1.557 +	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) const {
   1.558  	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8); }
   1.559 +	// Implicit conversion to "bool" using the safe_bool idiom
   1.560 +private:
   1.561 +	typedef struct SafeBoolStruct {
   1.562 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   1.563 +		StaticFunctionPtr m_nonzero;
   1.564 +	} UselessTypedef;
   1.565 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   1.566 +public:
   1.567 +	operator unspecified_bool_type() const {
   1.568 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
   1.569 +    }
   1.570 +	// necessary to allow ==0 to work despite the safe_bool idiom
   1.571 +	inline bool operator==(StaticFunctionPtr funcptr) {
   1.572 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
   1.573 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
   1.574 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
   1.575  	inline bool operator ! () const	{	// Is it bound to anything?
   1.576  			return !m_Closure; }
   1.577  	inline bool empty() const	{
   1.578 @@ -1409,7 +1625,8 @@
   1.579  	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9);
   1.580  	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9);
   1.581  	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9);
   1.582 -	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
   1.583 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   1.584 +	ClosureType m_Closure;
   1.585  public:
   1.586  	// Typedefs to aid generic programming
   1.587  	typedef FastDelegate9 type;
   1.588 @@ -1443,15 +1660,34 @@
   1.589  	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) {
   1.590  		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   1.591  	// Static functions. We convert them into a member function call.
   1.592 -	// Note that this also provides a conversion from static functions.
   1.593 +	// This constructor also provides implicit conversion
   1.594  	FastDelegate9(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9) ) {
   1.595  		bind(function_to_bind);	}
   1.596 +	// for efficiency, prevent creation of a temporary
   1.597 +	void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9) ) {
   1.598 +		bind(function_to_bind);	}
   1.599  	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)) {
   1.600  		m_Closure.bindstaticfunc(this, &FastDelegate9::InvokeStaticFunction,
   1.601  			function_to_bind); }
   1.602 -	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9) const { // Invoke the delegate
   1.603 -		// this next line is the only one that violates the standard
   1.604 +	// Invoke the delegate
   1.605 +	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9) const {
   1.606  	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9); }
   1.607 +	// Implicit conversion to "bool" using the safe_bool idiom
   1.608 +private:
   1.609 +	typedef struct SafeBoolStruct {
   1.610 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   1.611 +		StaticFunctionPtr m_nonzero;
   1.612 +	} UselessTypedef;
   1.613 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   1.614 +public:
   1.615 +	operator unspecified_bool_type() const {
   1.616 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
   1.617 +    }
   1.618 +	// necessary to allow ==0 to work despite the safe_bool idiom
   1.619 +	inline bool operator==(StaticFunctionPtr funcptr) {
   1.620 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
   1.621 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
   1.622 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
   1.623  	inline bool operator ! () const	{	// Is it bound to anything?
   1.624  			return !m_Closure; }
   1.625  	inline bool empty() const	{
   1.626 @@ -1474,7 +1710,8 @@
   1.627  	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10);
   1.628  	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10);
   1.629  	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);
   1.630 -	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
   1.631 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   1.632 +	ClosureType m_Closure;
   1.633  public:
   1.634  	// Typedefs to aid generic programming
   1.635  	typedef FastDelegate10 type;
   1.636 @@ -1508,15 +1745,34 @@
   1.637  	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) {
   1.638  		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   1.639  	// Static functions. We convert them into a member function call.
   1.640 -	// Note that this also provides a conversion from static functions.
   1.641 +	// This constructor also provides implicit conversion
   1.642  	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) ) {
   1.643  		bind(function_to_bind);	}
   1.644 +	// for efficiency, prevent creation of a temporary
   1.645 +	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) ) {
   1.646 +		bind(function_to_bind);	}
   1.647  	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)) {
   1.648  		m_Closure.bindstaticfunc(this, &FastDelegate10::InvokeStaticFunction,
   1.649  			function_to_bind); }
   1.650 -	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10) const { // Invoke the delegate
   1.651 -		// this next line is the only one that violates the standard
   1.652 +	// Invoke the delegate
   1.653 +	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10) const {
   1.654  	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); }
   1.655 +	// Implicit conversion to "bool" using the safe_bool idiom
   1.656 +private:
   1.657 +	typedef struct SafeBoolStruct {
   1.658 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   1.659 +		StaticFunctionPtr m_nonzero;
   1.660 +	} UselessTypedef;
   1.661 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   1.662 +public:
   1.663 +	operator unspecified_bool_type() const {
   1.664 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
   1.665 +    }
   1.666 +	// necessary to allow ==0 to work despite the safe_bool idiom
   1.667 +	inline bool operator==(StaticFunctionPtr funcptr) {
   1.668 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
   1.669 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
   1.670 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
   1.671  	inline bool operator ! () const	{	// Is it bound to anything?
   1.672  			return !m_Closure; }
   1.673  	inline bool empty() const	{
   1.674 @@ -1539,7 +1795,8 @@
   1.675  	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);
   1.676  	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);
   1.677  	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);
   1.678 -	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
   1.679 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   1.680 +	ClosureType m_Closure;
   1.681  public:
   1.682  	// Typedefs to aid generic programming
   1.683  	typedef FastDelegate11 type;
   1.684 @@ -1573,15 +1830,34 @@
   1.685  	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) {
   1.686  		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   1.687  	// Static functions. We convert them into a member function call.
   1.688 -	// Note that this also provides a conversion from static functions.
   1.689 +	// This constructor also provides implicit conversion
   1.690  	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) ) {
   1.691  		bind(function_to_bind);	}
   1.692 +	// for efficiency, prevent creation of a temporary
   1.693 +	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) ) {
   1.694 +		bind(function_to_bind);	}
   1.695  	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)) {
   1.696  		m_Closure.bindstaticfunc(this, &FastDelegate11::InvokeStaticFunction,
   1.697  			function_to_bind); }
   1.698 -	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11) const { // Invoke the delegate
   1.699 -		// this next line is the only one that violates the standard
   1.700 +	// Invoke the delegate
   1.701 +	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 {
   1.702  	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); }
   1.703 +	// Implicit conversion to "bool" using the safe_bool idiom
   1.704 +private:
   1.705 +	typedef struct SafeBoolStruct {
   1.706 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   1.707 +		StaticFunctionPtr m_nonzero;
   1.708 +	} UselessTypedef;
   1.709 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   1.710 +public:
   1.711 +	operator unspecified_bool_type() const {
   1.712 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
   1.713 +    }
   1.714 +	// necessary to allow ==0 to work despite the safe_bool idiom
   1.715 +	inline bool operator==(StaticFunctionPtr funcptr) {
   1.716 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
   1.717 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
   1.718 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
   1.719  	inline bool operator ! () const	{	// Is it bound to anything?
   1.720  			return !m_Closure; }
   1.721  	inline bool empty() const	{
   1.722 @@ -1604,7 +1880,8 @@
   1.723  	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);
   1.724  	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);
   1.725  	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);
   1.726 -	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
   1.727 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   1.728 +	ClosureType m_Closure;
   1.729  public:
   1.730  	// Typedefs to aid generic programming
   1.731  	typedef FastDelegate12 type;
   1.732 @@ -1638,15 +1915,34 @@
   1.733  	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) {
   1.734  		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   1.735  	// Static functions. We convert them into a member function call.
   1.736 -	// Note that this also provides a conversion from static functions.
   1.737 +	// This constructor also provides implicit conversion
   1.738  	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) ) {
   1.739  		bind(function_to_bind);	}
   1.740 +	// for efficiency, prevent creation of a temporary
   1.741 +	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) ) {
   1.742 +		bind(function_to_bind);	}
   1.743  	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)) {
   1.744  		m_Closure.bindstaticfunc(this, &FastDelegate12::InvokeStaticFunction,
   1.745  			function_to_bind); }
   1.746 -	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12) const { // Invoke the delegate
   1.747 -		// this next line is the only one that violates the standard
   1.748 +	// Invoke the delegate
   1.749 +	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 {
   1.750  	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); }
   1.751 +	// Implicit conversion to "bool" using the safe_bool idiom
   1.752 +private:
   1.753 +	typedef struct SafeBoolStruct {
   1.754 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   1.755 +		StaticFunctionPtr m_nonzero;
   1.756 +	} UselessTypedef;
   1.757 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   1.758 +public:
   1.759 +	operator unspecified_bool_type() const {
   1.760 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
   1.761 +    }
   1.762 +	// necessary to allow ==0 to work despite the safe_bool idiom
   1.763 +	inline bool operator==(StaticFunctionPtr funcptr) {
   1.764 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
   1.765 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
   1.766 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
   1.767  	inline bool operator ! () const	{	// Is it bound to anything?
   1.768  			return !m_Closure; }
   1.769  	inline bool empty() const	{
   1.770 @@ -1669,7 +1965,8 @@
   1.771  	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);
   1.772  	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);
   1.773  	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);
   1.774 -	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
   1.775 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   1.776 +	ClosureType m_Closure;
   1.777  public:
   1.778  	// Typedefs to aid generic programming
   1.779  	typedef FastDelegate13 type;
   1.780 @@ -1703,15 +2000,34 @@
   1.781  	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) {
   1.782  		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   1.783  	// Static functions. We convert them into a member function call.
   1.784 -	// Note that this also provides a conversion from static functions.
   1.785 +	// This constructor also provides implicit conversion
   1.786  	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) ) {
   1.787  		bind(function_to_bind);	}
   1.788 +	// for efficiency, prevent creation of a temporary
   1.789 +	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) ) {
   1.790 +		bind(function_to_bind);	}
   1.791  	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)) {
   1.792  		m_Closure.bindstaticfunc(this, &FastDelegate13::InvokeStaticFunction,
   1.793  			function_to_bind); }
   1.794 -	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13) const { // Invoke the delegate
   1.795 -		// this next line is the only one that violates the standard
   1.796 +	// Invoke the delegate
   1.797 +	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 {
   1.798  	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); }
   1.799 +	// Implicit conversion to "bool" using the safe_bool idiom
   1.800 +private:
   1.801 +	typedef struct SafeBoolStruct {
   1.802 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   1.803 +		StaticFunctionPtr m_nonzero;
   1.804 +	} UselessTypedef;
   1.805 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   1.806 +public:
   1.807 +	operator unspecified_bool_type() const {
   1.808 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
   1.809 +    }
   1.810 +	// necessary to allow ==0 to work despite the safe_bool idiom
   1.811 +	inline bool operator==(StaticFunctionPtr funcptr) {
   1.812 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
   1.813 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
   1.814 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
   1.815  	inline bool operator ! () const	{	// Is it bound to anything?
   1.816  			return !m_Closure; }
   1.817  	inline bool empty() const	{
   1.818 @@ -1734,7 +2050,8 @@
   1.819  	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);
   1.820  	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);
   1.821  	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);
   1.822 -	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
   1.823 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   1.824 +	ClosureType m_Closure;
   1.825  public:
   1.826  	// Typedefs to aid generic programming
   1.827  	typedef FastDelegate14 type;
   1.828 @@ -1768,15 +2085,34 @@
   1.829  	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) {
   1.830  		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   1.831  	// Static functions. We convert them into a member function call.
   1.832 -	// Note that this also provides a conversion from static functions.
   1.833 +	// This constructor also provides implicit conversion
   1.834  	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) ) {
   1.835  		bind(function_to_bind);	}
   1.836 +	// for efficiency, prevent creation of a temporary
   1.837 +	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) ) {
   1.838 +		bind(function_to_bind);	}
   1.839  	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)) {
   1.840  		m_Closure.bindstaticfunc(this, &FastDelegate14::InvokeStaticFunction,
   1.841  			function_to_bind); }
   1.842 -	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14) const { // Invoke the delegate
   1.843 -		// this next line is the only one that violates the standard
   1.844 +	// Invoke the delegate
   1.845 +	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 {
   1.846  	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); }
   1.847 +	// Implicit conversion to "bool" using the safe_bool idiom
   1.848 +private:
   1.849 +	typedef struct SafeBoolStruct {
   1.850 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   1.851 +		StaticFunctionPtr m_nonzero;
   1.852 +	} UselessTypedef;
   1.853 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   1.854 +public:
   1.855 +	operator unspecified_bool_type() const {
   1.856 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
   1.857 +    }
   1.858 +	// necessary to allow ==0 to work despite the safe_bool idiom
   1.859 +	inline bool operator==(StaticFunctionPtr funcptr) {
   1.860 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
   1.861 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
   1.862 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
   1.863  	inline bool operator ! () const	{	// Is it bound to anything?
   1.864  			return !m_Closure; }
   1.865  	inline bool empty() const	{
   1.866 @@ -1799,7 +2135,8 @@
   1.867  	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);
   1.868  	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);
   1.869  	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);
   1.870 -	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
   1.871 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   1.872 +	ClosureType m_Closure;
   1.873  public:
   1.874  	// Typedefs to aid generic programming
   1.875  	typedef FastDelegate15 type;
   1.876 @@ -1833,15 +2170,34 @@
   1.877  	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) {
   1.878  		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   1.879  	// Static functions. We convert them into a member function call.
   1.880 -	// Note that this also provides a conversion from static functions.
   1.881 +	// This constructor also provides implicit conversion
   1.882  	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) ) {
   1.883  		bind(function_to_bind);	}
   1.884 +	// for efficiency, prevent creation of a temporary
   1.885 +	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) ) {
   1.886 +		bind(function_to_bind);	}
   1.887  	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)) {
   1.888  		m_Closure.bindstaticfunc(this, &FastDelegate15::InvokeStaticFunction,
   1.889  			function_to_bind); }
   1.890 -	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15) const { // Invoke the delegate
   1.891 -		// this next line is the only one that violates the standard
   1.892 +	// Invoke the delegate
   1.893 +	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 {
   1.894  	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); }
   1.895 +	// Implicit conversion to "bool" using the safe_bool idiom
   1.896 +private:
   1.897 +	typedef struct SafeBoolStruct {
   1.898 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   1.899 +		StaticFunctionPtr m_nonzero;
   1.900 +	} UselessTypedef;
   1.901 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   1.902 +public:
   1.903 +	operator unspecified_bool_type() const {
   1.904 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
   1.905 +    }
   1.906 +	// necessary to allow ==0 to work despite the safe_bool idiom
   1.907 +	inline bool operator==(StaticFunctionPtr funcptr) {
   1.908 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
   1.909 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
   1.910 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
   1.911  	inline bool operator ! () const	{	// Is it bound to anything?
   1.912  			return !m_Closure; }
   1.913  	inline bool empty() const	{
   1.914 @@ -1864,7 +2220,8 @@
   1.915  	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);
   1.916  	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);
   1.917  	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);
   1.918 -	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
   1.919 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   1.920 +	ClosureType m_Closure;
   1.921  public:
   1.922  	// Typedefs to aid generic programming
   1.923  	typedef FastDelegate16 type;
   1.924 @@ -1898,15 +2255,34 @@
   1.925  	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) {
   1.926  		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   1.927  	// Static functions. We convert them into a member function call.
   1.928 -	// Note that this also provides a conversion from static functions.
   1.929 +	// This constructor also provides implicit conversion
   1.930  	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) ) {
   1.931  		bind(function_to_bind);	}
   1.932 +	// for efficiency, prevent creation of a temporary
   1.933 +	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) ) {
   1.934 +		bind(function_to_bind);	}
   1.935  	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)) {
   1.936  		m_Closure.bindstaticfunc(this, &FastDelegate16::InvokeStaticFunction,
   1.937  			function_to_bind); }
   1.938 -	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16) const { // Invoke the delegate
   1.939 -		// this next line is the only one that violates the standard
   1.940 +	// Invoke the delegate
   1.941 +	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 {
   1.942  	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16); }
   1.943 +	// Implicit conversion to "bool" using the safe_bool idiom
   1.944 +private:
   1.945 +	typedef struct SafeBoolStruct {
   1.946 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   1.947 +		StaticFunctionPtr m_nonzero;
   1.948 +	} UselessTypedef;
   1.949 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   1.950 +public:
   1.951 +	operator unspecified_bool_type() const {
   1.952 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
   1.953 +    }
   1.954 +	// necessary to allow ==0 to work despite the safe_bool idiom
   1.955 +	inline bool operator==(StaticFunctionPtr funcptr) {
   1.956 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
   1.957 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
   1.958 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
   1.959  	inline bool operator ! () const	{	// Is it bound to anything?
   1.960  			return !m_Closure; }
   1.961  	inline bool empty() const	{
   1.962 @@ -1929,7 +2305,8 @@
   1.963  	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, Param17 p17);
   1.964  	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, Param17 p17);
   1.965  	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, Param17 p17);
   1.966 -	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
   1.967 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   1.968 +	ClosureType m_Closure;
   1.969  public:
   1.970  	// Typedefs to aid generic programming
   1.971  	typedef FastDelegate17 type;
   1.972 @@ -1963,15 +2340,34 @@
   1.973  	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, Param17 p17) const) {
   1.974  		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   1.975  	// Static functions. We convert them into a member function call.
   1.976 -	// Note that this also provides a conversion from static functions.
   1.977 +	// This constructor also provides implicit conversion
   1.978  	FastDelegate17(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, Param17 p17) ) {
   1.979  		bind(function_to_bind);	}
   1.980 +	// for efficiency, prevent creation of a temporary
   1.981 +	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, Param17 p17) ) {
   1.982 +		bind(function_to_bind);	}
   1.983  	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, Param17 p17)) {
   1.984  		m_Closure.bindstaticfunc(this, &FastDelegate17::InvokeStaticFunction,
   1.985  			function_to_bind); }
   1.986 -	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, Param17 p17) const { // Invoke the delegate
   1.987 -		// this next line is the only one that violates the standard
   1.988 +	// Invoke the delegate
   1.989 +	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, Param17 p17) const {
   1.990  	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17); }
   1.991 +	// Implicit conversion to "bool" using the safe_bool idiom
   1.992 +private:
   1.993 +	typedef struct SafeBoolStruct {
   1.994 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   1.995 +		StaticFunctionPtr m_nonzero;
   1.996 +	} UselessTypedef;
   1.997 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   1.998 +public:
   1.999 +	operator unspecified_bool_type() const {
  1.1000 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
  1.1001 +    }
  1.1002 +	// necessary to allow ==0 to work despite the safe_bool idiom
  1.1003 +	inline bool operator==(StaticFunctionPtr funcptr) {
  1.1004 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
  1.1005 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
  1.1006 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
  1.1007  	inline bool operator ! () const	{	// Is it bound to anything?
  1.1008  			return !m_Closure; }
  1.1009  	inline bool empty() const	{
  1.1010 @@ -1994,7 +2390,8 @@
  1.1011  	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, Param17 p17, Param18 p18);
  1.1012  	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, Param17 p17, Param18 p18);
  1.1013  	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, Param17 p17, Param18 p18);
  1.1014 -	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
  1.1015 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
  1.1016 +	ClosureType m_Closure;
  1.1017  public:
  1.1018  	// Typedefs to aid generic programming
  1.1019  	typedef FastDelegate18 type;
  1.1020 @@ -2028,15 +2425,34 @@
  1.1021  	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, Param17 p17, Param18 p18) const) {
  1.1022  		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
  1.1023  	// Static functions. We convert them into a member function call.
  1.1024 -	// Note that this also provides a conversion from static functions.
  1.1025 +	// This constructor also provides implicit conversion
  1.1026  	FastDelegate18(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, Param17 p17, Param18 p18) ) {
  1.1027  		bind(function_to_bind);	}
  1.1028 +	// for efficiency, prevent creation of a temporary
  1.1029 +	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, Param17 p17, Param18 p18) ) {
  1.1030 +		bind(function_to_bind);	}
  1.1031  	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, Param17 p17, Param18 p18)) {
  1.1032  		m_Closure.bindstaticfunc(this, &FastDelegate18::InvokeStaticFunction,
  1.1033  			function_to_bind); }
  1.1034 -	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, Param17 p17, Param18 p18) const { // Invoke the delegate
  1.1035 -		// this next line is the only one that violates the standard
  1.1036 +	// Invoke the delegate
  1.1037 +	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, Param17 p17, Param18 p18) const {
  1.1038  	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18); }
  1.1039 +	// Implicit conversion to "bool" using the safe_bool idiom
  1.1040 +private:
  1.1041 +	typedef struct SafeBoolStruct {
  1.1042 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
  1.1043 +		StaticFunctionPtr m_nonzero;
  1.1044 +	} UselessTypedef;
  1.1045 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  1.1046 +public:
  1.1047 +	operator unspecified_bool_type() const {
  1.1048 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
  1.1049 +    }
  1.1050 +	// necessary to allow ==0 to work despite the safe_bool idiom
  1.1051 +	inline bool operator==(StaticFunctionPtr funcptr) {
  1.1052 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
  1.1053 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
  1.1054 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
  1.1055  	inline bool operator ! () const	{	// Is it bound to anything?
  1.1056  			return !m_Closure; }
  1.1057  	inline bool empty() const	{
  1.1058 @@ -2059,7 +2475,8 @@
  1.1059  	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, Param17 p17, Param18 p18, Param19 p19);
  1.1060  	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, Param17 p17, Param18 p18, Param19 p19);
  1.1061  	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, Param17 p17, Param18 p18, Param19 p19);
  1.1062 -	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
  1.1063 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
  1.1064 +	ClosureType m_Closure;
  1.1065  public:
  1.1066  	// Typedefs to aid generic programming
  1.1067  	typedef FastDelegate19 type;
  1.1068 @@ -2093,15 +2510,34 @@
  1.1069  	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, Param17 p17, Param18 p18, Param19 p19) const) {
  1.1070  		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
  1.1071  	// Static functions. We convert them into a member function call.
  1.1072 -	// Note that this also provides a conversion from static functions.
  1.1073 +	// This constructor also provides implicit conversion
  1.1074  	FastDelegate19(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, Param17 p17, Param18 p18, Param19 p19) ) {
  1.1075  		bind(function_to_bind);	}
  1.1076 +	// for efficiency, prevent creation of a temporary
  1.1077 +	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, Param17 p17, Param18 p18, Param19 p19) ) {
  1.1078 +		bind(function_to_bind);	}
  1.1079  	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, Param17 p17, Param18 p18, Param19 p19)) {
  1.1080  		m_Closure.bindstaticfunc(this, &FastDelegate19::InvokeStaticFunction,
  1.1081  			function_to_bind); }
  1.1082 -	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, Param17 p17, Param18 p18, Param19 p19) const { // Invoke the delegate
  1.1083 -		// this next line is the only one that violates the standard
  1.1084 +	// Invoke the delegate
  1.1085 +	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, Param17 p17, Param18 p18, Param19 p19) const {
  1.1086  	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19); }
  1.1087 +	// Implicit conversion to "bool" using the safe_bool idiom
  1.1088 +private:
  1.1089 +	typedef struct SafeBoolStruct {
  1.1090 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
  1.1091 +		StaticFunctionPtr m_nonzero;
  1.1092 +	} UselessTypedef;
  1.1093 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  1.1094 +public:
  1.1095 +	operator unspecified_bool_type() const {
  1.1096 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
  1.1097 +    }
  1.1098 +	// necessary to allow ==0 to work despite the safe_bool idiom
  1.1099 +	inline bool operator==(StaticFunctionPtr funcptr) {
  1.1100 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
  1.1101 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
  1.1102 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
  1.1103  	inline bool operator ! () const	{	// Is it bound to anything?
  1.1104  			return !m_Closure; }
  1.1105  	inline bool empty() const	{
  1.1106 @@ -2124,7 +2560,8 @@
  1.1107  	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, Param17 p17, Param18 p18, Param19 p19, Param20 p20);
  1.1108  	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, Param17 p17, Param18 p18, Param19 p19, Param20 p20);
  1.1109  	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, Param17 p17, Param18 p18, Param19 p19, Param20 p20);
  1.1110 -	detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> m_Closure;
  1.1111 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
  1.1112 +	ClosureType m_Closure;
  1.1113  public:
  1.1114  	// Typedefs to aid generic programming
  1.1115  	typedef FastDelegate20 type;
  1.1116 @@ -2158,15 +2595,34 @@
  1.1117  	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, Param17 p17, Param18 p18, Param19 p19, Param20 p20) const) {
  1.1118  		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
  1.1119  	// Static functions. We convert them into a member function call.
  1.1120 -	// Note that this also provides a conversion from static functions.
  1.1121 +	// This constructor also provides implicit conversion
  1.1122  	FastDelegate20(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, Param17 p17, Param18 p18, Param19 p19, Param20 p20) ) {
  1.1123  		bind(function_to_bind);	}
  1.1124 +	// for efficiency, prevent creation of a temporary
  1.1125 +	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, Param17 p17, Param18 p18, Param19 p19, Param20 p20) ) {
  1.1126 +		bind(function_to_bind);	}
  1.1127  	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, Param17 p17, Param18 p18, Param19 p19, Param20 p20)) {
  1.1128  		m_Closure.bindstaticfunc(this, &FastDelegate20::InvokeStaticFunction,
  1.1129  			function_to_bind); }
  1.1130 -	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, Param17 p17, Param18 p18, Param19 p19, Param20 p20) const { // Invoke the delegate
  1.1131 -		// this next line is the only one that violates the standard
  1.1132 +	// Invoke the delegate
  1.1133 +	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, Param17 p17, Param18 p18, Param19 p19, Param20 p20) const {
  1.1134  	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20); }
  1.1135 +	// Implicit conversion to "bool" using the safe_bool idiom
  1.1136 +private:
  1.1137 +	typedef struct SafeBoolStruct {
  1.1138 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
  1.1139 +		StaticFunctionPtr m_nonzero;
  1.1140 +	} UselessTypedef;
  1.1141 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
  1.1142 +public:
  1.1143 +	operator unspecified_bool_type() const {
  1.1144 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
  1.1145 +    }
  1.1146 +	// necessary to allow ==0 to work despite the safe_bool idiom
  1.1147 +	inline bool operator==(StaticFunctionPtr funcptr) {
  1.1148 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
  1.1149 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
  1.1150 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
  1.1151  	inline bool operator ! () const	{	// Is it bound to anything?
  1.1152  			return !m_Closure; }
  1.1153  	inline bool empty() const	{
  1.1154 @@ -2207,8 +2663,7 @@
  1.1155  // FastDelegate0 < R >
  1.1156  template<typename R>
  1.1157  class FastDelegate< R (  ) >
  1.1158 -  // Inherit from FastDelegate0 so that it can be treated just
  1.1159 -  // like a FastDelegate0
  1.1160 +  // Inherit from FastDelegate0 so that it can be treated just like a FastDelegate0
  1.1161    : public FastDelegate0 < R >
  1.1162  {
  1.1163  public:
  1.1164 @@ -2245,8 +2700,7 @@
  1.1165  // FastDelegate1 < Param1, R >
  1.1166  template<typename R, class Param1>
  1.1167  class FastDelegate< R ( Param1 ) >
  1.1168 -  // Inherit from FastDelegate1 so that it can be treated just
  1.1169 -  // like a FastDelegate1
  1.1170 +  // Inherit from FastDelegate1 so that it can be treated just like a FastDelegate1
  1.1171    : public FastDelegate1 < Param1, R >
  1.1172  {
  1.1173  public:
  1.1174 @@ -2283,8 +2737,7 @@
  1.1175  // FastDelegate2 < Param1, Param2, R >
  1.1176  template<typename R, class Param1, class Param2>
  1.1177  class FastDelegate< R ( Param1, Param2 ) >
  1.1178 -  // Inherit from FastDelegate2 so that it can be treated just
  1.1179 -  // like a FastDelegate2
  1.1180 +  // Inherit from FastDelegate2 so that it can be treated just like a FastDelegate2
  1.1181    : public FastDelegate2 < Param1, Param2, R >
  1.1182  {
  1.1183  public:
  1.1184 @@ -2321,8 +2774,7 @@
  1.1185  // FastDelegate3 < Param1, Param2, Param3, R >
  1.1186  template<typename R, class Param1, class Param2, class Param3>
  1.1187  class FastDelegate< R ( Param1, Param2, Param3 ) >
  1.1188 -  // Inherit from FastDelegate3 so that it can be treated just
  1.1189 -  // like a FastDelegate3
  1.1190 +  // Inherit from FastDelegate3 so that it can be treated just like a FastDelegate3
  1.1191    : public FastDelegate3 < Param1, Param2, Param3, R >
  1.1192  {
  1.1193  public:
  1.1194 @@ -2359,8 +2811,7 @@
  1.1195  // FastDelegate4 < Param1, Param2, Param3, Param4, R >
  1.1196  template<typename R, class Param1, class Param2, class Param3, class Param4>
  1.1197  class FastDelegate< R ( Param1, Param2, Param3, Param4 ) >
  1.1198 -  // Inherit from FastDelegate4 so that it can be treated just
  1.1199 -  // like a FastDelegate4
  1.1200 +  // Inherit from FastDelegate4 so that it can be treated just like a FastDelegate4
  1.1201    : public FastDelegate4 < Param1, Param2, Param3, Param4, R >
  1.1202  {
  1.1203  public:
  1.1204 @@ -2397,8 +2848,7 @@
  1.1205  // FastDelegate5 < Param1, Param2, Param3, Param4, Param5, R >
  1.1206  template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5>
  1.1207  class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5 ) >
  1.1208 -  // Inherit from FastDelegate5 so that it can be treated just
  1.1209 -  // like a FastDelegate5
  1.1210 +  // Inherit from FastDelegate5 so that it can be treated just like a FastDelegate5
  1.1211    : public FastDelegate5 < Param1, Param2, Param3, Param4, Param5, R >
  1.1212  {
  1.1213  public:
  1.1214 @@ -2435,8 +2885,7 @@
  1.1215  // FastDelegate6 < Param1, Param2, Param3, Param4, Param5, Param6, R >
  1.1216  template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
  1.1217  class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6 ) >
  1.1218 -  // Inherit from FastDelegate6 so that it can be treated just
  1.1219 -  // like a FastDelegate6
  1.1220 +  // Inherit from FastDelegate6 so that it can be treated just like a FastDelegate6
  1.1221    : public FastDelegate6 < Param1, Param2, Param3, Param4, Param5, Param6, R >
  1.1222  {
  1.1223  public:
  1.1224 @@ -2473,8 +2922,7 @@
  1.1225  // FastDelegate7 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, R >
  1.1226  template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
  1.1227  class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7 ) >
  1.1228 -  // Inherit from FastDelegate7 so that it can be treated just
  1.1229 -  // like a FastDelegate7
  1.1230 +  // Inherit from FastDelegate7 so that it can be treated just like a FastDelegate7
  1.1231    : public FastDelegate7 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, R >
  1.1232  {
  1.1233  public:
  1.1234 @@ -2511,8 +2959,7 @@
  1.1235  // FastDelegate8 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, R >
  1.1236  template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
  1.1237  class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8 ) >
  1.1238 -  // Inherit from FastDelegate8 so that it can be treated just
  1.1239 -  // like a FastDelegate8
  1.1240 +  // Inherit from FastDelegate8 so that it can be treated just like a FastDelegate8
  1.1241    : public FastDelegate8 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, R >
  1.1242  {
  1.1243  public:
  1.1244 @@ -2549,8 +2996,7 @@
  1.1245  // FastDelegate9 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, R >
  1.1246  template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9>
  1.1247  class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9 ) >
  1.1248 -  // Inherit from FastDelegate9 so that it can be treated just
  1.1249 -  // like a FastDelegate9
  1.1250 +  // Inherit from FastDelegate9 so that it can be treated just like a FastDelegate9
  1.1251    : public FastDelegate9 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, R >
  1.1252  {
  1.1253  public:
  1.1254 @@ -2587,8 +3033,7 @@
  1.1255  // FastDelegate10 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, R >
  1.1256  template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10>
  1.1257  class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10 ) >
  1.1258 -  // Inherit from FastDelegate10 so that it can be treated just
  1.1259 -  // like a FastDelegate10
  1.1260 +  // Inherit from FastDelegate10 so that it can be treated just like a FastDelegate10
  1.1261    : public FastDelegate10 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, R >
  1.1262  {
  1.1263  public:
  1.1264 @@ -2625,8 +3070,7 @@
  1.1265  // FastDelegate11 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, R >
  1.1266  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>
  1.1267  class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11 ) >
  1.1268 -  // Inherit from FastDelegate11 so that it can be treated just
  1.1269 -  // like a FastDelegate11
  1.1270 +  // Inherit from FastDelegate11 so that it can be treated just like a FastDelegate11
  1.1271    : public FastDelegate11 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, R >
  1.1272  {
  1.1273  public:
  1.1274 @@ -2663,8 +3107,7 @@
  1.1275  // FastDelegate12 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, R >
  1.1276  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>
  1.1277  class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12 ) >
  1.1278 -  // Inherit from FastDelegate12 so that it can be treated just
  1.1279 -  // like a FastDelegate12
  1.1280 +  // Inherit from FastDelegate12 so that it can be treated just like a FastDelegate12
  1.1281    : public FastDelegate12 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, R >
  1.1282  {
  1.1283  public:
  1.1284 @@ -2701,8 +3144,7 @@
  1.1285  // FastDelegate13 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, R >
  1.1286  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>
  1.1287  class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13 ) >
  1.1288 -  // Inherit from FastDelegate13 so that it can be treated just
  1.1289 -  // like a FastDelegate13
  1.1290 +  // Inherit from FastDelegate13 so that it can be treated just like a FastDelegate13
  1.1291    : public FastDelegate13 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, R >
  1.1292  {
  1.1293  public:
  1.1294 @@ -2739,8 +3181,7 @@
  1.1295  // FastDelegate14 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, R >
  1.1296  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>
  1.1297  class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14 ) >
  1.1298 -  // Inherit from FastDelegate14 so that it can be treated just
  1.1299 -  // like a FastDelegate14
  1.1300 +  // Inherit from FastDelegate14 so that it can be treated just like a FastDelegate14
  1.1301    : public FastDelegate14 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, R >
  1.1302  {
  1.1303  public:
  1.1304 @@ -2777,8 +3218,7 @@
  1.1305  // FastDelegate15 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, R >
  1.1306  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>
  1.1307  class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15 ) >
  1.1308 -  // Inherit from FastDelegate15 so that it can be treated just
  1.1309 -  // like a FastDelegate15
  1.1310 +  // Inherit from FastDelegate15 so that it can be treated just like a FastDelegate15
  1.1311    : public FastDelegate15 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, R >
  1.1312  {
  1.1313  public:
  1.1314 @@ -2815,8 +3255,7 @@
  1.1315  // FastDelegate16 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, R >
  1.1316  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>
  1.1317  class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16 ) >
  1.1318 -  // Inherit from FastDelegate16 so that it can be treated just
  1.1319 -  // like a FastDelegate16
  1.1320 +  // Inherit from FastDelegate16 so that it can be treated just like a FastDelegate16
  1.1321    : public FastDelegate16 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, R >
  1.1322  {
  1.1323  public:
  1.1324 @@ -2853,8 +3292,7 @@
  1.1325  // FastDelegate17 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, R >
  1.1326  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, class Param17>
  1.1327  class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17 ) >
  1.1328 -  // Inherit from FastDelegate17 so that it can be treated just
  1.1329 -  // like a FastDelegate17
  1.1330 +  // Inherit from FastDelegate17 so that it can be treated just like a FastDelegate17
  1.1331    : public FastDelegate17 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, R >
  1.1332  {
  1.1333  public:
  1.1334 @@ -2891,8 +3329,7 @@
  1.1335  // FastDelegate18 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, R >
  1.1336  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, class Param17, class Param18>
  1.1337  class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18 ) >
  1.1338 -  // Inherit from FastDelegate18 so that it can be treated just
  1.1339 -  // like a FastDelegate18
  1.1340 +  // Inherit from FastDelegate18 so that it can be treated just like a FastDelegate18
  1.1341    : public FastDelegate18 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, R >
  1.1342  {
  1.1343  public:
  1.1344 @@ -2929,8 +3366,7 @@
  1.1345  // FastDelegate19 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19, R >
  1.1346  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, class Param17, class Param18, class Param19>
  1.1347  class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19 ) >
  1.1348 -  // Inherit from FastDelegate19 so that it can be treated just
  1.1349 -  // like a FastDelegate19
  1.1350 +  // Inherit from FastDelegate19 so that it can be treated just like a FastDelegate19
  1.1351    : public FastDelegate19 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19, R >
  1.1352  {
  1.1353  public:
  1.1354 @@ -2967,8 +3403,7 @@
  1.1355  // FastDelegate20 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19, Param20, R >
  1.1356  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, class Param17, class Param18, class Param19, class Param20>
  1.1357  class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19, Param20 ) >
  1.1358 -  // Inherit from FastDelegate20 so that it can be treated just
  1.1359 -  // like a FastDelegate20
  1.1360 +  // Inherit from FastDelegate20 so that it can be treated just like a FastDelegate20
  1.1361    : public FastDelegate20 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, Param17, Param18, Param19, Param20, R >
  1.1362  {
  1.1363  public: