sourcehook/FastDelegate.h
changeset 390 66690bf8af93
parent 387 093c72464b35
     1.1 --- a/sourcehook/FastDelegate.h	Mon Oct 08 15:29:38 2007 +0000
     1.2 +++ b/sourcehook/FastDelegate.h	Mon Oct 08 15:43:23 2007 +0000
     1.3 @@ -1532,6 +1532,771 @@
     1.4  	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7); }
     1.5  };
     1.6  
     1.7 +//N=8
     1.8 +template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class RetType=detail::DefaultVoid>
     1.9 +class FastDelegate8 {
    1.10 +private:
    1.11 +	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
    1.12 +	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8);
    1.13 +	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8);
    1.14 +	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8);
    1.15 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
    1.16 +	ClosureType m_Closure;
    1.17 +public:
    1.18 +	// Typedefs to aid generic programming
    1.19 +	typedef FastDelegate8 type;
    1.20 +
    1.21 +	// Construction and comparison functions
    1.22 +	FastDelegate8() { clear(); }
    1.23 +	FastDelegate8(const FastDelegate8 &x) {
    1.24 +		m_Closure.CopyFrom(this, x.m_Closure); }
    1.25 +	void operator = (const FastDelegate8 &x)  {
    1.26 +		m_Closure.CopyFrom(this, x.m_Closure); }
    1.27 +	bool operator ==(const FastDelegate8 &x) const {
    1.28 +		return m_Closure.IsEqual(x.m_Closure);	}
    1.29 +	bool operator !=(const FastDelegate8 &x) const {
    1.30 +		return !m_Closure.IsEqual(x.m_Closure); }
    1.31 +	bool operator <(const FastDelegate8 &x) const {
    1.32 +		return m_Closure.IsLess(x.m_Closure);	}
    1.33 +	bool operator >(const FastDelegate8 &x) const {
    1.34 +		return x.m_Closure.IsLess(m_Closure);	}
    1.35 +	// Binding to non-const member functions
    1.36 +	template < class X, class Y >
    1.37 +	FastDelegate8(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) ) {
    1.38 +		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
    1.39 +	template < class X, class Y >
    1.40 +	inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8)) {
    1.41 +		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
    1.42 +	// Binding to const member functions.
    1.43 +	template < class X, class Y >
    1.44 +	FastDelegate8(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) const) {
    1.45 +		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
    1.46 +	template < class X, class Y >
    1.47 +	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.48 +		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
    1.49 +	// Static functions. We convert them into a member function call.
    1.50 +	// This constructor also provides implicit conversion
    1.51 +	FastDelegate8(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) ) {
    1.52 +		bind(function_to_bind);	}
    1.53 +	// for efficiency, prevent creation of a temporary
    1.54 +	void operator = (DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) ) {
    1.55 +		bind(function_to_bind);	}
    1.56 +	inline void bind(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8)) {
    1.57 +		m_Closure.bindstaticfunc(this, &FastDelegate8::InvokeStaticFunction,
    1.58 +			function_to_bind); }
    1.59 +	// Invoke the delegate
    1.60 +	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) const {
    1.61 +	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8); }
    1.62 +	// Implicit conversion to "bool" using the safe_bool idiom
    1.63 +private:
    1.64 +	typedef struct SafeBoolStruct {
    1.65 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
    1.66 +		StaticFunctionPtr m_nonzero;
    1.67 +	} UselessTypedef;
    1.68 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
    1.69 +public:
    1.70 +	operator unspecified_bool_type() const {
    1.71 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
    1.72 +    }
    1.73 +	// necessary to allow ==0 to work despite the safe_bool idiom
    1.74 +	inline bool operator==(StaticFunctionPtr funcptr) {
    1.75 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
    1.76 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
    1.77 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
    1.78 +	inline bool operator ! () const	{	// Is it bound to anything?
    1.79 +			return !m_Closure; }
    1.80 +	inline bool empty() const	{
    1.81 +			return !m_Closure; }
    1.82 +	void clear() { m_Closure.clear();}
    1.83 +	// Conversion to and from the DelegateMemento storage class
    1.84 +	const DelegateMemento & GetMemento() { return m_Closure; }
    1.85 +	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
    1.86 +
    1.87 +private:	// Invoker for static functions
    1.88 +	RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) const {
    1.89 +	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8); }
    1.90 +};
    1.91 +
    1.92 +//N=9
    1.93 +template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class RetType=detail::DefaultVoid>
    1.94 +class FastDelegate9 {
    1.95 +private:
    1.96 +	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
    1.97 +	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9);
    1.98 +	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9);
    1.99 +	typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9);
   1.100 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   1.101 +	ClosureType m_Closure;
   1.102 +public:
   1.103 +	// Typedefs to aid generic programming
   1.104 +	typedef FastDelegate9 type;
   1.105 +
   1.106 +	// Construction and comparison functions
   1.107 +	FastDelegate9() { clear(); }
   1.108 +	FastDelegate9(const FastDelegate9 &x) {
   1.109 +		m_Closure.CopyFrom(this, x.m_Closure); }
   1.110 +	void operator = (const FastDelegate9 &x)  {
   1.111 +		m_Closure.CopyFrom(this, x.m_Closure); }
   1.112 +	bool operator ==(const FastDelegate9 &x) const {
   1.113 +		return m_Closure.IsEqual(x.m_Closure);	}
   1.114 +	bool operator !=(const FastDelegate9 &x) const {
   1.115 +		return !m_Closure.IsEqual(x.m_Closure); }
   1.116 +	bool operator <(const FastDelegate9 &x) const {
   1.117 +		return m_Closure.IsLess(x.m_Closure);	}
   1.118 +	bool operator >(const FastDelegate9 &x) const {
   1.119 +		return x.m_Closure.IsLess(m_Closure);	}
   1.120 +	// Binding to non-const member functions
   1.121 +	template < class X, class Y >
   1.122 +	FastDelegate9(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9) ) {
   1.123 +		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
   1.124 +	template < class X, class Y >
   1.125 +	inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9)) {
   1.126 +		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
   1.127 +	// Binding to const member functions.
   1.128 +	template < class X, class Y >
   1.129 +	FastDelegate9(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9) const) {
   1.130 +		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
   1.131 +	template < class X, class Y >
   1.132 +	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.133 +		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   1.134 +	// Static functions. We convert them into a member function call.
   1.135 +	// This constructor also provides implicit conversion
   1.136 +	FastDelegate9(DesiredRetType (*function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9) ) {
   1.137 +		bind(function_to_bind);	}
   1.138 +	// for efficiency, prevent creation of a temporary
   1.139 +	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.140 +		bind(function_to_bind);	}
   1.141 +	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.142 +		m_Closure.bindstaticfunc(this, &FastDelegate9::InvokeStaticFunction,
   1.143 +			function_to_bind); }
   1.144 +	// Invoke the delegate
   1.145 +	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9) const {
   1.146 +	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9); }
   1.147 +	// Implicit conversion to "bool" using the safe_bool idiom
   1.148 +private:
   1.149 +	typedef struct SafeBoolStruct {
   1.150 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   1.151 +		StaticFunctionPtr m_nonzero;
   1.152 +	} UselessTypedef;
   1.153 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   1.154 +public:
   1.155 +	operator unspecified_bool_type() const {
   1.156 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
   1.157 +    }
   1.158 +	// necessary to allow ==0 to work despite the safe_bool idiom
   1.159 +	inline bool operator==(StaticFunctionPtr funcptr) {
   1.160 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
   1.161 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
   1.162 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
   1.163 +	inline bool operator ! () const	{	// Is it bound to anything?
   1.164 +			return !m_Closure; }
   1.165 +	inline bool empty() const	{
   1.166 +			return !m_Closure; }
   1.167 +	void clear() { m_Closure.clear();}
   1.168 +	// Conversion to and from the DelegateMemento storage class
   1.169 +	const DelegateMemento & GetMemento() { return m_Closure; }
   1.170 +	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
   1.171 +
   1.172 +private:	// Invoker for static functions
   1.173 +	RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9) const {
   1.174 +	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9); }
   1.175 +};
   1.176 +
   1.177 +//N=10
   1.178 +template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class RetType=detail::DefaultVoid>
   1.179 +class FastDelegate10 {
   1.180 +private:
   1.181 +	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
   1.182 +	typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10);
   1.183 +	typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10);
   1.184 +	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.185 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   1.186 +	ClosureType m_Closure;
   1.187 +public:
   1.188 +	// Typedefs to aid generic programming
   1.189 +	typedef FastDelegate10 type;
   1.190 +
   1.191 +	// Construction and comparison functions
   1.192 +	FastDelegate10() { clear(); }
   1.193 +	FastDelegate10(const FastDelegate10 &x) {
   1.194 +		m_Closure.CopyFrom(this, x.m_Closure); }
   1.195 +	void operator = (const FastDelegate10 &x)  {
   1.196 +		m_Closure.CopyFrom(this, x.m_Closure); }
   1.197 +	bool operator ==(const FastDelegate10 &x) const {
   1.198 +		return m_Closure.IsEqual(x.m_Closure);	}
   1.199 +	bool operator !=(const FastDelegate10 &x) const {
   1.200 +		return !m_Closure.IsEqual(x.m_Closure); }
   1.201 +	bool operator <(const FastDelegate10 &x) const {
   1.202 +		return m_Closure.IsLess(x.m_Closure);	}
   1.203 +	bool operator >(const FastDelegate10 &x) const {
   1.204 +		return x.m_Closure.IsLess(m_Closure);	}
   1.205 +	// Binding to non-const member functions
   1.206 +	template < class X, class Y >
   1.207 +	FastDelegate10(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10) ) {
   1.208 +		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
   1.209 +	template < class X, class Y >
   1.210 +	inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10)) {
   1.211 +		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
   1.212 +	// Binding to const member functions.
   1.213 +	template < class X, class Y >
   1.214 +	FastDelegate10(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10) const) {
   1.215 +		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
   1.216 +	template < class X, class Y >
   1.217 +	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.218 +		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   1.219 +	// Static functions. We convert them into a member function call.
   1.220 +	// This constructor also provides implicit conversion
   1.221 +	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.222 +		bind(function_to_bind);	}
   1.223 +	// for efficiency, prevent creation of a temporary
   1.224 +	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.225 +		bind(function_to_bind);	}
   1.226 +	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.227 +		m_Closure.bindstaticfunc(this, &FastDelegate10::InvokeStaticFunction,
   1.228 +			function_to_bind); }
   1.229 +	// Invoke the delegate
   1.230 +	RetType operator() (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10) const {
   1.231 +	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); }
   1.232 +	// Implicit conversion to "bool" using the safe_bool idiom
   1.233 +private:
   1.234 +	typedef struct SafeBoolStruct {
   1.235 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   1.236 +		StaticFunctionPtr m_nonzero;
   1.237 +	} UselessTypedef;
   1.238 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   1.239 +public:
   1.240 +	operator unspecified_bool_type() const {
   1.241 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
   1.242 +    }
   1.243 +	// necessary to allow ==0 to work despite the safe_bool idiom
   1.244 +	inline bool operator==(StaticFunctionPtr funcptr) {
   1.245 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
   1.246 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
   1.247 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
   1.248 +	inline bool operator ! () const	{	// Is it bound to anything?
   1.249 +			return !m_Closure; }
   1.250 +	inline bool empty() const	{
   1.251 +			return !m_Closure; }
   1.252 +	void clear() { m_Closure.clear();}
   1.253 +	// Conversion to and from the DelegateMemento storage class
   1.254 +	const DelegateMemento & GetMemento() { return m_Closure; }
   1.255 +	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
   1.256 +
   1.257 +private:	// Invoker for static functions
   1.258 +	RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10) const {
   1.259 +	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); }
   1.260 +};
   1.261 +
   1.262 +//N=11
   1.263 +template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class RetType=detail::DefaultVoid>
   1.264 +class FastDelegate11 {
   1.265 +private:
   1.266 +	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
   1.267 +	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.268 +	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.269 +	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.270 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   1.271 +	ClosureType m_Closure;
   1.272 +public:
   1.273 +	// Typedefs to aid generic programming
   1.274 +	typedef FastDelegate11 type;
   1.275 +
   1.276 +	// Construction and comparison functions
   1.277 +	FastDelegate11() { clear(); }
   1.278 +	FastDelegate11(const FastDelegate11 &x) {
   1.279 +		m_Closure.CopyFrom(this, x.m_Closure); }
   1.280 +	void operator = (const FastDelegate11 &x)  {
   1.281 +		m_Closure.CopyFrom(this, x.m_Closure); }
   1.282 +	bool operator ==(const FastDelegate11 &x) const {
   1.283 +		return m_Closure.IsEqual(x.m_Closure);	}
   1.284 +	bool operator !=(const FastDelegate11 &x) const {
   1.285 +		return !m_Closure.IsEqual(x.m_Closure); }
   1.286 +	bool operator <(const FastDelegate11 &x) const {
   1.287 +		return m_Closure.IsLess(x.m_Closure);	}
   1.288 +	bool operator >(const FastDelegate11 &x) const {
   1.289 +		return x.m_Closure.IsLess(m_Closure);	}
   1.290 +	// Binding to non-const member functions
   1.291 +	template < class X, class Y >
   1.292 +	FastDelegate11(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11) ) {
   1.293 +		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
   1.294 +	template < class X, class Y >
   1.295 +	inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11)) {
   1.296 +		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
   1.297 +	// Binding to const member functions.
   1.298 +	template < class X, class Y >
   1.299 +	FastDelegate11(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11) const) {
   1.300 +		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
   1.301 +	template < class X, class Y >
   1.302 +	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.303 +		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   1.304 +	// Static functions. We convert them into a member function call.
   1.305 +	// This constructor also provides implicit conversion
   1.306 +	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.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, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11) ) {
   1.310 +		bind(function_to_bind);	}
   1.311 +	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.312 +		m_Closure.bindstaticfunc(this, &FastDelegate11::InvokeStaticFunction,
   1.313 +			function_to_bind); }
   1.314 +	// Invoke the delegate
   1.315 +	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.316 +	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); }
   1.317 +	// Implicit conversion to "bool" using the safe_bool idiom
   1.318 +private:
   1.319 +	typedef struct SafeBoolStruct {
   1.320 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   1.321 +		StaticFunctionPtr m_nonzero;
   1.322 +	} UselessTypedef;
   1.323 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   1.324 +public:
   1.325 +	operator unspecified_bool_type() const {
   1.326 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
   1.327 +    }
   1.328 +	// necessary to allow ==0 to work despite the safe_bool idiom
   1.329 +	inline bool operator==(StaticFunctionPtr funcptr) {
   1.330 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
   1.331 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
   1.332 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
   1.333 +	inline bool operator ! () const	{	// Is it bound to anything?
   1.334 +			return !m_Closure; }
   1.335 +	inline bool empty() const	{
   1.336 +			return !m_Closure; }
   1.337 +	void clear() { m_Closure.clear();}
   1.338 +	// Conversion to and from the DelegateMemento storage class
   1.339 +	const DelegateMemento & GetMemento() { return m_Closure; }
   1.340 +	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
   1.341 +
   1.342 +private:	// Invoker for static functions
   1.343 +	RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11) const {
   1.344 +	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); }
   1.345 +};
   1.346 +
   1.347 +//N=12
   1.348 +template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class RetType=detail::DefaultVoid>
   1.349 +class FastDelegate12 {
   1.350 +private:
   1.351 +	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
   1.352 +	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.353 +	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.354 +	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.355 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   1.356 +	ClosureType m_Closure;
   1.357 +public:
   1.358 +	// Typedefs to aid generic programming
   1.359 +	typedef FastDelegate12 type;
   1.360 +
   1.361 +	// Construction and comparison functions
   1.362 +	FastDelegate12() { clear(); }
   1.363 +	FastDelegate12(const FastDelegate12 &x) {
   1.364 +		m_Closure.CopyFrom(this, x.m_Closure); }
   1.365 +	void operator = (const FastDelegate12 &x)  {
   1.366 +		m_Closure.CopyFrom(this, x.m_Closure); }
   1.367 +	bool operator ==(const FastDelegate12 &x) const {
   1.368 +		return m_Closure.IsEqual(x.m_Closure);	}
   1.369 +	bool operator !=(const FastDelegate12 &x) const {
   1.370 +		return !m_Closure.IsEqual(x.m_Closure); }
   1.371 +	bool operator <(const FastDelegate12 &x) const {
   1.372 +		return m_Closure.IsLess(x.m_Closure);	}
   1.373 +	bool operator >(const FastDelegate12 &x) const {
   1.374 +		return x.m_Closure.IsLess(m_Closure);	}
   1.375 +	// Binding to non-const member functions
   1.376 +	template < class X, class Y >
   1.377 +	FastDelegate12(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12) ) {
   1.378 +		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
   1.379 +	template < class X, class Y >
   1.380 +	inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12)) {
   1.381 +		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
   1.382 +	// Binding to const member functions.
   1.383 +	template < class X, class Y >
   1.384 +	FastDelegate12(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12) const) {
   1.385 +		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
   1.386 +	template < class X, class Y >
   1.387 +	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.388 +		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   1.389 +	// Static functions. We convert them into a member function call.
   1.390 +	// This constructor also provides implicit conversion
   1.391 +	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.392 +		bind(function_to_bind);	}
   1.393 +	// for efficiency, prevent creation of a temporary
   1.394 +	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.395 +		bind(function_to_bind);	}
   1.396 +	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.397 +		m_Closure.bindstaticfunc(this, &FastDelegate12::InvokeStaticFunction,
   1.398 +			function_to_bind); }
   1.399 +	// Invoke the delegate
   1.400 +	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.401 +	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); }
   1.402 +	// Implicit conversion to "bool" using the safe_bool idiom
   1.403 +private:
   1.404 +	typedef struct SafeBoolStruct {
   1.405 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   1.406 +		StaticFunctionPtr m_nonzero;
   1.407 +	} UselessTypedef;
   1.408 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   1.409 +public:
   1.410 +	operator unspecified_bool_type() const {
   1.411 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
   1.412 +    }
   1.413 +	// necessary to allow ==0 to work despite the safe_bool idiom
   1.414 +	inline bool operator==(StaticFunctionPtr funcptr) {
   1.415 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
   1.416 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
   1.417 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
   1.418 +	inline bool operator ! () const	{	// Is it bound to anything?
   1.419 +			return !m_Closure; }
   1.420 +	inline bool empty() const	{
   1.421 +			return !m_Closure; }
   1.422 +	void clear() { m_Closure.clear();}
   1.423 +	// Conversion to and from the DelegateMemento storage class
   1.424 +	const DelegateMemento & GetMemento() { return m_Closure; }
   1.425 +	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
   1.426 +
   1.427 +private:	// Invoker for static functions
   1.428 +	RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12) const {
   1.429 +	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); }
   1.430 +};
   1.431 +
   1.432 +//N=13
   1.433 +template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class RetType=detail::DefaultVoid>
   1.434 +class FastDelegate13 {
   1.435 +private:
   1.436 +	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
   1.437 +	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.438 +	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.439 +	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.440 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   1.441 +	ClosureType m_Closure;
   1.442 +public:
   1.443 +	// Typedefs to aid generic programming
   1.444 +	typedef FastDelegate13 type;
   1.445 +
   1.446 +	// Construction and comparison functions
   1.447 +	FastDelegate13() { clear(); }
   1.448 +	FastDelegate13(const FastDelegate13 &x) {
   1.449 +		m_Closure.CopyFrom(this, x.m_Closure); }
   1.450 +	void operator = (const FastDelegate13 &x)  {
   1.451 +		m_Closure.CopyFrom(this, x.m_Closure); }
   1.452 +	bool operator ==(const FastDelegate13 &x) const {
   1.453 +		return m_Closure.IsEqual(x.m_Closure);	}
   1.454 +	bool operator !=(const FastDelegate13 &x) const {
   1.455 +		return !m_Closure.IsEqual(x.m_Closure); }
   1.456 +	bool operator <(const FastDelegate13 &x) const {
   1.457 +		return m_Closure.IsLess(x.m_Closure);	}
   1.458 +	bool operator >(const FastDelegate13 &x) const {
   1.459 +		return x.m_Closure.IsLess(m_Closure);	}
   1.460 +	// Binding to non-const member functions
   1.461 +	template < class X, class Y >
   1.462 +	FastDelegate13(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13) ) {
   1.463 +		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
   1.464 +	template < class X, class Y >
   1.465 +	inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13)) {
   1.466 +		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
   1.467 +	// Binding to const member functions.
   1.468 +	template < class X, class Y >
   1.469 +	FastDelegate13(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13) const) {
   1.470 +		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
   1.471 +	template < class X, class Y >
   1.472 +	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.473 +		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   1.474 +	// Static functions. We convert them into a member function call.
   1.475 +	// This constructor also provides implicit conversion
   1.476 +	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.477 +		bind(function_to_bind);	}
   1.478 +	// for efficiency, prevent creation of a temporary
   1.479 +	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.480 +		bind(function_to_bind);	}
   1.481 +	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.482 +		m_Closure.bindstaticfunc(this, &FastDelegate13::InvokeStaticFunction,
   1.483 +			function_to_bind); }
   1.484 +	// Invoke the delegate
   1.485 +	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.486 +	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); }
   1.487 +	// Implicit conversion to "bool" using the safe_bool idiom
   1.488 +private:
   1.489 +	typedef struct SafeBoolStruct {
   1.490 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   1.491 +		StaticFunctionPtr m_nonzero;
   1.492 +	} UselessTypedef;
   1.493 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   1.494 +public:
   1.495 +	operator unspecified_bool_type() const {
   1.496 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
   1.497 +    }
   1.498 +	// necessary to allow ==0 to work despite the safe_bool idiom
   1.499 +	inline bool operator==(StaticFunctionPtr funcptr) {
   1.500 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
   1.501 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
   1.502 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
   1.503 +	inline bool operator ! () const	{	// Is it bound to anything?
   1.504 +			return !m_Closure; }
   1.505 +	inline bool empty() const	{
   1.506 +			return !m_Closure; }
   1.507 +	void clear() { m_Closure.clear();}
   1.508 +	// Conversion to and from the DelegateMemento storage class
   1.509 +	const DelegateMemento & GetMemento() { return m_Closure; }
   1.510 +	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
   1.511 +
   1.512 +private:	// Invoker for static functions
   1.513 +	RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13) const {
   1.514 +	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); }
   1.515 +};
   1.516 +
   1.517 +//N=14
   1.518 +template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class RetType=detail::DefaultVoid>
   1.519 +class FastDelegate14 {
   1.520 +private:
   1.521 +	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
   1.522 +	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.523 +	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.524 +	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.525 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   1.526 +	ClosureType m_Closure;
   1.527 +public:
   1.528 +	// Typedefs to aid generic programming
   1.529 +	typedef FastDelegate14 type;
   1.530 +
   1.531 +	// Construction and comparison functions
   1.532 +	FastDelegate14() { clear(); }
   1.533 +	FastDelegate14(const FastDelegate14 &x) {
   1.534 +		m_Closure.CopyFrom(this, x.m_Closure); }
   1.535 +	void operator = (const FastDelegate14 &x)  {
   1.536 +		m_Closure.CopyFrom(this, x.m_Closure); }
   1.537 +	bool operator ==(const FastDelegate14 &x) const {
   1.538 +		return m_Closure.IsEqual(x.m_Closure);	}
   1.539 +	bool operator !=(const FastDelegate14 &x) const {
   1.540 +		return !m_Closure.IsEqual(x.m_Closure); }
   1.541 +	bool operator <(const FastDelegate14 &x) const {
   1.542 +		return m_Closure.IsLess(x.m_Closure);	}
   1.543 +	bool operator >(const FastDelegate14 &x) const {
   1.544 +		return x.m_Closure.IsLess(m_Closure);	}
   1.545 +	// Binding to non-const member functions
   1.546 +	template < class X, class Y >
   1.547 +	FastDelegate14(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14) ) {
   1.548 +		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
   1.549 +	template < class X, class Y >
   1.550 +	inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14)) {
   1.551 +		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
   1.552 +	// Binding to const member functions.
   1.553 +	template < class X, class Y >
   1.554 +	FastDelegate14(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14) const) {
   1.555 +		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
   1.556 +	template < class X, class Y >
   1.557 +	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.558 +		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   1.559 +	// Static functions. We convert them into a member function call.
   1.560 +	// This constructor also provides implicit conversion
   1.561 +	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.562 +		bind(function_to_bind);	}
   1.563 +	// for efficiency, prevent creation of a temporary
   1.564 +	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.565 +		bind(function_to_bind);	}
   1.566 +	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.567 +		m_Closure.bindstaticfunc(this, &FastDelegate14::InvokeStaticFunction,
   1.568 +			function_to_bind); }
   1.569 +	// Invoke the delegate
   1.570 +	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.571 +	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); }
   1.572 +	// Implicit conversion to "bool" using the safe_bool idiom
   1.573 +private:
   1.574 +	typedef struct SafeBoolStruct {
   1.575 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   1.576 +		StaticFunctionPtr m_nonzero;
   1.577 +	} UselessTypedef;
   1.578 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   1.579 +public:
   1.580 +	operator unspecified_bool_type() const {
   1.581 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
   1.582 +    }
   1.583 +	// necessary to allow ==0 to work despite the safe_bool idiom
   1.584 +	inline bool operator==(StaticFunctionPtr funcptr) {
   1.585 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
   1.586 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
   1.587 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
   1.588 +	inline bool operator ! () const	{	// Is it bound to anything?
   1.589 +			return !m_Closure; }
   1.590 +	inline bool empty() const	{
   1.591 +			return !m_Closure; }
   1.592 +	void clear() { m_Closure.clear();}
   1.593 +	// Conversion to and from the DelegateMemento storage class
   1.594 +	const DelegateMemento & GetMemento() { return m_Closure; }
   1.595 +	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
   1.596 +
   1.597 +private:	// Invoker for static functions
   1.598 +	RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14) const {
   1.599 +	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); }
   1.600 +};
   1.601 +
   1.602 +//N=15
   1.603 +template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class RetType=detail::DefaultVoid>
   1.604 +class FastDelegate15 {
   1.605 +private:
   1.606 +	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
   1.607 +	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.608 +	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.609 +	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.610 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   1.611 +	ClosureType m_Closure;
   1.612 +public:
   1.613 +	// Typedefs to aid generic programming
   1.614 +	typedef FastDelegate15 type;
   1.615 +
   1.616 +	// Construction and comparison functions
   1.617 +	FastDelegate15() { clear(); }
   1.618 +	FastDelegate15(const FastDelegate15 &x) {
   1.619 +		m_Closure.CopyFrom(this, x.m_Closure); }
   1.620 +	void operator = (const FastDelegate15 &x)  {
   1.621 +		m_Closure.CopyFrom(this, x.m_Closure); }
   1.622 +	bool operator ==(const FastDelegate15 &x) const {
   1.623 +		return m_Closure.IsEqual(x.m_Closure);	}
   1.624 +	bool operator !=(const FastDelegate15 &x) const {
   1.625 +		return !m_Closure.IsEqual(x.m_Closure); }
   1.626 +	bool operator <(const FastDelegate15 &x) const {
   1.627 +		return m_Closure.IsLess(x.m_Closure);	}
   1.628 +	bool operator >(const FastDelegate15 &x) const {
   1.629 +		return x.m_Closure.IsLess(m_Closure);	}
   1.630 +	// Binding to non-const member functions
   1.631 +	template < class X, class Y >
   1.632 +	FastDelegate15(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15) ) {
   1.633 +		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
   1.634 +	template < class X, class Y >
   1.635 +	inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15)) {
   1.636 +		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
   1.637 +	// Binding to const member functions.
   1.638 +	template < class X, class Y >
   1.639 +	FastDelegate15(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15) const) {
   1.640 +		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
   1.641 +	template < class X, class Y >
   1.642 +	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.643 +		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   1.644 +	// Static functions. We convert them into a member function call.
   1.645 +	// This constructor also provides implicit conversion
   1.646 +	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.647 +		bind(function_to_bind);	}
   1.648 +	// for efficiency, prevent creation of a temporary
   1.649 +	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.650 +		bind(function_to_bind);	}
   1.651 +	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.652 +		m_Closure.bindstaticfunc(this, &FastDelegate15::InvokeStaticFunction,
   1.653 +			function_to_bind); }
   1.654 +	// Invoke the delegate
   1.655 +	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.656 +	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); }
   1.657 +	// Implicit conversion to "bool" using the safe_bool idiom
   1.658 +private:
   1.659 +	typedef struct SafeBoolStruct {
   1.660 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   1.661 +		StaticFunctionPtr m_nonzero;
   1.662 +	} UselessTypedef;
   1.663 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   1.664 +public:
   1.665 +	operator unspecified_bool_type() const {
   1.666 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
   1.667 +    }
   1.668 +	// necessary to allow ==0 to work despite the safe_bool idiom
   1.669 +	inline bool operator==(StaticFunctionPtr funcptr) {
   1.670 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
   1.671 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
   1.672 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
   1.673 +	inline bool operator ! () const	{	// Is it bound to anything?
   1.674 +			return !m_Closure; }
   1.675 +	inline bool empty() const	{
   1.676 +			return !m_Closure; }
   1.677 +	void clear() { m_Closure.clear();}
   1.678 +	// Conversion to and from the DelegateMemento storage class
   1.679 +	const DelegateMemento & GetMemento() { return m_Closure; }
   1.680 +	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
   1.681 +
   1.682 +private:	// Invoker for static functions
   1.683 +	RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15) const {
   1.684 +	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); }
   1.685 +};
   1.686 +
   1.687 +//N=16
   1.688 +template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16, class RetType=detail::DefaultVoid>
   1.689 +class FastDelegate16 {
   1.690 +private:
   1.691 +	typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType;
   1.692 +	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.693 +	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.694 +	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.695 +	typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
   1.696 +	ClosureType m_Closure;
   1.697 +public:
   1.698 +	// Typedefs to aid generic programming
   1.699 +	typedef FastDelegate16 type;
   1.700 +
   1.701 +	// Construction and comparison functions
   1.702 +	FastDelegate16() { clear(); }
   1.703 +	FastDelegate16(const FastDelegate16 &x) {
   1.704 +		m_Closure.CopyFrom(this, x.m_Closure); }
   1.705 +	void operator = (const FastDelegate16 &x)  {
   1.706 +		m_Closure.CopyFrom(this, x.m_Closure); }
   1.707 +	bool operator ==(const FastDelegate16 &x) const {
   1.708 +		return m_Closure.IsEqual(x.m_Closure);	}
   1.709 +	bool operator !=(const FastDelegate16 &x) const {
   1.710 +		return !m_Closure.IsEqual(x.m_Closure); }
   1.711 +	bool operator <(const FastDelegate16 &x) const {
   1.712 +		return m_Closure.IsLess(x.m_Closure);	}
   1.713 +	bool operator >(const FastDelegate16 &x) const {
   1.714 +		return x.m_Closure.IsLess(m_Closure);	}
   1.715 +	// Binding to non-const member functions
   1.716 +	template < class X, class Y >
   1.717 +	FastDelegate16(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16) ) {
   1.718 +		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); }
   1.719 +	template < class X, class Y >
   1.720 +	inline void bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16)) {
   1.721 +		m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind);	}
   1.722 +	// Binding to const member functions.
   1.723 +	template < class X, class Y >
   1.724 +	FastDelegate16(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16) const) {
   1.725 +		m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind);	}
   1.726 +	template < class X, class Y >
   1.727 +	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.728 +		m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind);	}
   1.729 +	// Static functions. We convert them into a member function call.
   1.730 +	// This constructor also provides implicit conversion
   1.731 +	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.732 +		bind(function_to_bind);	}
   1.733 +	// for efficiency, prevent creation of a temporary
   1.734 +	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.735 +		bind(function_to_bind);	}
   1.736 +	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.737 +		m_Closure.bindstaticfunc(this, &FastDelegate16::InvokeStaticFunction,
   1.738 +			function_to_bind); }
   1.739 +	// Invoke the delegate
   1.740 +	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.741 +	return (m_Closure.GetClosureThis()->*(m_Closure.GetClosureMemPtr()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16); }
   1.742 +	// Implicit conversion to "bool" using the safe_bool idiom
   1.743 +private:
   1.744 +	typedef struct SafeBoolStruct {
   1.745 +		int a_data_pointer_to_this_is_0_on_buggy_compilers;
   1.746 +		StaticFunctionPtr m_nonzero;
   1.747 +	} UselessTypedef;
   1.748 +    typedef StaticFunctionPtr SafeBoolStruct::*unspecified_bool_type;
   1.749 +public:
   1.750 +	operator unspecified_bool_type() const {
   1.751 +        return empty()? 0: &SafeBoolStruct::m_nonzero;
   1.752 +    }
   1.753 +	// necessary to allow ==0 to work despite the safe_bool idiom
   1.754 +	inline bool operator==(StaticFunctionPtr funcptr) {
   1.755 +		return m_Closure.IsEqualToStaticFuncPtr(funcptr);	}
   1.756 +	inline bool operator!=(StaticFunctionPtr funcptr) { 
   1.757 +		return !m_Closure.IsEqualToStaticFuncPtr(funcptr);    }
   1.758 +	inline bool operator ! () const	{	// Is it bound to anything?
   1.759 +			return !m_Closure; }
   1.760 +	inline bool empty() const	{
   1.761 +			return !m_Closure; }
   1.762 +	void clear() { m_Closure.clear();}
   1.763 +	// Conversion to and from the DelegateMemento storage class
   1.764 +	const DelegateMemento & GetMemento() { return m_Closure; }
   1.765 +	void SetMemento(const DelegateMemento &any) { m_Closure.CopyFrom(this, any); }
   1.766 +
   1.767 +private:	// Invoker for static functions
   1.768 +	RetType InvokeStaticFunction(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16) const {
   1.769 +	return (*(m_Closure.GetStaticFunction()))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16); }
   1.770 +};
   1.771 +
   1.772  
   1.773  ////////////////////////////////////////////////////////////////////////////////
   1.774  //						Fast Delegates, part 4:
   1.775 @@ -1847,6 +2612,339 @@
   1.776  		*static_cast<BaseType*>(this) = x; }
   1.777  };
   1.778  
   1.779 +//N=8
   1.780 +// Specialization to allow use of
   1.781 +// FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8 ) >
   1.782 +// instead of
   1.783 +// FastDelegate8 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, R >
   1.784 +template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
   1.785 +class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8 ) >
   1.786 +  // Inherit from FastDelegate8 so that it can be treated just like a FastDelegate8
   1.787 +  : public FastDelegate8 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, R >
   1.788 +{
   1.789 +public:
   1.790 +  // Make using the base type a bit easier via typedef.
   1.791 +  typedef FastDelegate8 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, R > BaseType;
   1.792 +
   1.793 +  // Allow users access to the specific type of this delegate.
   1.794 +  typedef FastDelegate SelfType;
   1.795 +
   1.796 +  // Mimic the base class constructors.
   1.797 +  FastDelegate() : BaseType() { }
   1.798 +
   1.799 +  template < class X, class Y >
   1.800 +  FastDelegate(Y * pthis,
   1.801 +    R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8 ))
   1.802 +    : BaseType(pthis, function_to_bind)  { }
   1.803 +
   1.804 +  template < class X, class Y >
   1.805 +  FastDelegate(const Y *pthis,
   1.806 +      R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8 ) const)
   1.807 +    : BaseType(pthis, function_to_bind)
   1.808 +  {  }
   1.809 +
   1.810 +  FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8 ))
   1.811 +    : BaseType(function_to_bind)  { }
   1.812 +  void operator = (const BaseType &x)  {
   1.813 +		*static_cast<BaseType*>(this) = x; }
   1.814 +};
   1.815 +
   1.816 +//N=9
   1.817 +// Specialization to allow use of
   1.818 +// FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9 ) >
   1.819 +// instead of
   1.820 +// FastDelegate9 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, R >
   1.821 +template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9>
   1.822 +class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9 ) >
   1.823 +  // Inherit from FastDelegate9 so that it can be treated just like a FastDelegate9
   1.824 +  : public FastDelegate9 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, R >
   1.825 +{
   1.826 +public:
   1.827 +  // Make using the base type a bit easier via typedef.
   1.828 +  typedef FastDelegate9 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, R > BaseType;
   1.829 +
   1.830 +  // Allow users access to the specific type of this delegate.
   1.831 +  typedef FastDelegate SelfType;
   1.832 +
   1.833 +  // Mimic the base class constructors.
   1.834 +  FastDelegate() : BaseType() { }
   1.835 +
   1.836 +  template < class X, class Y >
   1.837 +  FastDelegate(Y * pthis,
   1.838 +    R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9 ))
   1.839 +    : BaseType(pthis, function_to_bind)  { }
   1.840 +
   1.841 +  template < class X, class Y >
   1.842 +  FastDelegate(const Y *pthis,
   1.843 +      R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9 ) const)
   1.844 +    : BaseType(pthis, function_to_bind)
   1.845 +  {  }
   1.846 +
   1.847 +  FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9 ))
   1.848 +    : BaseType(function_to_bind)  { }
   1.849 +  void operator = (const BaseType &x)  {
   1.850 +		*static_cast<BaseType*>(this) = x; }
   1.851 +};
   1.852 +
   1.853 +//N=10
   1.854 +// Specialization to allow use of
   1.855 +// FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10 ) >
   1.856 +// instead of
   1.857 +// FastDelegate10 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, R >
   1.858 +template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10>
   1.859 +class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10 ) >
   1.860 +  // Inherit from FastDelegate10 so that it can be treated just like a FastDelegate10
   1.861 +  : public FastDelegate10 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, R >
   1.862 +{
   1.863 +public:
   1.864 +  // Make using the base type a bit easier via typedef.
   1.865 +  typedef FastDelegate10 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, R > BaseType;
   1.866 +
   1.867 +  // Allow users access to the specific type of this delegate.
   1.868 +  typedef FastDelegate SelfType;
   1.869 +
   1.870 +  // Mimic the base class constructors.
   1.871 +  FastDelegate() : BaseType() { }
   1.872 +
   1.873 +  template < class X, class Y >
   1.874 +  FastDelegate(Y * pthis,
   1.875 +    R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10 ))
   1.876 +    : BaseType(pthis, function_to_bind)  { }
   1.877 +
   1.878 +  template < class X, class Y >
   1.879 +  FastDelegate(const Y *pthis,
   1.880 +      R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10 ) const)
   1.881 +    : BaseType(pthis, function_to_bind)
   1.882 +  {  }
   1.883 +
   1.884 +  FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10 ))
   1.885 +    : BaseType(function_to_bind)  { }
   1.886 +  void operator = (const BaseType &x)  {
   1.887 +		*static_cast<BaseType*>(this) = x; }
   1.888 +};
   1.889 +
   1.890 +//N=11
   1.891 +// Specialization to allow use of
   1.892 +// FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11 ) >
   1.893 +// instead of
   1.894 +// FastDelegate11 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, R >
   1.895 +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.896 +class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11 ) >
   1.897 +  // Inherit from FastDelegate11 so that it can be treated just like a FastDelegate11
   1.898 +  : public FastDelegate11 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, R >
   1.899 +{
   1.900 +public:
   1.901 +  // Make using the base type a bit easier via typedef.
   1.902 +  typedef FastDelegate11 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, R > BaseType;
   1.903 +
   1.904 +  // Allow users access to the specific type of this delegate.
   1.905 +  typedef FastDelegate SelfType;
   1.906 +
   1.907 +  // Mimic the base class constructors.
   1.908 +  FastDelegate() : BaseType() { }
   1.909 +
   1.910 +  template < class X, class Y >
   1.911 +  FastDelegate(Y * pthis,
   1.912 +    R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11 ))
   1.913 +    : BaseType(pthis, function_to_bind)  { }
   1.914 +
   1.915 +  template < class X, class Y >
   1.916 +  FastDelegate(const Y *pthis,
   1.917 +      R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11 ) const)
   1.918 +    : BaseType(pthis, function_to_bind)
   1.919 +  {  }
   1.920 +
   1.921 +  FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11 ))
   1.922 +    : BaseType(function_to_bind)  { }
   1.923 +  void operator = (const BaseType &x)  {
   1.924 +		*static_cast<BaseType*>(this) = x; }
   1.925 +};
   1.926 +
   1.927 +//N=12
   1.928 +// Specialization to allow use of
   1.929 +// FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12 ) >
   1.930 +// instead of
   1.931 +// FastDelegate12 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, R >
   1.932 +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.933 +class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12 ) >
   1.934 +  // Inherit from FastDelegate12 so that it can be treated just like a FastDelegate12
   1.935 +  : public FastDelegate12 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, R >
   1.936 +{
   1.937 +public:
   1.938 +  // Make using the base type a bit easier via typedef.
   1.939 +  typedef FastDelegate12 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, R > BaseType;
   1.940 +
   1.941 +  // Allow users access to the specific type of this delegate.
   1.942 +  typedef FastDelegate SelfType;
   1.943 +
   1.944 +  // Mimic the base class constructors.
   1.945 +  FastDelegate() : BaseType() { }
   1.946 +
   1.947 +  template < class X, class Y >
   1.948 +  FastDelegate(Y * pthis,
   1.949 +    R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12 ))
   1.950 +    : BaseType(pthis, function_to_bind)  { }
   1.951 +
   1.952 +  template < class X, class Y >
   1.953 +  FastDelegate(const Y *pthis,
   1.954 +      R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12 ) const)
   1.955 +    : BaseType(pthis, function_to_bind)
   1.956 +  {  }
   1.957 +
   1.958 +  FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12 ))
   1.959 +    : BaseType(function_to_bind)  { }
   1.960 +  void operator = (const BaseType &x)  {
   1.961 +		*static_cast<BaseType*>(this) = x; }
   1.962 +};
   1.963 +
   1.964 +//N=13
   1.965 +// Specialization to allow use of
   1.966 +// FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13 ) >
   1.967 +// instead of
   1.968 +// FastDelegate13 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, R >
   1.969 +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.970 +class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13 ) >
   1.971 +  // Inherit from FastDelegate13 so that it can be treated just like a FastDelegate13
   1.972 +  : public FastDelegate13 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, R >
   1.973 +{
   1.974 +public:
   1.975 +  // Make using the base type a bit easier via typedef.
   1.976 +  typedef FastDelegate13 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, R > BaseType;
   1.977 +
   1.978 +  // Allow users access to the specific type of this delegate.
   1.979 +  typedef FastDelegate SelfType;
   1.980 +
   1.981 +  // Mimic the base class constructors.
   1.982 +  FastDelegate() : BaseType() { }
   1.983 +
   1.984 +  template < class X, class Y >
   1.985 +  FastDelegate(Y * pthis,
   1.986 +    R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13 ))
   1.987 +    : BaseType(pthis, function_to_bind)  { }
   1.988 +
   1.989 +  template < class X, class Y >
   1.990 +  FastDelegate(const Y *pthis,
   1.991 +      R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13 ) const)
   1.992 +    : BaseType(pthis, function_to_bind)
   1.993 +  {  }
   1.994 +
   1.995 +  FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13 ))
   1.996 +    : BaseType(function_to_bind)  { }
   1.997 +  void operator = (const BaseType &x)  {
   1.998 +		*static_cast<BaseType*>(this) = x; }
   1.999 +};
  1.1000 +
  1.1001 +//N=14
  1.1002 +// Specialization to allow use of
  1.1003 +// FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14 ) >
  1.1004 +// instead of
  1.1005 +// FastDelegate14 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, R >
  1.1006 +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.1007 +class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14 ) >
  1.1008 +  // Inherit from FastDelegate14 so that it can be treated just like a FastDelegate14
  1.1009 +  : public FastDelegate14 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, R >
  1.1010 +{
  1.1011 +public:
  1.1012 +  // Make using the base type a bit easier via typedef.
  1.1013 +  typedef FastDelegate14 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, R > BaseType;
  1.1014 +
  1.1015 +  // Allow users access to the specific type of this delegate.
  1.1016 +  typedef FastDelegate SelfType;
  1.1017 +
  1.1018 +  // Mimic the base class constructors.
  1.1019 +  FastDelegate() : BaseType() { }
  1.1020 +
  1.1021 +  template < class X, class Y >
  1.1022 +  FastDelegate(Y * pthis,
  1.1023 +    R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14 ))
  1.1024 +    : BaseType(pthis, function_to_bind)  { }
  1.1025 +
  1.1026 +  template < class X, class Y >
  1.1027 +  FastDelegate(const Y *pthis,
  1.1028 +      R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14 ) const)
  1.1029 +    : BaseType(pthis, function_to_bind)
  1.1030 +  {  }
  1.1031 +
  1.1032 +  FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14 ))
  1.1033 +    : BaseType(function_to_bind)  { }
  1.1034 +  void operator = (const BaseType &x)  {
  1.1035 +		*static_cast<BaseType*>(this) = x; }
  1.1036 +};
  1.1037 +
  1.1038 +//N=15
  1.1039 +// Specialization to allow use of
  1.1040 +// FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15 ) >
  1.1041 +// instead of
  1.1042 +// FastDelegate15 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, R >
  1.1043 +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.1044 +class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15 ) >
  1.1045 +  // Inherit from FastDelegate15 so that it can be treated just like a FastDelegate15
  1.1046 +  : public FastDelegate15 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, R >
  1.1047 +{
  1.1048 +public:
  1.1049 +  // Make using the base type a bit easier via typedef.
  1.1050 +  typedef FastDelegate15 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, R > BaseType;
  1.1051 +
  1.1052 +  // Allow users access to the specific type of this delegate.
  1.1053 +  typedef FastDelegate SelfType;
  1.1054 +
  1.1055 +  // Mimic the base class constructors.
  1.1056 +  FastDelegate() : BaseType() { }
  1.1057 +
  1.1058 +  template < class X, class Y >
  1.1059 +  FastDelegate(Y * pthis,
  1.1060 +    R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15 ))
  1.1061 +    : BaseType(pthis, function_to_bind)  { }
  1.1062 +
  1.1063 +  template < class X, class Y >
  1.1064 +  FastDelegate(const Y *pthis,
  1.1065 +      R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15 ) const)
  1.1066 +    : BaseType(pthis, function_to_bind)
  1.1067 +  {  }
  1.1068 +
  1.1069 +  FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15 ))
  1.1070 +    : BaseType(function_to_bind)  { }
  1.1071 +  void operator = (const BaseType &x)  {
  1.1072 +		*static_cast<BaseType*>(this) = x; }
  1.1073 +};
  1.1074 +
  1.1075 +//N=16
  1.1076 +// Specialization to allow use of
  1.1077 +// FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16 ) >
  1.1078 +// instead of
  1.1079 +// FastDelegate16 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, R >
  1.1080 +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.1081 +class FastDelegate< R ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16 ) >
  1.1082 +  // Inherit from FastDelegate16 so that it can be treated just like a FastDelegate16
  1.1083 +  : public FastDelegate16 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, R >
  1.1084 +{
  1.1085 +public:
  1.1086 +  // Make using the base type a bit easier via typedef.
  1.1087 +  typedef FastDelegate16 < Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, R > BaseType;
  1.1088 +
  1.1089 +  // Allow users access to the specific type of this delegate.
  1.1090 +  typedef FastDelegate SelfType;
  1.1091 +
  1.1092 +  // Mimic the base class constructors.
  1.1093 +  FastDelegate() : BaseType() { }
  1.1094 +
  1.1095 +  template < class X, class Y >
  1.1096 +  FastDelegate(Y * pthis,
  1.1097 +    R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16 ))
  1.1098 +    : BaseType(pthis, function_to_bind)  { }
  1.1099 +
  1.1100 +  template < class X, class Y >
  1.1101 +  FastDelegate(const Y *pthis,
  1.1102 +      R (X::* function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16 ) const)
  1.1103 +    : BaseType(pthis, function_to_bind)
  1.1104 +  {  }
  1.1105 +
  1.1106 +  FastDelegate(R (*function_to_bind)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16 ))
  1.1107 +    : BaseType(function_to_bind)  { }
  1.1108 +  void operator = (const BaseType &x)  {
  1.1109 +		*static_cast<BaseType*>(this) = x; }
  1.1110 +};
  1.1111 +
  1.1112  
  1.1113  #endif //FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX
  1.1114  
  1.1115 @@ -2008,6 +3106,150 @@
  1.1116  	return FastDelegate7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, FASTDLGT_RETTYPE>(func);
  1.1117  }
  1.1118  
  1.1119 +//N=8
  1.1120 +template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class RetType>
  1.1121 +FastDelegate8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8)) {
  1.1122 +	return FastDelegate8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, FASTDLGT_RETTYPE>(x, func);
  1.1123 +}
  1.1124 +
  1.1125 +template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class RetType>
  1.1126 +FastDelegate8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) const) {
  1.1127 +	return FastDelegate8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, FASTDLGT_RETTYPE>(x, func);
  1.1128 +}
  1.1129 +
  1.1130 +template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class RetType>
  1.1131 +FastDelegate8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8)) {
  1.1132 +	return FastDelegate8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, FASTDLGT_RETTYPE>(func);
  1.1133 +}
  1.1134 +
  1.1135 +//N=9
  1.1136 +template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class RetType>
  1.1137 +FastDelegate9<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9)) {
  1.1138 +	return FastDelegate9<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, FASTDLGT_RETTYPE>(x, func);
  1.1139 +}
  1.1140 +
  1.1141 +template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class RetType>
  1.1142 +FastDelegate9<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9) const) {
  1.1143 +	return FastDelegate9<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, FASTDLGT_RETTYPE>(x, func);
  1.1144 +}
  1.1145 +
  1.1146 +template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class RetType>
  1.1147 +FastDelegate9<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9)) {
  1.1148 +	return FastDelegate9<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, FASTDLGT_RETTYPE>(func);
  1.1149 +}
  1.1150 +
  1.1151 +//N=10
  1.1152 +template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class RetType>
  1.1153 +FastDelegate10<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10)) {
  1.1154 +	return FastDelegate10<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, FASTDLGT_RETTYPE>(x, func);
  1.1155 +}
  1.1156 +
  1.1157 +template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class RetType>
  1.1158 +FastDelegate10<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10) const) {
  1.1159 +	return FastDelegate10<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, FASTDLGT_RETTYPE>(x, func);
  1.1160 +}
  1.1161 +
  1.1162 +template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class RetType>
  1.1163 +FastDelegate10<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10)) {
  1.1164 +	return FastDelegate10<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, FASTDLGT_RETTYPE>(func);
  1.1165 +}
  1.1166 +
  1.1167 +//N=11
  1.1168 +template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class RetType>
  1.1169 +FastDelegate11<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11)) {
  1.1170 +	return FastDelegate11<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, FASTDLGT_RETTYPE>(x, func);
  1.1171 +}
  1.1172 +
  1.1173 +template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class RetType>
  1.1174 +FastDelegate11<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11) const) {
  1.1175 +	return FastDelegate11<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, FASTDLGT_RETTYPE>(x, func);
  1.1176 +}
  1.1177 +
  1.1178 +template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class RetType>
  1.1179 +FastDelegate11<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11)) {
  1.1180 +	return FastDelegate11<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, FASTDLGT_RETTYPE>(func);
  1.1181 +}
  1.1182 +
  1.1183 +//N=12
  1.1184 +template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class RetType>
  1.1185 +FastDelegate12<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12)) {
  1.1186 +	return FastDelegate12<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, FASTDLGT_RETTYPE>(x, func);
  1.1187 +}
  1.1188 +
  1.1189 +template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class RetType>
  1.1190 +FastDelegate12<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12) const) {
  1.1191 +	return FastDelegate12<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, FASTDLGT_RETTYPE>(x, func);
  1.1192 +}
  1.1193 +
  1.1194 +template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class RetType>
  1.1195 +FastDelegate12<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12)) {
  1.1196 +	return FastDelegate12<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, FASTDLGT_RETTYPE>(func);
  1.1197 +}
  1.1198 +
  1.1199 +//N=13
  1.1200 +template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class RetType>
  1.1201 +FastDelegate13<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13)) {
  1.1202 +	return FastDelegate13<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, FASTDLGT_RETTYPE>(x, func);
  1.1203 +}
  1.1204 +
  1.1205 +template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class RetType>
  1.1206 +FastDelegate13<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13) const) {
  1.1207 +	return FastDelegate13<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, FASTDLGT_RETTYPE>(x, func);
  1.1208 +}
  1.1209 +
  1.1210 +template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class RetType>
  1.1211 +FastDelegate13<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13)) {
  1.1212 +	return FastDelegate13<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, FASTDLGT_RETTYPE>(func);
  1.1213 +}
  1.1214 +
  1.1215 +//N=14
  1.1216 +template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class RetType>
  1.1217 +FastDelegate14<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14)) {
  1.1218 +	return FastDelegate14<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, FASTDLGT_RETTYPE>(x, func);
  1.1219 +}
  1.1220 +
  1.1221 +template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class RetType>
  1.1222 +FastDelegate14<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14) const) {
  1.1223 +	return FastDelegate14<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, FASTDLGT_RETTYPE>(x, func);
  1.1224 +}
  1.1225 +
  1.1226 +template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class RetType>
  1.1227 +FastDelegate14<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14)) {
  1.1228 +	return FastDelegate14<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, FASTDLGT_RETTYPE>(func);
  1.1229 +}
  1.1230 +
  1.1231 +//N=15
  1.1232 +template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class RetType>
  1.1233 +FastDelegate15<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15)) {
  1.1234 +	return FastDelegate15<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, FASTDLGT_RETTYPE>(x, func);
  1.1235 +}
  1.1236 +
  1.1237 +template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class RetType>
  1.1238 +FastDelegate15<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15) const) {
  1.1239 +	return FastDelegate15<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, FASTDLGT_RETTYPE>(x, func);
  1.1240 +}
  1.1241 +
  1.1242 +template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class RetType>
  1.1243 +FastDelegate15<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15)) {
  1.1244 +	return FastDelegate15<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, FASTDLGT_RETTYPE>(func);
  1.1245 +}
  1.1246 +
  1.1247 +//N=16
  1.1248 +template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16, class RetType>
  1.1249 +FastDelegate16<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16)) {
  1.1250 +	return FastDelegate16<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, FASTDLGT_RETTYPE>(x, func);
  1.1251 +}
  1.1252 +
  1.1253 +template <class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16, class RetType>
  1.1254 +FastDelegate16<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, FASTDLGT_RETTYPE> MakeDelegate(Y* x, RetType (X::*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16) const) {
  1.1255 +	return FastDelegate16<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, FASTDLGT_RETTYPE>(x, func);
  1.1256 +}
  1.1257 +
  1.1258 +template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Param9, class Param10, class Param11, class Param12, class Param13, class Param14, class Param15, class Param16, class RetType>
  1.1259 +FastDelegate16<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, FASTDLGT_RETTYPE> MakeDelegate(RetType (*func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8, Param9 p9, Param10 p10, Param11 p11, Param12 p12, Param13 p13, Param14 p14, Param15 p15, Param16 p16)) {
  1.1260 +	return FastDelegate16<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, Param9, Param10, Param11, Param12, Param13, Param14, Param15, Param16, FASTDLGT_RETTYPE>(func);
  1.1261 +}
  1.1262 +
  1.1263  
  1.1264   // clean up after ourselves...
  1.1265  #undef FASTDLGT_RETTYPE