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