guiguitant théo
/
lorawan-master
Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Embed:
(wiki syntax)
Show/hide line numbers
Callback.h
00001 /* mbed Microcontroller Library 00002 * Copyright (c) 2006-2015 ARM Limited 00003 * 00004 * Licensed under the Apache License, Version 2.0 (the "License"); 00005 * you may not use this file except in compliance with the License. 00006 * You may obtain a copy of the License at 00007 * 00008 * http://www.apache.org/licenses/LICENSE-2.0 00009 * 00010 * Unless required by applicable law or agreed to in writing, software 00011 * distributed under the License is distributed on an "AS IS" BASIS, 00012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 00013 * See the License for the specific language governing permissions and 00014 * limitations under the License. 00015 */ 00016 #ifndef MBED_CALLBACK_H 00017 #define MBED_CALLBACK_H 00018 00019 #include <string.h> 00020 #include <stdint.h> 00021 #include <new> 00022 #include "platform/mbed_assert.h" 00023 #include "platform/mbed_toolchain.h" 00024 00025 namespace mbed { 00026 /** \addtogroup platform */ 00027 /** @{*/ 00028 00029 00030 /** Callback class based on template specialization 00031 * 00032 * @Note Synchronization level: Not protected 00033 */ 00034 template <typename F> 00035 class Callback; 00036 00037 // Internal sfinae declarations 00038 // 00039 // These are used to eliminate overloads based on type attributes 00040 // 1. Does a function object have a call operator 00041 // 2. Does a function object fit in the available storage 00042 // 00043 // These eliminations are handled cleanly by the compiler and avoid 00044 // massive and misleading error messages when confronted with an 00045 // invalid type (or worse, runtime failures) 00046 namespace detail { 00047 struct nil {}; 00048 00049 template <bool B, typename R = nil> 00050 struct enable_if { typedef R type; }; 00051 00052 template <typename R> 00053 struct enable_if<false, R> {}; 00054 00055 template <typename M, M> 00056 struct is_type { 00057 static const bool value = true; 00058 }; 00059 } 00060 00061 /** Callback class based on template specialization 00062 * 00063 * @Note Synchronization level: Not protected 00064 */ 00065 template <typename R> 00066 class Callback<R()> { 00067 public: 00068 /** Create a Callback with a static function 00069 * @param func Static function to attach 00070 */ 00071 Callback(R (*func)() = 0) { 00072 if (!func) { 00073 _ops = 0; 00074 } else { 00075 generate(func); 00076 } 00077 } 00078 00079 /** Attach a Callback 00080 * @param func The Callback to attach 00081 */ 00082 Callback(const Callback<R()> &func) { 00083 if (func._ops) { 00084 func._ops->move(this, &func); 00085 } 00086 _ops = func._ops; 00087 } 00088 00089 /** Create a Callback with a member function 00090 * @param obj Pointer to object to invoke member function on 00091 * @param method Member function to attach 00092 */ 00093 template<typename T, typename U> 00094 Callback(U *obj, R (T::*method)()) { 00095 generate(method_context<T, R (T::*)()>(obj, method)); 00096 } 00097 00098 /** Create a Callback with a member function 00099 * @param obj Pointer to object to invoke member function on 00100 * @param method Member function to attach 00101 */ 00102 template<typename T, typename U> 00103 Callback(const U *obj, R (T::*method)() const) { 00104 generate(method_context<const T, R (T::*)() const>(obj, method)); 00105 } 00106 00107 /** Create a Callback with a member function 00108 * @param obj Pointer to object to invoke member function on 00109 * @param method Member function to attach 00110 */ 00111 template<typename T, typename U> 00112 Callback(volatile U *obj, R (T::*method)() volatile) { 00113 generate(method_context<volatile T, R (T::*)() volatile>(obj, method)); 00114 } 00115 00116 /** Create a Callback with a member function 00117 * @param obj Pointer to object to invoke member function on 00118 * @param method Member function to attach 00119 */ 00120 template<typename T, typename U> 00121 Callback(const volatile U *obj, R (T::*method)() const volatile) { 00122 generate(method_context<const volatile T, R (T::*)() const volatile>(obj, method)); 00123 } 00124 00125 /** Create a Callback with a static function and bound pointer 00126 * @param func Static function to attach 00127 * @param arg Pointer argument to function 00128 */ 00129 template<typename T, typename U> 00130 Callback(R (*func)(T*), U *arg) { 00131 generate(function_context<R (*)(T*), T>(func, arg)); 00132 } 00133 00134 /** Create a Callback with a static function and bound pointer 00135 * @param func Static function to attach 00136 * @param arg Pointer argument to function 00137 */ 00138 template<typename T, typename U> 00139 Callback(R (*func)(const T*), const U *arg) { 00140 generate(function_context<R (*)(const T*), const T>(func, arg)); 00141 } 00142 00143 /** Create a Callback with a static function and bound pointer 00144 * @param func Static function to attach 00145 * @param arg Pointer argument to function 00146 */ 00147 template<typename T, typename U> 00148 Callback(R (*func)(volatile T*), volatile U *arg) { 00149 generate(function_context<R (*)(volatile T*), volatile T>(func, arg)); 00150 } 00151 00152 /** Create a Callback with a static function and bound pointer 00153 * @param func Static function to attach 00154 * @param arg Pointer argument to function 00155 */ 00156 template<typename T, typename U> 00157 Callback(R (*func)(const volatile T*), const volatile U *arg) { 00158 generate(function_context<R (*)(const volatile T*), const volatile T>(func, arg)); 00159 } 00160 00161 /** Create a Callback with a function object 00162 * @param func Function object to attach 00163 * @note The function object is limited to a single word of storage 00164 */ 00165 template <typename F> 00166 Callback(F f, typename detail::enable_if< 00167 detail::is_type<R (F::*)(), &F::operator()>::value && 00168 sizeof(F) <= sizeof(uintptr_t) 00169 >::type = detail::nil()) { 00170 generate(f); 00171 } 00172 00173 /** Create a Callback with a function object 00174 * @param func Function object to attach 00175 * @note The function object is limited to a single word of storage 00176 */ 00177 template <typename F> 00178 Callback(const F f, typename detail::enable_if< 00179 detail::is_type<R (F::*)() const, &F::operator()>::value && 00180 sizeof(F) <= sizeof(uintptr_t) 00181 >::type = detail::nil()) { 00182 generate(f); 00183 } 00184 00185 /** Create a Callback with a function object 00186 * @param func Function object to attach 00187 * @note The function object is limited to a single word of storage 00188 */ 00189 template <typename F> 00190 Callback(volatile F f, typename detail::enable_if< 00191 detail::is_type<R (F::*)() volatile, &F::operator()>::value && 00192 sizeof(F) <= sizeof(uintptr_t) 00193 >::type = detail::nil()) { 00194 generate(f); 00195 } 00196 00197 /** Create a Callback with a function object 00198 * @param func Function object to attach 00199 * @note The function object is limited to a single word of storage 00200 */ 00201 template <typename F> 00202 Callback(const volatile F f, typename detail::enable_if< 00203 detail::is_type<R (F::*)() const volatile, &F::operator()>::value && 00204 sizeof(F) <= sizeof(uintptr_t) 00205 >::type = detail::nil()) { 00206 generate(f); 00207 } 00208 00209 /** Create a Callback with a static function and bound pointer 00210 * @param obj Pointer to object to bind to function 00211 * @param func Static function to attach 00212 * @deprecated 00213 * Arguments to callback have been reordered to Callback(func, arg) 00214 */ 00215 template<typename T, typename U> 00216 MBED_DEPRECATED_SINCE("mbed-os-5.1", 00217 "Arguments to callback have been reordered to Callback(func, arg)") 00218 Callback(U *obj, R (*func)(T*)) { 00219 new (this) Callback(func, obj); 00220 } 00221 00222 /** Create a Callback with a static function and bound pointer 00223 * @param obj Pointer to object to bind to function 00224 * @param func Static function to attach 00225 * @deprecated 00226 * Arguments to callback have been reordered to Callback(func, arg) 00227 */ 00228 template<typename T, typename U> 00229 MBED_DEPRECATED_SINCE("mbed-os-5.1", 00230 "Arguments to callback have been reordered to Callback(func, arg)") 00231 Callback(const U *obj, R (*func)(const T*)) { 00232 new (this) Callback(func, obj); 00233 } 00234 00235 /** Create a Callback with a static function and bound pointer 00236 * @param obj Pointer to object to bind to function 00237 * @param func Static function to attach 00238 * @deprecated 00239 * Arguments to callback have been reordered to Callback(func, arg) 00240 */ 00241 template<typename T, typename U> 00242 MBED_DEPRECATED_SINCE("mbed-os-5.1", 00243 "Arguments to callback have been reordered to Callback(func, arg)") 00244 Callback(volatile U *obj, R (*func)(volatile T*)) { 00245 new (this) Callback(func, obj); 00246 } 00247 00248 /** Create a Callback with a static function and bound pointer 00249 * @param obj Pointer to object to bind to function 00250 * @param func Static function to attach 00251 * @deprecated 00252 * Arguments to callback have been reordered to Callback(func, arg) 00253 */ 00254 template<typename T, typename U> 00255 MBED_DEPRECATED_SINCE("mbed-os-5.1", 00256 "Arguments to callback have been reordered to Callback(func, arg)") 00257 Callback(const volatile U *obj, R (*func)(const volatile T*)) { 00258 new (this) Callback(func, obj); 00259 } 00260 00261 /** Destroy a callback 00262 */ 00263 ~Callback() { 00264 if (_ops) { 00265 _ops->dtor(this); 00266 } 00267 } 00268 00269 /** Attach a static function 00270 * @param func Static function to attach 00271 * @deprecated 00272 * Replaced by simple assignment 'Callback cb = func' 00273 */ 00274 MBED_DEPRECATED_SINCE("mbed-os-5.4", 00275 "Replaced by simple assignment 'Callback cb = func") 00276 void attach(R (*func)()) { 00277 this->~Callback(); 00278 new (this) Callback(func); 00279 } 00280 00281 /** Attach a Callback 00282 * @param func The Callback to attach 00283 * @deprecated 00284 * Replaced by simple assignment 'Callback cb = func' 00285 */ 00286 MBED_DEPRECATED_SINCE("mbed-os-5.4", 00287 "Replaced by simple assignment 'Callback cb = func") 00288 void attach(const Callback<R()> &func) { 00289 this->~Callback(); 00290 new (this) Callback(func); 00291 } 00292 00293 /** Attach a member function 00294 * @param obj Pointer to object to invoke member function on 00295 * @param method Member function to attach 00296 * @deprecated 00297 * Replaced by simple assignment 'Callback cb = func' 00298 */ 00299 template<typename T, typename U> 00300 MBED_DEPRECATED_SINCE("mbed-os-5.4", 00301 "Replaced by simple assignment 'Callback cb = func") 00302 void attach(U *obj, R (T::*method)()) { 00303 this->~Callback(); 00304 new (this) Callback(obj, method); 00305 } 00306 00307 /** Attach a member function 00308 * @param obj Pointer to object to invoke member function on 00309 * @param method Member function to attach 00310 * @deprecated 00311 * Replaced by simple assignment 'Callback cb = func' 00312 */ 00313 template<typename T, typename U> 00314 MBED_DEPRECATED_SINCE("mbed-os-5.4", 00315 "Replaced by simple assignment 'Callback cb = func") 00316 void attach(const U *obj, R (T::*method)() const) { 00317 this->~Callback(); 00318 new (this) Callback(obj, method); 00319 } 00320 00321 /** Attach a member function 00322 * @param obj Pointer to object to invoke member function on 00323 * @param method Member function to attach 00324 * @deprecated 00325 * Replaced by simple assignment 'Callback cb = func' 00326 */ 00327 template<typename T, typename U> 00328 MBED_DEPRECATED_SINCE("mbed-os-5.4", 00329 "Replaced by simple assignment 'Callback cb = func") 00330 void attach(volatile U *obj, R (T::*method)() volatile) { 00331 this->~Callback(); 00332 new (this) Callback(obj, method); 00333 } 00334 00335 /** Attach a member function 00336 * @param obj Pointer to object to invoke member function on 00337 * @param method Member function to attach 00338 * @deprecated 00339 * Replaced by simple assignment 'Callback cb = func' 00340 */ 00341 template<typename T, typename U> 00342 MBED_DEPRECATED_SINCE("mbed-os-5.4", 00343 "Replaced by simple assignment 'Callback cb = func") 00344 void attach(const volatile U *obj, R (T::*method)() const volatile) { 00345 this->~Callback(); 00346 new (this) Callback(obj, method); 00347 } 00348 00349 /** Attach a static function with a bound pointer 00350 * @param func Static function to attach 00351 * @param arg Pointer argument to function 00352 * @deprecated 00353 * Replaced by simple assignment 'Callback cb = func' 00354 */ 00355 template <typename T, typename U> 00356 MBED_DEPRECATED_SINCE("mbed-os-5.4", 00357 "Replaced by simple assignment 'Callback cb = func") 00358 void attach(R (*func)(T*), U *arg) { 00359 this->~Callback(); 00360 new (this) Callback(func, arg); 00361 } 00362 00363 /** Attach a static function with a bound pointer 00364 * @param func Static function to attach 00365 * @param arg Pointer argument to function 00366 * @deprecated 00367 * Replaced by simple assignment 'Callback cb = func' 00368 */ 00369 template <typename T, typename U> 00370 MBED_DEPRECATED_SINCE("mbed-os-5.4", 00371 "Replaced by simple assignment 'Callback cb = func") 00372 void attach(R (*func)(const T*), const U *arg) { 00373 this->~Callback(); 00374 new (this) Callback(func, arg); 00375 } 00376 00377 /** Attach a static function with a bound pointer 00378 * @param func Static function to attach 00379 * @param arg Pointer argument to function 00380 * @deprecated 00381 * Replaced by simple assignment 'Callback cb = func' 00382 */ 00383 template <typename T, typename U> 00384 MBED_DEPRECATED_SINCE("mbed-os-5.4", 00385 "Replaced by simple assignment 'Callback cb = func") 00386 void attach(R (*func)(volatile T*), volatile U *arg) { 00387 this->~Callback(); 00388 new (this) Callback(func, arg); 00389 } 00390 00391 /** Attach a static function with a bound pointer 00392 * @param func Static function to attach 00393 * @param arg Pointer argument to function 00394 * @deprecated 00395 * Replaced by simple assignment 'Callback cb = func' 00396 */ 00397 template <typename T, typename U> 00398 MBED_DEPRECATED_SINCE("mbed-os-5.4", 00399 "Replaced by simple assignment 'Callback cb = func") 00400 void attach(R (*func)(const volatile T*), const volatile U *arg) { 00401 this->~Callback(); 00402 new (this) Callback(func, arg); 00403 } 00404 00405 /** Attach a function object 00406 * @param func Function object to attach 00407 * @note The function object is limited to a single word of storage 00408 * @deprecated 00409 * Replaced by simple assignment 'Callback cb = func' 00410 */ 00411 template <typename F> 00412 MBED_DEPRECATED_SINCE("mbed-os-5.4", 00413 "Replaced by simple assignment 'Callback cb = func") 00414 void attach(F f, typename detail::enable_if< 00415 detail::is_type<R (F::*)(), &F::operator()>::value && 00416 sizeof(F) <= sizeof(uintptr_t) 00417 >::type = detail::nil()) { 00418 this->~Callback(); 00419 new (this) Callback(f); 00420 } 00421 00422 /** Attach a function object 00423 * @param func Function object to attach 00424 * @note The function object is limited to a single word of storage 00425 * @deprecated 00426 * Replaced by simple assignment 'Callback cb = func' 00427 */ 00428 template <typename F> 00429 MBED_DEPRECATED_SINCE("mbed-os-5.4", 00430 "Replaced by simple assignment 'Callback cb = func") 00431 void attach(const F f, typename detail::enable_if< 00432 detail::is_type<R (F::*)() const, &F::operator()>::value && 00433 sizeof(F) <= sizeof(uintptr_t) 00434 >::type = detail::nil()) { 00435 this->~Callback(); 00436 new (this) Callback(f); 00437 } 00438 00439 /** Attach a function object 00440 * @param func Function object to attach 00441 * @note The function object is limited to a single word of storage 00442 * @deprecated 00443 * Replaced by simple assignment 'Callback cb = func' 00444 */ 00445 template <typename F> 00446 MBED_DEPRECATED_SINCE("mbed-os-5.4", 00447 "Replaced by simple assignment 'Callback cb = func") 00448 void attach(volatile F f, typename detail::enable_if< 00449 detail::is_type<R (F::*)() volatile, &F::operator()>::value && 00450 sizeof(F) <= sizeof(uintptr_t) 00451 >::type = detail::nil()) { 00452 this->~Callback(); 00453 new (this) Callback(f); 00454 } 00455 00456 /** Attach a function object 00457 * @param func Function object to attach 00458 * @note The function object is limited to a single word of storage 00459 * @deprecated 00460 * Replaced by simple assignment 'Callback cb = func' 00461 */ 00462 template <typename F> 00463 MBED_DEPRECATED_SINCE("mbed-os-5.4", 00464 "Replaced by simple assignment 'Callback cb = func") 00465 void attach(const volatile F f, typename detail::enable_if< 00466 detail::is_type<R (F::*)() const volatile, &F::operator()>::value && 00467 sizeof(F) <= sizeof(uintptr_t) 00468 >::type = detail::nil()) { 00469 this->~Callback(); 00470 new (this) Callback(f); 00471 } 00472 00473 /** Attach a static function with a bound pointer 00474 * @param obj Pointer to object to bind to function 00475 * @param func Static function to attach 00476 * @deprecated 00477 * Arguments to callback have been reordered to attach(func, arg) 00478 */ 00479 template <typename T, typename U> 00480 MBED_DEPRECATED_SINCE("mbed-os-5.1", 00481 "Arguments to callback have been reordered to attach(func, arg)") 00482 void attach(U *obj, R (*func)(T*)) { 00483 this->~Callback(); 00484 new (this) Callback(func, obj); 00485 } 00486 00487 /** Attach a static function with a bound pointer 00488 * @param obj Pointer to object to bind to function 00489 * @param func Static function to attach 00490 * @deprecated 00491 * Arguments to callback have been reordered to attach(func, arg) 00492 */ 00493 template <typename T, typename U> 00494 MBED_DEPRECATED_SINCE("mbed-os-5.1", 00495 "Arguments to callback have been reordered to attach(func, arg)") 00496 void attach(const U *obj, R (*func)(const T*)) { 00497 this->~Callback(); 00498 new (this) Callback(func, obj); 00499 } 00500 00501 /** Attach a static function with a bound pointer 00502 * @param obj Pointer to object to bind to function 00503 * @param func Static function to attach 00504 * @deprecated 00505 * Arguments to callback have been reordered to attach(func, arg) 00506 */ 00507 template <typename T, typename U> 00508 MBED_DEPRECATED_SINCE("mbed-os-5.1", 00509 "Arguments to callback have been reordered to attach(func, arg)") 00510 void attach(volatile U *obj, R (*func)(volatile T*)) { 00511 this->~Callback(); 00512 new (this) Callback(func, obj); 00513 } 00514 00515 /** Attach a static function with a bound pointer 00516 * @param obj Pointer to object to bind to function 00517 * @param func Static function to attach 00518 * @deprecated 00519 * Arguments to callback have been reordered to attach(func, arg) 00520 */ 00521 template <typename T, typename U> 00522 MBED_DEPRECATED_SINCE("mbed-os-5.1", 00523 "Arguments to callback have been reordered to attach(func, arg)") 00524 void attach(const volatile U *obj, R (*func)(const volatile T*)) { 00525 this->~Callback(); 00526 new (this) Callback(func, obj); 00527 } 00528 00529 /** Assign a callback 00530 */ 00531 Callback &operator=(const Callback &that) { 00532 if (this != &that) { 00533 this->~Callback(); 00534 new (this) Callback(that); 00535 } 00536 00537 return *this; 00538 } 00539 00540 /** Call the attached function 00541 */ 00542 R call() const { 00543 MBED_ASSERT(_ops); 00544 return _ops->call(this); 00545 } 00546 00547 /** Call the attached function 00548 */ 00549 R operator()() const { 00550 return call(); 00551 } 00552 00553 /** Test if function has been attached 00554 */ 00555 operator bool() const { 00556 return _ops; 00557 } 00558 00559 /** Test for equality 00560 */ 00561 friend bool operator==(const Callback &l, const Callback &r) { 00562 return memcmp(&l, &r, sizeof(Callback)) == 0; 00563 } 00564 00565 /** Test for inequality 00566 */ 00567 friend bool operator!=(const Callback &l, const Callback &r) { 00568 return !(l == r); 00569 } 00570 00571 /** Static thunk for passing as C-style function 00572 * @param func Callback to call passed as void pointer 00573 */ 00574 static R thunk(void *func) { 00575 return static_cast<Callback*>(func)->call(); 00576 } 00577 00578 private: 00579 // Stored as pointer to function and pointer to optional object 00580 // Function pointer is stored as union of possible function types 00581 // to garuntee proper size and alignment 00582 struct _class; 00583 union { 00584 void (*_staticfunc)(); 00585 void (*_boundfunc)(_class*); 00586 void (_class::*_methodfunc)(); 00587 } _func; 00588 void *_obj; 00589 00590 // Dynamically dispatched operations 00591 const struct ops { 00592 R (*call)(const void*); 00593 void (*move)(void*, const void*); 00594 void (*dtor)(void*); 00595 } *_ops; 00596 00597 // Generate operations for function object 00598 template <typename F> 00599 void generate(const F &f) { 00600 static const ops ops = { 00601 &Callback::function_call<F>, 00602 &Callback::function_move<F>, 00603 &Callback::function_dtor<F>, 00604 }; 00605 00606 MBED_STATIC_ASSERT(sizeof(Callback) - sizeof(_ops) >= sizeof(F), 00607 "Type F must not exceed the size of the Callback class"); 00608 new (this) F(f); 00609 _ops = &ops; 00610 } 00611 00612 // Function attributes 00613 template <typename F> 00614 static R function_call(const void *p) { 00615 return (*(F*)p)(); 00616 } 00617 00618 template <typename F> 00619 static void function_move(void *d, const void *p) { 00620 new (d) F(*(F*)p); 00621 } 00622 00623 template <typename F> 00624 static void function_dtor(void *p) { 00625 ((F*)p)->~F(); 00626 } 00627 00628 // Wrappers for functions with context 00629 template <typename O, typename M> 00630 struct method_context { 00631 M method; 00632 O *obj; 00633 00634 method_context(O *obj, M method) 00635 : method(method), obj(obj) {} 00636 00637 R operator()() const { 00638 return (obj->*method)(); 00639 } 00640 }; 00641 00642 template <typename F, typename A> 00643 struct function_context { 00644 F func; 00645 A *arg; 00646 00647 function_context(F func, A *arg) 00648 : func(func), arg(arg) {} 00649 00650 R operator()() const { 00651 return func(arg); 00652 } 00653 }; 00654 }; 00655 00656 /** Callback class based on template specialization 00657 * 00658 * @Note Synchronization level: Not protected 00659 */ 00660 template <typename R, typename A0> 00661 class Callback<R(A0)> { 00662 public: 00663 /** Create a Callback with a static function 00664 * @param func Static function to attach 00665 */ 00666 Callback(R (*func)(A0) = 0) { 00667 if (!func) { 00668 _ops = 0; 00669 } else { 00670 generate(func); 00671 } 00672 } 00673 00674 /** Attach a Callback 00675 * @param func The Callback to attach 00676 */ 00677 Callback(const Callback<R(A0)> &func) { 00678 if (func._ops) { 00679 func._ops->move(this, &func); 00680 } 00681 _ops = func._ops; 00682 } 00683 00684 /** Create a Callback with a member function 00685 * @param obj Pointer to object to invoke member function on 00686 * @param method Member function to attach 00687 */ 00688 template<typename T, typename U> 00689 Callback(U *obj, R (T::*method)(A0)) { 00690 generate(method_context<T, R (T::*)(A0)>(obj, method)); 00691 } 00692 00693 /** Create a Callback with a member function 00694 * @param obj Pointer to object to invoke member function on 00695 * @param method Member function to attach 00696 */ 00697 template<typename T, typename U> 00698 Callback(const U *obj, R (T::*method)(A0) const) { 00699 generate(method_context<const T, R (T::*)(A0) const>(obj, method)); 00700 } 00701 00702 /** Create a Callback with a member function 00703 * @param obj Pointer to object to invoke member function on 00704 * @param method Member function to attach 00705 */ 00706 template<typename T, typename U> 00707 Callback(volatile U *obj, R (T::*method)(A0) volatile) { 00708 generate(method_context<volatile T, R (T::*)(A0) volatile>(obj, method)); 00709 } 00710 00711 /** Create a Callback with a member function 00712 * @param obj Pointer to object to invoke member function on 00713 * @param method Member function to attach 00714 */ 00715 template<typename T, typename U> 00716 Callback(const volatile U *obj, R (T::*method)(A0) const volatile) { 00717 generate(method_context<const volatile T, R (T::*)(A0) const volatile>(obj, method)); 00718 } 00719 00720 /** Create a Callback with a static function and bound pointer 00721 * @param func Static function to attach 00722 * @param arg Pointer argument to function 00723 */ 00724 template<typename T, typename U> 00725 Callback(R (*func)(T*, A0), U *arg) { 00726 generate(function_context<R (*)(T*, A0), T>(func, arg)); 00727 } 00728 00729 /** Create a Callback with a static function and bound pointer 00730 * @param func Static function to attach 00731 * @param arg Pointer argument to function 00732 */ 00733 template<typename T, typename U> 00734 Callback(R (*func)(const T*, A0), const U *arg) { 00735 generate(function_context<R (*)(const T*, A0), const T>(func, arg)); 00736 } 00737 00738 /** Create a Callback with a static function and bound pointer 00739 * @param func Static function to attach 00740 * @param arg Pointer argument to function 00741 */ 00742 template<typename T, typename U> 00743 Callback(R (*func)(volatile T*, A0), volatile U *arg) { 00744 generate(function_context<R (*)(volatile T*, A0), volatile T>(func, arg)); 00745 } 00746 00747 /** Create a Callback with a static function and bound pointer 00748 * @param func Static function to attach 00749 * @param arg Pointer argument to function 00750 */ 00751 template<typename T, typename U> 00752 Callback(R (*func)(const volatile T*, A0), const volatile U *arg) { 00753 generate(function_context<R (*)(const volatile T*, A0), const volatile T>(func, arg)); 00754 } 00755 00756 /** Create a Callback with a function object 00757 * @param func Function object to attach 00758 * @note The function object is limited to a single word of storage 00759 */ 00760 template <typename F> 00761 Callback(F f, typename detail::enable_if< 00762 detail::is_type<R (F::*)(A0), &F::operator()>::value && 00763 sizeof(F) <= sizeof(uintptr_t) 00764 >::type = detail::nil()) { 00765 generate(f); 00766 } 00767 00768 /** Create a Callback with a function object 00769 * @param func Function object to attach 00770 * @note The function object is limited to a single word of storage 00771 */ 00772 template <typename F> 00773 Callback(const F f, typename detail::enable_if< 00774 detail::is_type<R (F::*)(A0) const, &F::operator()>::value && 00775 sizeof(F) <= sizeof(uintptr_t) 00776 >::type = detail::nil()) { 00777 generate(f); 00778 } 00779 00780 /** Create a Callback with a function object 00781 * @param func Function object to attach 00782 * @note The function object is limited to a single word of storage 00783 */ 00784 template <typename F> 00785 Callback(volatile F f, typename detail::enable_if< 00786 detail::is_type<R (F::*)(A0) volatile, &F::operator()>::value && 00787 sizeof(F) <= sizeof(uintptr_t) 00788 >::type = detail::nil()) { 00789 generate(f); 00790 } 00791 00792 /** Create a Callback with a function object 00793 * @param func Function object to attach 00794 * @note The function object is limited to a single word of storage 00795 */ 00796 template <typename F> 00797 Callback(const volatile F f, typename detail::enable_if< 00798 detail::is_type<R (F::*)(A0) const volatile, &F::operator()>::value && 00799 sizeof(F) <= sizeof(uintptr_t) 00800 >::type = detail::nil()) { 00801 generate(f); 00802 } 00803 00804 /** Create a Callback with a static function and bound pointer 00805 * @param obj Pointer to object to bind to function 00806 * @param func Static function to attach 00807 * @deprecated 00808 * Arguments to callback have been reordered to Callback(func, arg) 00809 */ 00810 template<typename T, typename U> 00811 MBED_DEPRECATED_SINCE("mbed-os-5.1", 00812 "Arguments to callback have been reordered to Callback(func, arg)") 00813 Callback(U *obj, R (*func)(T*, A0)) { 00814 new (this) Callback(func, obj); 00815 } 00816 00817 /** Create a Callback with a static function and bound pointer 00818 * @param obj Pointer to object to bind to function 00819 * @param func Static function to attach 00820 * @deprecated 00821 * Arguments to callback have been reordered to Callback(func, arg) 00822 */ 00823 template<typename T, typename U> 00824 MBED_DEPRECATED_SINCE("mbed-os-5.1", 00825 "Arguments to callback have been reordered to Callback(func, arg)") 00826 Callback(const U *obj, R (*func)(const T*, A0)) { 00827 new (this) Callback(func, obj); 00828 } 00829 00830 /** Create a Callback with a static function and bound pointer 00831 * @param obj Pointer to object to bind to function 00832 * @param func Static function to attach 00833 * @deprecated 00834 * Arguments to callback have been reordered to Callback(func, arg) 00835 */ 00836 template<typename T, typename U> 00837 MBED_DEPRECATED_SINCE("mbed-os-5.1", 00838 "Arguments to callback have been reordered to Callback(func, arg)") 00839 Callback(volatile U *obj, R (*func)(volatile T*, A0)) { 00840 new (this) Callback(func, obj); 00841 } 00842 00843 /** Create a Callback with a static function and bound pointer 00844 * @param obj Pointer to object to bind to function 00845 * @param func Static function to attach 00846 * @deprecated 00847 * Arguments to callback have been reordered to Callback(func, arg) 00848 */ 00849 template<typename T, typename U> 00850 MBED_DEPRECATED_SINCE("mbed-os-5.1", 00851 "Arguments to callback have been reordered to Callback(func, arg)") 00852 Callback(const volatile U *obj, R (*func)(const volatile T*, A0)) { 00853 new (this) Callback(func, obj); 00854 } 00855 00856 /** Destroy a callback 00857 */ 00858 ~Callback() { 00859 if (_ops) { 00860 _ops->dtor(this); 00861 } 00862 } 00863 00864 /** Attach a static function 00865 * @param func Static function to attach 00866 * @deprecated 00867 * Replaced by simple assignment 'Callback cb = func' 00868 */ 00869 MBED_DEPRECATED_SINCE("mbed-os-5.4", 00870 "Replaced by simple assignment 'Callback cb = func") 00871 void attach(R (*func)(A0)) { 00872 this->~Callback(); 00873 new (this) Callback(func); 00874 } 00875 00876 /** Attach a Callback 00877 * @param func The Callback to attach 00878 * @deprecated 00879 * Replaced by simple assignment 'Callback cb = func' 00880 */ 00881 MBED_DEPRECATED_SINCE("mbed-os-5.4", 00882 "Replaced by simple assignment 'Callback cb = func") 00883 void attach(const Callback<R(A0)> &func) { 00884 this->~Callback(); 00885 new (this) Callback(func); 00886 } 00887 00888 /** Attach a member function 00889 * @param obj Pointer to object to invoke member function on 00890 * @param method Member function to attach 00891 * @deprecated 00892 * Replaced by simple assignment 'Callback cb = func' 00893 */ 00894 template<typename T, typename U> 00895 MBED_DEPRECATED_SINCE("mbed-os-5.4", 00896 "Replaced by simple assignment 'Callback cb = func") 00897 void attach(U *obj, R (T::*method)(A0)) { 00898 this->~Callback(); 00899 new (this) Callback(obj, method); 00900 } 00901 00902 /** Attach a member function 00903 * @param obj Pointer to object to invoke member function on 00904 * @param method Member function to attach 00905 * @deprecated 00906 * Replaced by simple assignment 'Callback cb = func' 00907 */ 00908 template<typename T, typename U> 00909 MBED_DEPRECATED_SINCE("mbed-os-5.4", 00910 "Replaced by simple assignment 'Callback cb = func") 00911 void attach(const U *obj, R (T::*method)(A0) const) { 00912 this->~Callback(); 00913 new (this) Callback(obj, method); 00914 } 00915 00916 /** Attach a member function 00917 * @param obj Pointer to object to invoke member function on 00918 * @param method Member function to attach 00919 * @deprecated 00920 * Replaced by simple assignment 'Callback cb = func' 00921 */ 00922 template<typename T, typename U> 00923 MBED_DEPRECATED_SINCE("mbed-os-5.4", 00924 "Replaced by simple assignment 'Callback cb = func") 00925 void attach(volatile U *obj, R (T::*method)(A0) volatile) { 00926 this->~Callback(); 00927 new (this) Callback(obj, method); 00928 } 00929 00930 /** Attach a member function 00931 * @param obj Pointer to object to invoke member function on 00932 * @param method Member function to attach 00933 * @deprecated 00934 * Replaced by simple assignment 'Callback cb = func' 00935 */ 00936 template<typename T, typename U> 00937 MBED_DEPRECATED_SINCE("mbed-os-5.4", 00938 "Replaced by simple assignment 'Callback cb = func") 00939 void attach(const volatile U *obj, R (T::*method)(A0) const volatile) { 00940 this->~Callback(); 00941 new (this) Callback(obj, method); 00942 } 00943 00944 /** Attach a static function with a bound pointer 00945 * @param func Static function to attach 00946 * @param arg Pointer argument to function 00947 * @deprecated 00948 * Replaced by simple assignment 'Callback cb = func' 00949 */ 00950 template <typename T, typename U> 00951 MBED_DEPRECATED_SINCE("mbed-os-5.4", 00952 "Replaced by simple assignment 'Callback cb = func") 00953 void attach(R (*func)(T*, A0), U *arg) { 00954 this->~Callback(); 00955 new (this) Callback(func, arg); 00956 } 00957 00958 /** Attach a static function with a bound pointer 00959 * @param func Static function to attach 00960 * @param arg Pointer argument to function 00961 * @deprecated 00962 * Replaced by simple assignment 'Callback cb = func' 00963 */ 00964 template <typename T, typename U> 00965 MBED_DEPRECATED_SINCE("mbed-os-5.4", 00966 "Replaced by simple assignment 'Callback cb = func") 00967 void attach(R (*func)(const T*, A0), const U *arg) { 00968 this->~Callback(); 00969 new (this) Callback(func, arg); 00970 } 00971 00972 /** Attach a static function with a bound pointer 00973 * @param func Static function to attach 00974 * @param arg Pointer argument to function 00975 * @deprecated 00976 * Replaced by simple assignment 'Callback cb = func' 00977 */ 00978 template <typename T, typename U> 00979 MBED_DEPRECATED_SINCE("mbed-os-5.4", 00980 "Replaced by simple assignment 'Callback cb = func") 00981 void attach(R (*func)(volatile T*, A0), volatile U *arg) { 00982 this->~Callback(); 00983 new (this) Callback(func, arg); 00984 } 00985 00986 /** Attach a static function with a bound pointer 00987 * @param func Static function to attach 00988 * @param arg Pointer argument to function 00989 * @deprecated 00990 * Replaced by simple assignment 'Callback cb = func' 00991 */ 00992 template <typename T, typename U> 00993 MBED_DEPRECATED_SINCE("mbed-os-5.4", 00994 "Replaced by simple assignment 'Callback cb = func") 00995 void attach(R (*func)(const volatile T*, A0), const volatile U *arg) { 00996 this->~Callback(); 00997 new (this) Callback(func, arg); 00998 } 00999 01000 /** Attach a function object 01001 * @param func Function object to attach 01002 * @note The function object is limited to a single word of storage 01003 * @deprecated 01004 * Replaced by simple assignment 'Callback cb = func' 01005 */ 01006 template <typename F> 01007 MBED_DEPRECATED_SINCE("mbed-os-5.4", 01008 "Replaced by simple assignment 'Callback cb = func") 01009 void attach(F f, typename detail::enable_if< 01010 detail::is_type<R (F::*)(A0), &F::operator()>::value && 01011 sizeof(F) <= sizeof(uintptr_t) 01012 >::type = detail::nil()) { 01013 this->~Callback(); 01014 new (this) Callback(f); 01015 } 01016 01017 /** Attach a function object 01018 * @param func Function object to attach 01019 * @note The function object is limited to a single word of storage 01020 * @deprecated 01021 * Replaced by simple assignment 'Callback cb = func' 01022 */ 01023 template <typename F> 01024 MBED_DEPRECATED_SINCE("mbed-os-5.4", 01025 "Replaced by simple assignment 'Callback cb = func") 01026 void attach(const F f, typename detail::enable_if< 01027 detail::is_type<R (F::*)(A0) const, &F::operator()>::value && 01028 sizeof(F) <= sizeof(uintptr_t) 01029 >::type = detail::nil()) { 01030 this->~Callback(); 01031 new (this) Callback(f); 01032 } 01033 01034 /** Attach a function object 01035 * @param func Function object to attach 01036 * @note The function object is limited to a single word of storage 01037 * @deprecated 01038 * Replaced by simple assignment 'Callback cb = func' 01039 */ 01040 template <typename F> 01041 MBED_DEPRECATED_SINCE("mbed-os-5.4", 01042 "Replaced by simple assignment 'Callback cb = func") 01043 void attach(volatile F f, typename detail::enable_if< 01044 detail::is_type<R (F::*)(A0) volatile, &F::operator()>::value && 01045 sizeof(F) <= sizeof(uintptr_t) 01046 >::type = detail::nil()) { 01047 this->~Callback(); 01048 new (this) Callback(f); 01049 } 01050 01051 /** Attach a function object 01052 * @param func Function object to attach 01053 * @note The function object is limited to a single word of storage 01054 * @deprecated 01055 * Replaced by simple assignment 'Callback cb = func' 01056 */ 01057 template <typename F> 01058 MBED_DEPRECATED_SINCE("mbed-os-5.4", 01059 "Replaced by simple assignment 'Callback cb = func") 01060 void attach(const volatile F f, typename detail::enable_if< 01061 detail::is_type<R (F::*)(A0) const volatile, &F::operator()>::value && 01062 sizeof(F) <= sizeof(uintptr_t) 01063 >::type = detail::nil()) { 01064 this->~Callback(); 01065 new (this) Callback(f); 01066 } 01067 01068 /** Attach a static function with a bound pointer 01069 * @param obj Pointer to object to bind to function 01070 * @param func Static function to attach 01071 * @deprecated 01072 * Arguments to callback have been reordered to attach(func, arg) 01073 */ 01074 template <typename T, typename U> 01075 MBED_DEPRECATED_SINCE("mbed-os-5.1", 01076 "Arguments to callback have been reordered to attach(func, arg)") 01077 void attach(U *obj, R (*func)(T*, A0)) { 01078 this->~Callback(); 01079 new (this) Callback(func, obj); 01080 } 01081 01082 /** Attach a static function with a bound pointer 01083 * @param obj Pointer to object to bind to function 01084 * @param func Static function to attach 01085 * @deprecated 01086 * Arguments to callback have been reordered to attach(func, arg) 01087 */ 01088 template <typename T, typename U> 01089 MBED_DEPRECATED_SINCE("mbed-os-5.1", 01090 "Arguments to callback have been reordered to attach(func, arg)") 01091 void attach(const U *obj, R (*func)(const T*, A0)) { 01092 this->~Callback(); 01093 new (this) Callback(func, obj); 01094 } 01095 01096 /** Attach a static function with a bound pointer 01097 * @param obj Pointer to object to bind to function 01098 * @param func Static function to attach 01099 * @deprecated 01100 * Arguments to callback have been reordered to attach(func, arg) 01101 */ 01102 template <typename T, typename U> 01103 MBED_DEPRECATED_SINCE("mbed-os-5.1", 01104 "Arguments to callback have been reordered to attach(func, arg)") 01105 void attach(volatile U *obj, R (*func)(volatile T*, A0)) { 01106 this->~Callback(); 01107 new (this) Callback(func, obj); 01108 } 01109 01110 /** Attach a static function with a bound pointer 01111 * @param obj Pointer to object to bind to function 01112 * @param func Static function to attach 01113 * @deprecated 01114 * Arguments to callback have been reordered to attach(func, arg) 01115 */ 01116 template <typename T, typename U> 01117 MBED_DEPRECATED_SINCE("mbed-os-5.1", 01118 "Arguments to callback have been reordered to attach(func, arg)") 01119 void attach(const volatile U *obj, R (*func)(const volatile T*, A0)) { 01120 this->~Callback(); 01121 new (this) Callback(func, obj); 01122 } 01123 01124 /** Assign a callback 01125 */ 01126 Callback &operator=(const Callback &that) { 01127 if (this != &that) { 01128 this->~Callback(); 01129 new (this) Callback(that); 01130 } 01131 01132 return *this; 01133 } 01134 01135 /** Call the attached function 01136 */ 01137 R call(A0 a0) const { 01138 MBED_ASSERT(_ops); 01139 return _ops->call(this, a0); 01140 } 01141 01142 /** Call the attached function 01143 */ 01144 R operator()(A0 a0) const { 01145 return call(a0); 01146 } 01147 01148 /** Test if function has been attached 01149 */ 01150 operator bool() const { 01151 return _ops; 01152 } 01153 01154 /** Test for equality 01155 */ 01156 friend bool operator==(const Callback &l, const Callback &r) { 01157 return memcmp(&l, &r, sizeof(Callback)) == 0; 01158 } 01159 01160 /** Test for inequality 01161 */ 01162 friend bool operator!=(const Callback &l, const Callback &r) { 01163 return !(l == r); 01164 } 01165 01166 /** Static thunk for passing as C-style function 01167 * @param func Callback to call passed as void pointer 01168 */ 01169 static R thunk(void *func, A0 a0) { 01170 return static_cast<Callback*>(func)->call(a0); 01171 } 01172 01173 private: 01174 // Stored as pointer to function and pointer to optional object 01175 // Function pointer is stored as union of possible function types 01176 // to garuntee proper size and alignment 01177 struct _class; 01178 union { 01179 void (*_staticfunc)(A0); 01180 void (*_boundfunc)(_class*, A0); 01181 void (_class::*_methodfunc)(A0); 01182 } _func; 01183 void *_obj; 01184 01185 // Dynamically dispatched operations 01186 const struct ops { 01187 R (*call)(const void*, A0); 01188 void (*move)(void*, const void*); 01189 void (*dtor)(void*); 01190 } *_ops; 01191 01192 // Generate operations for function object 01193 template <typename F> 01194 void generate(const F &f) { 01195 static const ops ops = { 01196 &Callback::function_call<F>, 01197 &Callback::function_move<F>, 01198 &Callback::function_dtor<F>, 01199 }; 01200 01201 MBED_STATIC_ASSERT(sizeof(Callback) - sizeof(_ops) >= sizeof(F), 01202 "Type F must not exceed the size of the Callback class"); 01203 new (this) F(f); 01204 _ops = &ops; 01205 } 01206 01207 // Function attributes 01208 template <typename F> 01209 static R function_call(const void *p, A0 a0) { 01210 return (*(F*)p)(a0); 01211 } 01212 01213 template <typename F> 01214 static void function_move(void *d, const void *p) { 01215 new (d) F(*(F*)p); 01216 } 01217 01218 template <typename F> 01219 static void function_dtor(void *p) { 01220 ((F*)p)->~F(); 01221 } 01222 01223 // Wrappers for functions with context 01224 template <typename O, typename M> 01225 struct method_context { 01226 M method; 01227 O *obj; 01228 01229 method_context(O *obj, M method) 01230 : method(method), obj(obj) {} 01231 01232 R operator()(A0 a0) const { 01233 return (obj->*method)(a0); 01234 } 01235 }; 01236 01237 template <typename F, typename A> 01238 struct function_context { 01239 F func; 01240 A *arg; 01241 01242 function_context(F func, A *arg) 01243 : func(func), arg(arg) {} 01244 01245 R operator()(A0 a0) const { 01246 return func(arg, a0); 01247 } 01248 }; 01249 }; 01250 01251 /** Callback class based on template specialization 01252 * 01253 * @Note Synchronization level: Not protected 01254 */ 01255 template <typename R, typename A0, typename A1> 01256 class Callback<R(A0, A1)> { 01257 public: 01258 /** Create a Callback with a static function 01259 * @param func Static function to attach 01260 */ 01261 Callback(R (*func)(A0, A1) = 0) { 01262 if (!func) { 01263 _ops = 0; 01264 } else { 01265 generate(func); 01266 } 01267 } 01268 01269 /** Attach a Callback 01270 * @param func The Callback to attach 01271 */ 01272 Callback(const Callback<R(A0, A1)> &func) { 01273 if (func._ops) { 01274 func._ops->move(this, &func); 01275 } 01276 _ops = func._ops; 01277 } 01278 01279 /** Create a Callback with a member function 01280 * @param obj Pointer to object to invoke member function on 01281 * @param method Member function to attach 01282 */ 01283 template<typename T, typename U> 01284 Callback(U *obj, R (T::*method)(A0, A1)) { 01285 generate(method_context<T, R (T::*)(A0, A1)>(obj, method)); 01286 } 01287 01288 /** Create a Callback with a member function 01289 * @param obj Pointer to object to invoke member function on 01290 * @param method Member function to attach 01291 */ 01292 template<typename T, typename U> 01293 Callback(const U *obj, R (T::*method)(A0, A1) const) { 01294 generate(method_context<const T, R (T::*)(A0, A1) const>(obj, method)); 01295 } 01296 01297 /** Create a Callback with a member function 01298 * @param obj Pointer to object to invoke member function on 01299 * @param method Member function to attach 01300 */ 01301 template<typename T, typename U> 01302 Callback(volatile U *obj, R (T::*method)(A0, A1) volatile) { 01303 generate(method_context<volatile T, R (T::*)(A0, A1) volatile>(obj, method)); 01304 } 01305 01306 /** Create a Callback with a member function 01307 * @param obj Pointer to object to invoke member function on 01308 * @param method Member function to attach 01309 */ 01310 template<typename T, typename U> 01311 Callback(const volatile U *obj, R (T::*method)(A0, A1) const volatile) { 01312 generate(method_context<const volatile T, R (T::*)(A0, A1) const volatile>(obj, method)); 01313 } 01314 01315 /** Create a Callback with a static function and bound pointer 01316 * @param func Static function to attach 01317 * @param arg Pointer argument to function 01318 */ 01319 template<typename T, typename U> 01320 Callback(R (*func)(T*, A0, A1), U *arg) { 01321 generate(function_context<R (*)(T*, A0, A1), T>(func, arg)); 01322 } 01323 01324 /** Create a Callback with a static function and bound pointer 01325 * @param func Static function to attach 01326 * @param arg Pointer argument to function 01327 */ 01328 template<typename T, typename U> 01329 Callback(R (*func)(const T*, A0, A1), const U *arg) { 01330 generate(function_context<R (*)(const T*, A0, A1), const T>(func, arg)); 01331 } 01332 01333 /** Create a Callback with a static function and bound pointer 01334 * @param func Static function to attach 01335 * @param arg Pointer argument to function 01336 */ 01337 template<typename T, typename U> 01338 Callback(R (*func)(volatile T*, A0, A1), volatile U *arg) { 01339 generate(function_context<R (*)(volatile T*, A0, A1), volatile T>(func, arg)); 01340 } 01341 01342 /** Create a Callback with a static function and bound pointer 01343 * @param func Static function to attach 01344 * @param arg Pointer argument to function 01345 */ 01346 template<typename T, typename U> 01347 Callback(R (*func)(const volatile T*, A0, A1), const volatile U *arg) { 01348 generate(function_context<R (*)(const volatile T*, A0, A1), const volatile T>(func, arg)); 01349 } 01350 01351 /** Create a Callback with a function object 01352 * @param func Function object to attach 01353 * @note The function object is limited to a single word of storage 01354 */ 01355 template <typename F> 01356 Callback(F f, typename detail::enable_if< 01357 detail::is_type<R (F::*)(A0, A1), &F::operator()>::value && 01358 sizeof(F) <= sizeof(uintptr_t) 01359 >::type = detail::nil()) { 01360 generate(f); 01361 } 01362 01363 /** Create a Callback with a function object 01364 * @param func Function object to attach 01365 * @note The function object is limited to a single word of storage 01366 */ 01367 template <typename F> 01368 Callback(const F f, typename detail::enable_if< 01369 detail::is_type<R (F::*)(A0, A1) const, &F::operator()>::value && 01370 sizeof(F) <= sizeof(uintptr_t) 01371 >::type = detail::nil()) { 01372 generate(f); 01373 } 01374 01375 /** Create a Callback with a function object 01376 * @param func Function object to attach 01377 * @note The function object is limited to a single word of storage 01378 */ 01379 template <typename F> 01380 Callback(volatile F f, typename detail::enable_if< 01381 detail::is_type<R (F::*)(A0, A1) volatile, &F::operator()>::value && 01382 sizeof(F) <= sizeof(uintptr_t) 01383 >::type = detail::nil()) { 01384 generate(f); 01385 } 01386 01387 /** Create a Callback with a function object 01388 * @param func Function object to attach 01389 * @note The function object is limited to a single word of storage 01390 */ 01391 template <typename F> 01392 Callback(const volatile F f, typename detail::enable_if< 01393 detail::is_type<R (F::*)(A0, A1) const volatile, &F::operator()>::value && 01394 sizeof(F) <= sizeof(uintptr_t) 01395 >::type = detail::nil()) { 01396 generate(f); 01397 } 01398 01399 /** Create a Callback with a static function and bound pointer 01400 * @param obj Pointer to object to bind to function 01401 * @param func Static function to attach 01402 * @deprecated 01403 * Arguments to callback have been reordered to Callback(func, arg) 01404 */ 01405 template<typename T, typename U> 01406 MBED_DEPRECATED_SINCE("mbed-os-5.1", 01407 "Arguments to callback have been reordered to Callback(func, arg)") 01408 Callback(U *obj, R (*func)(T*, A0, A1)) { 01409 new (this) Callback(func, obj); 01410 } 01411 01412 /** Create a Callback with a static function and bound pointer 01413 * @param obj Pointer to object to bind to function 01414 * @param func Static function to attach 01415 * @deprecated 01416 * Arguments to callback have been reordered to Callback(func, arg) 01417 */ 01418 template<typename T, typename U> 01419 MBED_DEPRECATED_SINCE("mbed-os-5.1", 01420 "Arguments to callback have been reordered to Callback(func, arg)") 01421 Callback(const U *obj, R (*func)(const T*, A0, A1)) { 01422 new (this) Callback(func, obj); 01423 } 01424 01425 /** Create a Callback with a static function and bound pointer 01426 * @param obj Pointer to object to bind to function 01427 * @param func Static function to attach 01428 * @deprecated 01429 * Arguments to callback have been reordered to Callback(func, arg) 01430 */ 01431 template<typename T, typename U> 01432 MBED_DEPRECATED_SINCE("mbed-os-5.1", 01433 "Arguments to callback have been reordered to Callback(func, arg)") 01434 Callback(volatile U *obj, R (*func)(volatile T*, A0, A1)) { 01435 new (this) Callback(func, obj); 01436 } 01437 01438 /** Create a Callback with a static function and bound pointer 01439 * @param obj Pointer to object to bind to function 01440 * @param func Static function to attach 01441 * @deprecated 01442 * Arguments to callback have been reordered to Callback(func, arg) 01443 */ 01444 template<typename T, typename U> 01445 MBED_DEPRECATED_SINCE("mbed-os-5.1", 01446 "Arguments to callback have been reordered to Callback(func, arg)") 01447 Callback(const volatile U *obj, R (*func)(const volatile T*, A0, A1)) { 01448 new (this) Callback(func, obj); 01449 } 01450 01451 /** Destroy a callback 01452 */ 01453 ~Callback() { 01454 if (_ops) { 01455 _ops->dtor(this); 01456 } 01457 } 01458 01459 /** Attach a static function 01460 * @param func Static function to attach 01461 * @deprecated 01462 * Replaced by simple assignment 'Callback cb = func' 01463 */ 01464 MBED_DEPRECATED_SINCE("mbed-os-5.4", 01465 "Replaced by simple assignment 'Callback cb = func") 01466 void attach(R (*func)(A0, A1)) { 01467 this->~Callback(); 01468 new (this) Callback(func); 01469 } 01470 01471 /** Attach a Callback 01472 * @param func The Callback to attach 01473 * @deprecated 01474 * Replaced by simple assignment 'Callback cb = func' 01475 */ 01476 MBED_DEPRECATED_SINCE("mbed-os-5.4", 01477 "Replaced by simple assignment 'Callback cb = func") 01478 void attach(const Callback<R(A0, A1)> &func) { 01479 this->~Callback(); 01480 new (this) Callback(func); 01481 } 01482 01483 /** Attach a member function 01484 * @param obj Pointer to object to invoke member function on 01485 * @param method Member function to attach 01486 * @deprecated 01487 * Replaced by simple assignment 'Callback cb = func' 01488 */ 01489 template<typename T, typename U> 01490 MBED_DEPRECATED_SINCE("mbed-os-5.4", 01491 "Replaced by simple assignment 'Callback cb = func") 01492 void attach(U *obj, R (T::*method)(A0, A1)) { 01493 this->~Callback(); 01494 new (this) Callback(obj, method); 01495 } 01496 01497 /** Attach a member function 01498 * @param obj Pointer to object to invoke member function on 01499 * @param method Member function to attach 01500 * @deprecated 01501 * Replaced by simple assignment 'Callback cb = func' 01502 */ 01503 template<typename T, typename U> 01504 MBED_DEPRECATED_SINCE("mbed-os-5.4", 01505 "Replaced by simple assignment 'Callback cb = func") 01506 void attach(const U *obj, R (T::*method)(A0, A1) const) { 01507 this->~Callback(); 01508 new (this) Callback(obj, method); 01509 } 01510 01511 /** Attach a member function 01512 * @param obj Pointer to object to invoke member function on 01513 * @param method Member function to attach 01514 * @deprecated 01515 * Replaced by simple assignment 'Callback cb = func' 01516 */ 01517 template<typename T, typename U> 01518 MBED_DEPRECATED_SINCE("mbed-os-5.4", 01519 "Replaced by simple assignment 'Callback cb = func") 01520 void attach(volatile U *obj, R (T::*method)(A0, A1) volatile) { 01521 this->~Callback(); 01522 new (this) Callback(obj, method); 01523 } 01524 01525 /** Attach a member function 01526 * @param obj Pointer to object to invoke member function on 01527 * @param method Member function to attach 01528 * @deprecated 01529 * Replaced by simple assignment 'Callback cb = func' 01530 */ 01531 template<typename T, typename U> 01532 MBED_DEPRECATED_SINCE("mbed-os-5.4", 01533 "Replaced by simple assignment 'Callback cb = func") 01534 void attach(const volatile U *obj, R (T::*method)(A0, A1) const volatile) { 01535 this->~Callback(); 01536 new (this) Callback(obj, method); 01537 } 01538 01539 /** Attach a static function with a bound pointer 01540 * @param func Static function to attach 01541 * @param arg Pointer argument to function 01542 * @deprecated 01543 * Replaced by simple assignment 'Callback cb = func' 01544 */ 01545 template <typename T, typename U> 01546 MBED_DEPRECATED_SINCE("mbed-os-5.4", 01547 "Replaced by simple assignment 'Callback cb = func") 01548 void attach(R (*func)(T*, A0, A1), U *arg) { 01549 this->~Callback(); 01550 new (this) Callback(func, arg); 01551 } 01552 01553 /** Attach a static function with a bound pointer 01554 * @param func Static function to attach 01555 * @param arg Pointer argument to function 01556 * @deprecated 01557 * Replaced by simple assignment 'Callback cb = func' 01558 */ 01559 template <typename T, typename U> 01560 MBED_DEPRECATED_SINCE("mbed-os-5.4", 01561 "Replaced by simple assignment 'Callback cb = func") 01562 void attach(R (*func)(const T*, A0, A1), const U *arg) { 01563 this->~Callback(); 01564 new (this) Callback(func, arg); 01565 } 01566 01567 /** Attach a static function with a bound pointer 01568 * @param func Static function to attach 01569 * @param arg Pointer argument to function 01570 * @deprecated 01571 * Replaced by simple assignment 'Callback cb = func' 01572 */ 01573 template <typename T, typename U> 01574 MBED_DEPRECATED_SINCE("mbed-os-5.4", 01575 "Replaced by simple assignment 'Callback cb = func") 01576 void attach(R (*func)(volatile T*, A0, A1), volatile U *arg) { 01577 this->~Callback(); 01578 new (this) Callback(func, arg); 01579 } 01580 01581 /** Attach a static function with a bound pointer 01582 * @param func Static function to attach 01583 * @param arg Pointer argument to function 01584 * @deprecated 01585 * Replaced by simple assignment 'Callback cb = func' 01586 */ 01587 template <typename T, typename U> 01588 MBED_DEPRECATED_SINCE("mbed-os-5.4", 01589 "Replaced by simple assignment 'Callback cb = func") 01590 void attach(R (*func)(const volatile T*, A0, A1), const volatile U *arg) { 01591 this->~Callback(); 01592 new (this) Callback(func, arg); 01593 } 01594 01595 /** Attach a function object 01596 * @param func Function object to attach 01597 * @note The function object is limited to a single word of storage 01598 * @deprecated 01599 * Replaced by simple assignment 'Callback cb = func' 01600 */ 01601 template <typename F> 01602 MBED_DEPRECATED_SINCE("mbed-os-5.4", 01603 "Replaced by simple assignment 'Callback cb = func") 01604 void attach(F f, typename detail::enable_if< 01605 detail::is_type<R (F::*)(A0, A1), &F::operator()>::value && 01606 sizeof(F) <= sizeof(uintptr_t) 01607 >::type = detail::nil()) { 01608 this->~Callback(); 01609 new (this) Callback(f); 01610 } 01611 01612 /** Attach a function object 01613 * @param func Function object to attach 01614 * @note The function object is limited to a single word of storage 01615 * @deprecated 01616 * Replaced by simple assignment 'Callback cb = func' 01617 */ 01618 template <typename F> 01619 MBED_DEPRECATED_SINCE("mbed-os-5.4", 01620 "Replaced by simple assignment 'Callback cb = func") 01621 void attach(const F f, typename detail::enable_if< 01622 detail::is_type<R (F::*)(A0, A1) const, &F::operator()>::value && 01623 sizeof(F) <= sizeof(uintptr_t) 01624 >::type = detail::nil()) { 01625 this->~Callback(); 01626 new (this) Callback(f); 01627 } 01628 01629 /** Attach a function object 01630 * @param func Function object to attach 01631 * @note The function object is limited to a single word of storage 01632 * @deprecated 01633 * Replaced by simple assignment 'Callback cb = func' 01634 */ 01635 template <typename F> 01636 MBED_DEPRECATED_SINCE("mbed-os-5.4", 01637 "Replaced by simple assignment 'Callback cb = func") 01638 void attach(volatile F f, typename detail::enable_if< 01639 detail::is_type<R (F::*)(A0, A1) volatile, &F::operator()>::value && 01640 sizeof(F) <= sizeof(uintptr_t) 01641 >::type = detail::nil()) { 01642 this->~Callback(); 01643 new (this) Callback(f); 01644 } 01645 01646 /** Attach a function object 01647 * @param func Function object to attach 01648 * @note The function object is limited to a single word of storage 01649 * @deprecated 01650 * Replaced by simple assignment 'Callback cb = func' 01651 */ 01652 template <typename F> 01653 MBED_DEPRECATED_SINCE("mbed-os-5.4", 01654 "Replaced by simple assignment 'Callback cb = func") 01655 void attach(const volatile F f, typename detail::enable_if< 01656 detail::is_type<R (F::*)(A0, A1) const volatile, &F::operator()>::value && 01657 sizeof(F) <= sizeof(uintptr_t) 01658 >::type = detail::nil()) { 01659 this->~Callback(); 01660 new (this) Callback(f); 01661 } 01662 01663 /** Attach a static function with a bound pointer 01664 * @param obj Pointer to object to bind to function 01665 * @param func Static function to attach 01666 * @deprecated 01667 * Arguments to callback have been reordered to attach(func, arg) 01668 */ 01669 template <typename T, typename U> 01670 MBED_DEPRECATED_SINCE("mbed-os-5.1", 01671 "Arguments to callback have been reordered to attach(func, arg)") 01672 void attach(U *obj, R (*func)(T*, A0, A1)) { 01673 this->~Callback(); 01674 new (this) Callback(func, obj); 01675 } 01676 01677 /** Attach a static function with a bound pointer 01678 * @param obj Pointer to object to bind to function 01679 * @param func Static function to attach 01680 * @deprecated 01681 * Arguments to callback have been reordered to attach(func, arg) 01682 */ 01683 template <typename T, typename U> 01684 MBED_DEPRECATED_SINCE("mbed-os-5.1", 01685 "Arguments to callback have been reordered to attach(func, arg)") 01686 void attach(const U *obj, R (*func)(const T*, A0, A1)) { 01687 this->~Callback(); 01688 new (this) Callback(func, obj); 01689 } 01690 01691 /** Attach a static function with a bound pointer 01692 * @param obj Pointer to object to bind to function 01693 * @param func Static function to attach 01694 * @deprecated 01695 * Arguments to callback have been reordered to attach(func, arg) 01696 */ 01697 template <typename T, typename U> 01698 MBED_DEPRECATED_SINCE("mbed-os-5.1", 01699 "Arguments to callback have been reordered to attach(func, arg)") 01700 void attach(volatile U *obj, R (*func)(volatile T*, A0, A1)) { 01701 this->~Callback(); 01702 new (this) Callback(func, obj); 01703 } 01704 01705 /** Attach a static function with a bound pointer 01706 * @param obj Pointer to object to bind to function 01707 * @param func Static function to attach 01708 * @deprecated 01709 * Arguments to callback have been reordered to attach(func, arg) 01710 */ 01711 template <typename T, typename U> 01712 MBED_DEPRECATED_SINCE("mbed-os-5.1", 01713 "Arguments to callback have been reordered to attach(func, arg)") 01714 void attach(const volatile U *obj, R (*func)(const volatile T*, A0, A1)) { 01715 this->~Callback(); 01716 new (this) Callback(func, obj); 01717 } 01718 01719 /** Assign a callback 01720 */ 01721 Callback &operator=(const Callback &that) { 01722 if (this != &that) { 01723 this->~Callback(); 01724 new (this) Callback(that); 01725 } 01726 01727 return *this; 01728 } 01729 01730 /** Call the attached function 01731 */ 01732 R call(A0 a0, A1 a1) const { 01733 MBED_ASSERT(_ops); 01734 return _ops->call(this, a0, a1); 01735 } 01736 01737 /** Call the attached function 01738 */ 01739 R operator()(A0 a0, A1 a1) const { 01740 return call(a0, a1); 01741 } 01742 01743 /** Test if function has been attached 01744 */ 01745 operator bool() const { 01746 return _ops; 01747 } 01748 01749 /** Test for equality 01750 */ 01751 friend bool operator==(const Callback &l, const Callback &r) { 01752 return memcmp(&l, &r, sizeof(Callback)) == 0; 01753 } 01754 01755 /** Test for inequality 01756 */ 01757 friend bool operator!=(const Callback &l, const Callback &r) { 01758 return !(l == r); 01759 } 01760 01761 /** Static thunk for passing as C-style function 01762 * @param func Callback to call passed as void pointer 01763 */ 01764 static R thunk(void *func, A0 a0, A1 a1) { 01765 return static_cast<Callback*>(func)->call(a0, a1); 01766 } 01767 01768 private: 01769 // Stored as pointer to function and pointer to optional object 01770 // Function pointer is stored as union of possible function types 01771 // to garuntee proper size and alignment 01772 struct _class; 01773 union { 01774 void (*_staticfunc)(A0, A1); 01775 void (*_boundfunc)(_class*, A0, A1); 01776 void (_class::*_methodfunc)(A0, A1); 01777 } _func; 01778 void *_obj; 01779 01780 // Dynamically dispatched operations 01781 const struct ops { 01782 R (*call)(const void*, A0, A1); 01783 void (*move)(void*, const void*); 01784 void (*dtor)(void*); 01785 } *_ops; 01786 01787 // Generate operations for function object 01788 template <typename F> 01789 void generate(const F &f) { 01790 static const ops ops = { 01791 &Callback::function_call<F>, 01792 &Callback::function_move<F>, 01793 &Callback::function_dtor<F>, 01794 }; 01795 01796 MBED_STATIC_ASSERT(sizeof(Callback) - sizeof(_ops) >= sizeof(F), 01797 "Type F must not exceed the size of the Callback class"); 01798 new (this) F(f); 01799 _ops = &ops; 01800 } 01801 01802 // Function attributes 01803 template <typename F> 01804 static R function_call(const void *p, A0 a0, A1 a1) { 01805 return (*(F*)p)(a0, a1); 01806 } 01807 01808 template <typename F> 01809 static void function_move(void *d, const void *p) { 01810 new (d) F(*(F*)p); 01811 } 01812 01813 template <typename F> 01814 static void function_dtor(void *p) { 01815 ((F*)p)->~F(); 01816 } 01817 01818 // Wrappers for functions with context 01819 template <typename O, typename M> 01820 struct method_context { 01821 M method; 01822 O *obj; 01823 01824 method_context(O *obj, M method) 01825 : method(method), obj(obj) {} 01826 01827 R operator()(A0 a0, A1 a1) const { 01828 return (obj->*method)(a0, a1); 01829 } 01830 }; 01831 01832 template <typename F, typename A> 01833 struct function_context { 01834 F func; 01835 A *arg; 01836 01837 function_context(F func, A *arg) 01838 : func(func), arg(arg) {} 01839 01840 R operator()(A0 a0, A1 a1) const { 01841 return func(arg, a0, a1); 01842 } 01843 }; 01844 }; 01845 01846 /** Callback class based on template specialization 01847 * 01848 * @Note Synchronization level: Not protected 01849 */ 01850 template <typename R, typename A0, typename A1, typename A2> 01851 class Callback<R(A0, A1, A2)> { 01852 public: 01853 /** Create a Callback with a static function 01854 * @param func Static function to attach 01855 */ 01856 Callback(R (*func)(A0, A1, A2) = 0) { 01857 if (!func) { 01858 _ops = 0; 01859 } else { 01860 generate(func); 01861 } 01862 } 01863 01864 /** Attach a Callback 01865 * @param func The Callback to attach 01866 */ 01867 Callback(const Callback<R(A0, A1, A2)> &func) { 01868 if (func._ops) { 01869 func._ops->move(this, &func); 01870 } 01871 _ops = func._ops; 01872 } 01873 01874 /** Create a Callback with a member function 01875 * @param obj Pointer to object to invoke member function on 01876 * @param method Member function to attach 01877 */ 01878 template<typename T, typename U> 01879 Callback(U *obj, R (T::*method)(A0, A1, A2)) { 01880 generate(method_context<T, R (T::*)(A0, A1, A2)>(obj, method)); 01881 } 01882 01883 /** Create a Callback with a member function 01884 * @param obj Pointer to object to invoke member function on 01885 * @param method Member function to attach 01886 */ 01887 template<typename T, typename U> 01888 Callback(const U *obj, R (T::*method)(A0, A1, A2) const) { 01889 generate(method_context<const T, R (T::*)(A0, A1, A2) const>(obj, method)); 01890 } 01891 01892 /** Create a Callback with a member function 01893 * @param obj Pointer to object to invoke member function on 01894 * @param method Member function to attach 01895 */ 01896 template<typename T, typename U> 01897 Callback(volatile U *obj, R (T::*method)(A0, A1, A2) volatile) { 01898 generate(method_context<volatile T, R (T::*)(A0, A1, A2) volatile>(obj, method)); 01899 } 01900 01901 /** Create a Callback with a member function 01902 * @param obj Pointer to object to invoke member function on 01903 * @param method Member function to attach 01904 */ 01905 template<typename T, typename U> 01906 Callback(const volatile U *obj, R (T::*method)(A0, A1, A2) const volatile) { 01907 generate(method_context<const volatile T, R (T::*)(A0, A1, A2) const volatile>(obj, method)); 01908 } 01909 01910 /** Create a Callback with a static function and bound pointer 01911 * @param func Static function to attach 01912 * @param arg Pointer argument to function 01913 */ 01914 template<typename T, typename U> 01915 Callback(R (*func)(T*, A0, A1, A2), U *arg) { 01916 generate(function_context<R (*)(T*, A0, A1, A2), T>(func, arg)); 01917 } 01918 01919 /** Create a Callback with a static function and bound pointer 01920 * @param func Static function to attach 01921 * @param arg Pointer argument to function 01922 */ 01923 template<typename T, typename U> 01924 Callback(R (*func)(const T*, A0, A1, A2), const U *arg) { 01925 generate(function_context<R (*)(const T*, A0, A1, A2), const T>(func, arg)); 01926 } 01927 01928 /** Create a Callback with a static function and bound pointer 01929 * @param func Static function to attach 01930 * @param arg Pointer argument to function 01931 */ 01932 template<typename T, typename U> 01933 Callback(R (*func)(volatile T*, A0, A1, A2), volatile U *arg) { 01934 generate(function_context<R (*)(volatile T*, A0, A1, A2), volatile T>(func, arg)); 01935 } 01936 01937 /** Create a Callback with a static function and bound pointer 01938 * @param func Static function to attach 01939 * @param arg Pointer argument to function 01940 */ 01941 template<typename T, typename U> 01942 Callback(R (*func)(const volatile T*, A0, A1, A2), const volatile U *arg) { 01943 generate(function_context<R (*)(const volatile T*, A0, A1, A2), const volatile T>(func, arg)); 01944 } 01945 01946 /** Create a Callback with a function object 01947 * @param func Function object to attach 01948 * @note The function object is limited to a single word of storage 01949 */ 01950 template <typename F> 01951 Callback(F f, typename detail::enable_if< 01952 detail::is_type<R (F::*)(A0, A1, A2), &F::operator()>::value && 01953 sizeof(F) <= sizeof(uintptr_t) 01954 >::type = detail::nil()) { 01955 generate(f); 01956 } 01957 01958 /** Create a Callback with a function object 01959 * @param func Function object to attach 01960 * @note The function object is limited to a single word of storage 01961 */ 01962 template <typename F> 01963 Callback(const F f, typename detail::enable_if< 01964 detail::is_type<R (F::*)(A0, A1, A2) const, &F::operator()>::value && 01965 sizeof(F) <= sizeof(uintptr_t) 01966 >::type = detail::nil()) { 01967 generate(f); 01968 } 01969 01970 /** Create a Callback with a function object 01971 * @param func Function object to attach 01972 * @note The function object is limited to a single word of storage 01973 */ 01974 template <typename F> 01975 Callback(volatile F f, typename detail::enable_if< 01976 detail::is_type<R (F::*)(A0, A1, A2) volatile, &F::operator()>::value && 01977 sizeof(F) <= sizeof(uintptr_t) 01978 >::type = detail::nil()) { 01979 generate(f); 01980 } 01981 01982 /** Create a Callback with a function object 01983 * @param func Function object to attach 01984 * @note The function object is limited to a single word of storage 01985 */ 01986 template <typename F> 01987 Callback(const volatile F f, typename detail::enable_if< 01988 detail::is_type<R (F::*)(A0, A1, A2) const volatile, &F::operator()>::value && 01989 sizeof(F) <= sizeof(uintptr_t) 01990 >::type = detail::nil()) { 01991 generate(f); 01992 } 01993 01994 /** Create a Callback with a static function and bound pointer 01995 * @param obj Pointer to object to bind to function 01996 * @param func Static function to attach 01997 * @deprecated 01998 * Arguments to callback have been reordered to Callback(func, arg) 01999 */ 02000 template<typename T, typename U> 02001 MBED_DEPRECATED_SINCE("mbed-os-5.1", 02002 "Arguments to callback have been reordered to Callback(func, arg)") 02003 Callback(U *obj, R (*func)(T*, A0, A1, A2)) { 02004 new (this) Callback(func, obj); 02005 } 02006 02007 /** Create a Callback with a static function and bound pointer 02008 * @param obj Pointer to object to bind to function 02009 * @param func Static function to attach 02010 * @deprecated 02011 * Arguments to callback have been reordered to Callback(func, arg) 02012 */ 02013 template<typename T, typename U> 02014 MBED_DEPRECATED_SINCE("mbed-os-5.1", 02015 "Arguments to callback have been reordered to Callback(func, arg)") 02016 Callback(const U *obj, R (*func)(const T*, A0, A1, A2)) { 02017 new (this) Callback(func, obj); 02018 } 02019 02020 /** Create a Callback with a static function and bound pointer 02021 * @param obj Pointer to object to bind to function 02022 * @param func Static function to attach 02023 * @deprecated 02024 * Arguments to callback have been reordered to Callback(func, arg) 02025 */ 02026 template<typename T, typename U> 02027 MBED_DEPRECATED_SINCE("mbed-os-5.1", 02028 "Arguments to callback have been reordered to Callback(func, arg)") 02029 Callback(volatile U *obj, R (*func)(volatile T*, A0, A1, A2)) { 02030 new (this) Callback(func, obj); 02031 } 02032 02033 /** Create a Callback with a static function and bound pointer 02034 * @param obj Pointer to object to bind to function 02035 * @param func Static function to attach 02036 * @deprecated 02037 * Arguments to callback have been reordered to Callback(func, arg) 02038 */ 02039 template<typename T, typename U> 02040 MBED_DEPRECATED_SINCE("mbed-os-5.1", 02041 "Arguments to callback have been reordered to Callback(func, arg)") 02042 Callback(const volatile U *obj, R (*func)(const volatile T*, A0, A1, A2)) { 02043 new (this) Callback(func, obj); 02044 } 02045 02046 /** Destroy a callback 02047 */ 02048 ~Callback() { 02049 if (_ops) { 02050 _ops->dtor(this); 02051 } 02052 } 02053 02054 /** Attach a static function 02055 * @param func Static function to attach 02056 * @deprecated 02057 * Replaced by simple assignment 'Callback cb = func' 02058 */ 02059 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02060 "Replaced by simple assignment 'Callback cb = func") 02061 void attach(R (*func)(A0, A1, A2)) { 02062 this->~Callback(); 02063 new (this) Callback(func); 02064 } 02065 02066 /** Attach a Callback 02067 * @param func The Callback to attach 02068 * @deprecated 02069 * Replaced by simple assignment 'Callback cb = func' 02070 */ 02071 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02072 "Replaced by simple assignment 'Callback cb = func") 02073 void attach(const Callback<R(A0, A1, A2)> &func) { 02074 this->~Callback(); 02075 new (this) Callback(func); 02076 } 02077 02078 /** Attach a member function 02079 * @param obj Pointer to object to invoke member function on 02080 * @param method Member function to attach 02081 * @deprecated 02082 * Replaced by simple assignment 'Callback cb = func' 02083 */ 02084 template<typename T, typename U> 02085 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02086 "Replaced by simple assignment 'Callback cb = func") 02087 void attach(U *obj, R (T::*method)(A0, A1, A2)) { 02088 this->~Callback(); 02089 new (this) Callback(obj, method); 02090 } 02091 02092 /** Attach a member function 02093 * @param obj Pointer to object to invoke member function on 02094 * @param method Member function to attach 02095 * @deprecated 02096 * Replaced by simple assignment 'Callback cb = func' 02097 */ 02098 template<typename T, typename U> 02099 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02100 "Replaced by simple assignment 'Callback cb = func") 02101 void attach(const U *obj, R (T::*method)(A0, A1, A2) const) { 02102 this->~Callback(); 02103 new (this) Callback(obj, method); 02104 } 02105 02106 /** Attach a member function 02107 * @param obj Pointer to object to invoke member function on 02108 * @param method Member function to attach 02109 * @deprecated 02110 * Replaced by simple assignment 'Callback cb = func' 02111 */ 02112 template<typename T, typename U> 02113 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02114 "Replaced by simple assignment 'Callback cb = func") 02115 void attach(volatile U *obj, R (T::*method)(A0, A1, A2) volatile) { 02116 this->~Callback(); 02117 new (this) Callback(obj, method); 02118 } 02119 02120 /** Attach a member function 02121 * @param obj Pointer to object to invoke member function on 02122 * @param method Member function to attach 02123 * @deprecated 02124 * Replaced by simple assignment 'Callback cb = func' 02125 */ 02126 template<typename T, typename U> 02127 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02128 "Replaced by simple assignment 'Callback cb = func") 02129 void attach(const volatile U *obj, R (T::*method)(A0, A1, A2) const volatile) { 02130 this->~Callback(); 02131 new (this) Callback(obj, method); 02132 } 02133 02134 /** Attach a static function with a bound pointer 02135 * @param func Static function to attach 02136 * @param arg Pointer argument to function 02137 * @deprecated 02138 * Replaced by simple assignment 'Callback cb = func' 02139 */ 02140 template <typename T, typename U> 02141 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02142 "Replaced by simple assignment 'Callback cb = func") 02143 void attach(R (*func)(T*, A0, A1, A2), U *arg) { 02144 this->~Callback(); 02145 new (this) Callback(func, arg); 02146 } 02147 02148 /** Attach a static function with a bound pointer 02149 * @param func Static function to attach 02150 * @param arg Pointer argument to function 02151 * @deprecated 02152 * Replaced by simple assignment 'Callback cb = func' 02153 */ 02154 template <typename T, typename U> 02155 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02156 "Replaced by simple assignment 'Callback cb = func") 02157 void attach(R (*func)(const T*, A0, A1, A2), const U *arg) { 02158 this->~Callback(); 02159 new (this) Callback(func, arg); 02160 } 02161 02162 /** Attach a static function with a bound pointer 02163 * @param func Static function to attach 02164 * @param arg Pointer argument to function 02165 * @deprecated 02166 * Replaced by simple assignment 'Callback cb = func' 02167 */ 02168 template <typename T, typename U> 02169 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02170 "Replaced by simple assignment 'Callback cb = func") 02171 void attach(R (*func)(volatile T*, A0, A1, A2), volatile U *arg) { 02172 this->~Callback(); 02173 new (this) Callback(func, arg); 02174 } 02175 02176 /** Attach a static function with a bound pointer 02177 * @param func Static function to attach 02178 * @param arg Pointer argument to function 02179 * @deprecated 02180 * Replaced by simple assignment 'Callback cb = func' 02181 */ 02182 template <typename T, typename U> 02183 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02184 "Replaced by simple assignment 'Callback cb = func") 02185 void attach(R (*func)(const volatile T*, A0, A1, A2), const volatile U *arg) { 02186 this->~Callback(); 02187 new (this) Callback(func, arg); 02188 } 02189 02190 /** Attach a function object 02191 * @param func Function object to attach 02192 * @note The function object is limited to a single word of storage 02193 * @deprecated 02194 * Replaced by simple assignment 'Callback cb = func' 02195 */ 02196 template <typename F> 02197 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02198 "Replaced by simple assignment 'Callback cb = func") 02199 void attach(F f, typename detail::enable_if< 02200 detail::is_type<R (F::*)(A0, A1, A2), &F::operator()>::value && 02201 sizeof(F) <= sizeof(uintptr_t) 02202 >::type = detail::nil()) { 02203 this->~Callback(); 02204 new (this) Callback(f); 02205 } 02206 02207 /** Attach a function object 02208 * @param func Function object to attach 02209 * @note The function object is limited to a single word of storage 02210 * @deprecated 02211 * Replaced by simple assignment 'Callback cb = func' 02212 */ 02213 template <typename F> 02214 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02215 "Replaced by simple assignment 'Callback cb = func") 02216 void attach(const F f, typename detail::enable_if< 02217 detail::is_type<R (F::*)(A0, A1, A2) const, &F::operator()>::value && 02218 sizeof(F) <= sizeof(uintptr_t) 02219 >::type = detail::nil()) { 02220 this->~Callback(); 02221 new (this) Callback(f); 02222 } 02223 02224 /** Attach a function object 02225 * @param func Function object to attach 02226 * @note The function object is limited to a single word of storage 02227 * @deprecated 02228 * Replaced by simple assignment 'Callback cb = func' 02229 */ 02230 template <typename F> 02231 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02232 "Replaced by simple assignment 'Callback cb = func") 02233 void attach(volatile F f, typename detail::enable_if< 02234 detail::is_type<R (F::*)(A0, A1, A2) volatile, &F::operator()>::value && 02235 sizeof(F) <= sizeof(uintptr_t) 02236 >::type = detail::nil()) { 02237 this->~Callback(); 02238 new (this) Callback(f); 02239 } 02240 02241 /** Attach a function object 02242 * @param func Function object to attach 02243 * @note The function object is limited to a single word of storage 02244 * @deprecated 02245 * Replaced by simple assignment 'Callback cb = func' 02246 */ 02247 template <typename F> 02248 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02249 "Replaced by simple assignment 'Callback cb = func") 02250 void attach(const volatile F f, typename detail::enable_if< 02251 detail::is_type<R (F::*)(A0, A1, A2) const volatile, &F::operator()>::value && 02252 sizeof(F) <= sizeof(uintptr_t) 02253 >::type = detail::nil()) { 02254 this->~Callback(); 02255 new (this) Callback(f); 02256 } 02257 02258 /** Attach a static function with a bound pointer 02259 * @param obj Pointer to object to bind to function 02260 * @param func Static function to attach 02261 * @deprecated 02262 * Arguments to callback have been reordered to attach(func, arg) 02263 */ 02264 template <typename T, typename U> 02265 MBED_DEPRECATED_SINCE("mbed-os-5.1", 02266 "Arguments to callback have been reordered to attach(func, arg)") 02267 void attach(U *obj, R (*func)(T*, A0, A1, A2)) { 02268 this->~Callback(); 02269 new (this) Callback(func, obj); 02270 } 02271 02272 /** Attach a static function with a bound pointer 02273 * @param obj Pointer to object to bind to function 02274 * @param func Static function to attach 02275 * @deprecated 02276 * Arguments to callback have been reordered to attach(func, arg) 02277 */ 02278 template <typename T, typename U> 02279 MBED_DEPRECATED_SINCE("mbed-os-5.1", 02280 "Arguments to callback have been reordered to attach(func, arg)") 02281 void attach(const U *obj, R (*func)(const T*, A0, A1, A2)) { 02282 this->~Callback(); 02283 new (this) Callback(func, obj); 02284 } 02285 02286 /** Attach a static function with a bound pointer 02287 * @param obj Pointer to object to bind to function 02288 * @param func Static function to attach 02289 * @deprecated 02290 * Arguments to callback have been reordered to attach(func, arg) 02291 */ 02292 template <typename T, typename U> 02293 MBED_DEPRECATED_SINCE("mbed-os-5.1", 02294 "Arguments to callback have been reordered to attach(func, arg)") 02295 void attach(volatile U *obj, R (*func)(volatile T*, A0, A1, A2)) { 02296 this->~Callback(); 02297 new (this) Callback(func, obj); 02298 } 02299 02300 /** Attach a static function with a bound pointer 02301 * @param obj Pointer to object to bind to function 02302 * @param func Static function to attach 02303 * @deprecated 02304 * Arguments to callback have been reordered to attach(func, arg) 02305 */ 02306 template <typename T, typename U> 02307 MBED_DEPRECATED_SINCE("mbed-os-5.1", 02308 "Arguments to callback have been reordered to attach(func, arg)") 02309 void attach(const volatile U *obj, R (*func)(const volatile T*, A0, A1, A2)) { 02310 this->~Callback(); 02311 new (this) Callback(func, obj); 02312 } 02313 02314 /** Assign a callback 02315 */ 02316 Callback &operator=(const Callback &that) { 02317 if (this != &that) { 02318 this->~Callback(); 02319 new (this) Callback(that); 02320 } 02321 02322 return *this; 02323 } 02324 02325 /** Call the attached function 02326 */ 02327 R call(A0 a0, A1 a1, A2 a2) const { 02328 MBED_ASSERT(_ops); 02329 return _ops->call(this, a0, a1, a2); 02330 } 02331 02332 /** Call the attached function 02333 */ 02334 R operator()(A0 a0, A1 a1, A2 a2) const { 02335 return call(a0, a1, a2); 02336 } 02337 02338 /** Test if function has been attached 02339 */ 02340 operator bool() const { 02341 return _ops; 02342 } 02343 02344 /** Test for equality 02345 */ 02346 friend bool operator==(const Callback &l, const Callback &r) { 02347 return memcmp(&l, &r, sizeof(Callback)) == 0; 02348 } 02349 02350 /** Test for inequality 02351 */ 02352 friend bool operator!=(const Callback &l, const Callback &r) { 02353 return !(l == r); 02354 } 02355 02356 /** Static thunk for passing as C-style function 02357 * @param func Callback to call passed as void pointer 02358 */ 02359 static R thunk(void *func, A0 a0, A1 a1, A2 a2) { 02360 return static_cast<Callback*>(func)->call(a0, a1, a2); 02361 } 02362 02363 private: 02364 // Stored as pointer to function and pointer to optional object 02365 // Function pointer is stored as union of possible function types 02366 // to garuntee proper size and alignment 02367 struct _class; 02368 union { 02369 void (*_staticfunc)(A0, A1, A2); 02370 void (*_boundfunc)(_class*, A0, A1, A2); 02371 void (_class::*_methodfunc)(A0, A1, A2); 02372 } _func; 02373 void *_obj; 02374 02375 // Dynamically dispatched operations 02376 const struct ops { 02377 R (*call)(const void*, A0, A1, A2); 02378 void (*move)(void*, const void*); 02379 void (*dtor)(void*); 02380 } *_ops; 02381 02382 // Generate operations for function object 02383 template <typename F> 02384 void generate(const F &f) { 02385 static const ops ops = { 02386 &Callback::function_call<F>, 02387 &Callback::function_move<F>, 02388 &Callback::function_dtor<F>, 02389 }; 02390 02391 MBED_STATIC_ASSERT(sizeof(Callback) - sizeof(_ops) >= sizeof(F), 02392 "Type F must not exceed the size of the Callback class"); 02393 new (this) F(f); 02394 _ops = &ops; 02395 } 02396 02397 // Function attributes 02398 template <typename F> 02399 static R function_call(const void *p, A0 a0, A1 a1, A2 a2) { 02400 return (*(F*)p)(a0, a1, a2); 02401 } 02402 02403 template <typename F> 02404 static void function_move(void *d, const void *p) { 02405 new (d) F(*(F*)p); 02406 } 02407 02408 template <typename F> 02409 static void function_dtor(void *p) { 02410 ((F*)p)->~F(); 02411 } 02412 02413 // Wrappers for functions with context 02414 template <typename O, typename M> 02415 struct method_context { 02416 M method; 02417 O *obj; 02418 02419 method_context(O *obj, M method) 02420 : method(method), obj(obj) {} 02421 02422 R operator()(A0 a0, A1 a1, A2 a2) const { 02423 return (obj->*method)(a0, a1, a2); 02424 } 02425 }; 02426 02427 template <typename F, typename A> 02428 struct function_context { 02429 F func; 02430 A *arg; 02431 02432 function_context(F func, A *arg) 02433 : func(func), arg(arg) {} 02434 02435 R operator()(A0 a0, A1 a1, A2 a2) const { 02436 return func(arg, a0, a1, a2); 02437 } 02438 }; 02439 }; 02440 02441 /** Callback class based on template specialization 02442 * 02443 * @Note Synchronization level: Not protected 02444 */ 02445 template <typename R, typename A0, typename A1, typename A2, typename A3> 02446 class Callback<R(A0, A1, A2, A3)> { 02447 public: 02448 /** Create a Callback with a static function 02449 * @param func Static function to attach 02450 */ 02451 Callback(R (*func)(A0, A1, A2, A3) = 0) { 02452 if (!func) { 02453 _ops = 0; 02454 } else { 02455 generate(func); 02456 } 02457 } 02458 02459 /** Attach a Callback 02460 * @param func The Callback to attach 02461 */ 02462 Callback(const Callback<R(A0, A1, A2, A3)> &func) { 02463 if (func._ops) { 02464 func._ops->move(this, &func); 02465 } 02466 _ops = func._ops; 02467 } 02468 02469 /** Create a Callback with a member function 02470 * @param obj Pointer to object to invoke member function on 02471 * @param method Member function to attach 02472 */ 02473 template<typename T, typename U> 02474 Callback(U *obj, R (T::*method)(A0, A1, A2, A3)) { 02475 generate(method_context<T, R (T::*)(A0, A1, A2, A3)>(obj, method)); 02476 } 02477 02478 /** Create a Callback with a member function 02479 * @param obj Pointer to object to invoke member function on 02480 * @param method Member function to attach 02481 */ 02482 template<typename T, typename U> 02483 Callback(const U *obj, R (T::*method)(A0, A1, A2, A3) const) { 02484 generate(method_context<const T, R (T::*)(A0, A1, A2, A3) const>(obj, method)); 02485 } 02486 02487 /** Create a Callback with a member function 02488 * @param obj Pointer to object to invoke member function on 02489 * @param method Member function to attach 02490 */ 02491 template<typename T, typename U> 02492 Callback(volatile U *obj, R (T::*method)(A0, A1, A2, A3) volatile) { 02493 generate(method_context<volatile T, R (T::*)(A0, A1, A2, A3) volatile>(obj, method)); 02494 } 02495 02496 /** Create a Callback with a member function 02497 * @param obj Pointer to object to invoke member function on 02498 * @param method Member function to attach 02499 */ 02500 template<typename T, typename U> 02501 Callback(const volatile U *obj, R (T::*method)(A0, A1, A2, A3) const volatile) { 02502 generate(method_context<const volatile T, R (T::*)(A0, A1, A2, A3) const volatile>(obj, method)); 02503 } 02504 02505 /** Create a Callback with a static function and bound pointer 02506 * @param func Static function to attach 02507 * @param arg Pointer argument to function 02508 */ 02509 template<typename T, typename U> 02510 Callback(R (*func)(T*, A0, A1, A2, A3), U *arg) { 02511 generate(function_context<R (*)(T*, A0, A1, A2, A3), T>(func, arg)); 02512 } 02513 02514 /** Create a Callback with a static function and bound pointer 02515 * @param func Static function to attach 02516 * @param arg Pointer argument to function 02517 */ 02518 template<typename T, typename U> 02519 Callback(R (*func)(const T*, A0, A1, A2, A3), const U *arg) { 02520 generate(function_context<R (*)(const T*, A0, A1, A2, A3), const T>(func, arg)); 02521 } 02522 02523 /** Create a Callback with a static function and bound pointer 02524 * @param func Static function to attach 02525 * @param arg Pointer argument to function 02526 */ 02527 template<typename T, typename U> 02528 Callback(R (*func)(volatile T*, A0, A1, A2, A3), volatile U *arg) { 02529 generate(function_context<R (*)(volatile T*, A0, A1, A2, A3), volatile T>(func, arg)); 02530 } 02531 02532 /** Create a Callback with a static function and bound pointer 02533 * @param func Static function to attach 02534 * @param arg Pointer argument to function 02535 */ 02536 template<typename T, typename U> 02537 Callback(R (*func)(const volatile T*, A0, A1, A2, A3), const volatile U *arg) { 02538 generate(function_context<R (*)(const volatile T*, A0, A1, A2, A3), const volatile T>(func, arg)); 02539 } 02540 02541 /** Create a Callback with a function object 02542 * @param func Function object to attach 02543 * @note The function object is limited to a single word of storage 02544 */ 02545 template <typename F> 02546 Callback(F f, typename detail::enable_if< 02547 detail::is_type<R (F::*)(A0, A1, A2, A3), &F::operator()>::value && 02548 sizeof(F) <= sizeof(uintptr_t) 02549 >::type = detail::nil()) { 02550 generate(f); 02551 } 02552 02553 /** Create a Callback with a function object 02554 * @param func Function object to attach 02555 * @note The function object is limited to a single word of storage 02556 */ 02557 template <typename F> 02558 Callback(const F f, typename detail::enable_if< 02559 detail::is_type<R (F::*)(A0, A1, A2, A3) const, &F::operator()>::value && 02560 sizeof(F) <= sizeof(uintptr_t) 02561 >::type = detail::nil()) { 02562 generate(f); 02563 } 02564 02565 /** Create a Callback with a function object 02566 * @param func Function object to attach 02567 * @note The function object is limited to a single word of storage 02568 */ 02569 template <typename F> 02570 Callback(volatile F f, typename detail::enable_if< 02571 detail::is_type<R (F::*)(A0, A1, A2, A3) volatile, &F::operator()>::value && 02572 sizeof(F) <= sizeof(uintptr_t) 02573 >::type = detail::nil()) { 02574 generate(f); 02575 } 02576 02577 /** Create a Callback with a function object 02578 * @param func Function object to attach 02579 * @note The function object is limited to a single word of storage 02580 */ 02581 template <typename F> 02582 Callback(const volatile F f, typename detail::enable_if< 02583 detail::is_type<R (F::*)(A0, A1, A2, A3) const volatile, &F::operator()>::value && 02584 sizeof(F) <= sizeof(uintptr_t) 02585 >::type = detail::nil()) { 02586 generate(f); 02587 } 02588 02589 /** Create a Callback with a static function and bound pointer 02590 * @param obj Pointer to object to bind to function 02591 * @param func Static function to attach 02592 * @deprecated 02593 * Arguments to callback have been reordered to Callback(func, arg) 02594 */ 02595 template<typename T, typename U> 02596 MBED_DEPRECATED_SINCE("mbed-os-5.1", 02597 "Arguments to callback have been reordered to Callback(func, arg)") 02598 Callback(U *obj, R (*func)(T*, A0, A1, A2, A3)) { 02599 new (this) Callback(func, obj); 02600 } 02601 02602 /** Create a Callback with a static function and bound pointer 02603 * @param obj Pointer to object to bind to function 02604 * @param func Static function to attach 02605 * @deprecated 02606 * Arguments to callback have been reordered to Callback(func, arg) 02607 */ 02608 template<typename T, typename U> 02609 MBED_DEPRECATED_SINCE("mbed-os-5.1", 02610 "Arguments to callback have been reordered to Callback(func, arg)") 02611 Callback(const U *obj, R (*func)(const T*, A0, A1, A2, A3)) { 02612 new (this) Callback(func, obj); 02613 } 02614 02615 /** Create a Callback with a static function and bound pointer 02616 * @param obj Pointer to object to bind to function 02617 * @param func Static function to attach 02618 * @deprecated 02619 * Arguments to callback have been reordered to Callback(func, arg) 02620 */ 02621 template<typename T, typename U> 02622 MBED_DEPRECATED_SINCE("mbed-os-5.1", 02623 "Arguments to callback have been reordered to Callback(func, arg)") 02624 Callback(volatile U *obj, R (*func)(volatile T*, A0, A1, A2, A3)) { 02625 new (this) Callback(func, obj); 02626 } 02627 02628 /** Create a Callback with a static function and bound pointer 02629 * @param obj Pointer to object to bind to function 02630 * @param func Static function to attach 02631 * @deprecated 02632 * Arguments to callback have been reordered to Callback(func, arg) 02633 */ 02634 template<typename T, typename U> 02635 MBED_DEPRECATED_SINCE("mbed-os-5.1", 02636 "Arguments to callback have been reordered to Callback(func, arg)") 02637 Callback(const volatile U *obj, R (*func)(const volatile T*, A0, A1, A2, A3)) { 02638 new (this) Callback(func, obj); 02639 } 02640 02641 /** Destroy a callback 02642 */ 02643 ~Callback() { 02644 if (_ops) { 02645 _ops->dtor(this); 02646 } 02647 } 02648 02649 /** Attach a static function 02650 * @param func Static function to attach 02651 * @deprecated 02652 * Replaced by simple assignment 'Callback cb = func' 02653 */ 02654 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02655 "Replaced by simple assignment 'Callback cb = func") 02656 void attach(R (*func)(A0, A1, A2, A3)) { 02657 this->~Callback(); 02658 new (this) Callback(func); 02659 } 02660 02661 /** Attach a Callback 02662 * @param func The Callback to attach 02663 * @deprecated 02664 * Replaced by simple assignment 'Callback cb = func' 02665 */ 02666 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02667 "Replaced by simple assignment 'Callback cb = func") 02668 void attach(const Callback<R(A0, A1, A2, A3)> &func) { 02669 this->~Callback(); 02670 new (this) Callback(func); 02671 } 02672 02673 /** Attach a member function 02674 * @param obj Pointer to object to invoke member function on 02675 * @param method Member function to attach 02676 * @deprecated 02677 * Replaced by simple assignment 'Callback cb = func' 02678 */ 02679 template<typename T, typename U> 02680 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02681 "Replaced by simple assignment 'Callback cb = func") 02682 void attach(U *obj, R (T::*method)(A0, A1, A2, A3)) { 02683 this->~Callback(); 02684 new (this) Callback(obj, method); 02685 } 02686 02687 /** Attach a member function 02688 * @param obj Pointer to object to invoke member function on 02689 * @param method Member function to attach 02690 * @deprecated 02691 * Replaced by simple assignment 'Callback cb = func' 02692 */ 02693 template<typename T, typename U> 02694 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02695 "Replaced by simple assignment 'Callback cb = func") 02696 void attach(const U *obj, R (T::*method)(A0, A1, A2, A3) const) { 02697 this->~Callback(); 02698 new (this) Callback(obj, method); 02699 } 02700 02701 /** Attach a member function 02702 * @param obj Pointer to object to invoke member function on 02703 * @param method Member function to attach 02704 * @deprecated 02705 * Replaced by simple assignment 'Callback cb = func' 02706 */ 02707 template<typename T, typename U> 02708 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02709 "Replaced by simple assignment 'Callback cb = func") 02710 void attach(volatile U *obj, R (T::*method)(A0, A1, A2, A3) volatile) { 02711 this->~Callback(); 02712 new (this) Callback(obj, method); 02713 } 02714 02715 /** Attach a member function 02716 * @param obj Pointer to object to invoke member function on 02717 * @param method Member function to attach 02718 * @deprecated 02719 * Replaced by simple assignment 'Callback cb = func' 02720 */ 02721 template<typename T, typename U> 02722 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02723 "Replaced by simple assignment 'Callback cb = func") 02724 void attach(const volatile U *obj, R (T::*method)(A0, A1, A2, A3) const volatile) { 02725 this->~Callback(); 02726 new (this) Callback(obj, method); 02727 } 02728 02729 /** Attach a static function with a bound pointer 02730 * @param func Static function to attach 02731 * @param arg Pointer argument to function 02732 * @deprecated 02733 * Replaced by simple assignment 'Callback cb = func' 02734 */ 02735 template <typename T, typename U> 02736 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02737 "Replaced by simple assignment 'Callback cb = func") 02738 void attach(R (*func)(T*, A0, A1, A2, A3), U *arg) { 02739 this->~Callback(); 02740 new (this) Callback(func, arg); 02741 } 02742 02743 /** Attach a static function with a bound pointer 02744 * @param func Static function to attach 02745 * @param arg Pointer argument to function 02746 * @deprecated 02747 * Replaced by simple assignment 'Callback cb = func' 02748 */ 02749 template <typename T, typename U> 02750 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02751 "Replaced by simple assignment 'Callback cb = func") 02752 void attach(R (*func)(const T*, A0, A1, A2, A3), const U *arg) { 02753 this->~Callback(); 02754 new (this) Callback(func, arg); 02755 } 02756 02757 /** Attach a static function with a bound pointer 02758 * @param func Static function to attach 02759 * @param arg Pointer argument to function 02760 * @deprecated 02761 * Replaced by simple assignment 'Callback cb = func' 02762 */ 02763 template <typename T, typename U> 02764 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02765 "Replaced by simple assignment 'Callback cb = func") 02766 void attach(R (*func)(volatile T*, A0, A1, A2, A3), volatile U *arg) { 02767 this->~Callback(); 02768 new (this) Callback(func, arg); 02769 } 02770 02771 /** Attach a static function with a bound pointer 02772 * @param func Static function to attach 02773 * @param arg Pointer argument to function 02774 * @deprecated 02775 * Replaced by simple assignment 'Callback cb = func' 02776 */ 02777 template <typename T, typename U> 02778 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02779 "Replaced by simple assignment 'Callback cb = func") 02780 void attach(R (*func)(const volatile T*, A0, A1, A2, A3), const volatile U *arg) { 02781 this->~Callback(); 02782 new (this) Callback(func, arg); 02783 } 02784 02785 /** Attach a function object 02786 * @param func Function object to attach 02787 * @note The function object is limited to a single word of storage 02788 * @deprecated 02789 * Replaced by simple assignment 'Callback cb = func' 02790 */ 02791 template <typename F> 02792 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02793 "Replaced by simple assignment 'Callback cb = func") 02794 void attach(F f, typename detail::enable_if< 02795 detail::is_type<R (F::*)(A0, A1, A2, A3), &F::operator()>::value && 02796 sizeof(F) <= sizeof(uintptr_t) 02797 >::type = detail::nil()) { 02798 this->~Callback(); 02799 new (this) Callback(f); 02800 } 02801 02802 /** Attach a function object 02803 * @param func Function object to attach 02804 * @note The function object is limited to a single word of storage 02805 * @deprecated 02806 * Replaced by simple assignment 'Callback cb = func' 02807 */ 02808 template <typename F> 02809 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02810 "Replaced by simple assignment 'Callback cb = func") 02811 void attach(const F f, typename detail::enable_if< 02812 detail::is_type<R (F::*)(A0, A1, A2, A3) const, &F::operator()>::value && 02813 sizeof(F) <= sizeof(uintptr_t) 02814 >::type = detail::nil()) { 02815 this->~Callback(); 02816 new (this) Callback(f); 02817 } 02818 02819 /** Attach a function object 02820 * @param func Function object to attach 02821 * @note The function object is limited to a single word of storage 02822 * @deprecated 02823 * Replaced by simple assignment 'Callback cb = func' 02824 */ 02825 template <typename F> 02826 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02827 "Replaced by simple assignment 'Callback cb = func") 02828 void attach(volatile F f, typename detail::enable_if< 02829 detail::is_type<R (F::*)(A0, A1, A2, A3) volatile, &F::operator()>::value && 02830 sizeof(F) <= sizeof(uintptr_t) 02831 >::type = detail::nil()) { 02832 this->~Callback(); 02833 new (this) Callback(f); 02834 } 02835 02836 /** Attach a function object 02837 * @param func Function object to attach 02838 * @note The function object is limited to a single word of storage 02839 * @deprecated 02840 * Replaced by simple assignment 'Callback cb = func' 02841 */ 02842 template <typename F> 02843 MBED_DEPRECATED_SINCE("mbed-os-5.4", 02844 "Replaced by simple assignment 'Callback cb = func") 02845 void attach(const volatile F f, typename detail::enable_if< 02846 detail::is_type<R (F::*)(A0, A1, A2, A3) const volatile, &F::operator()>::value && 02847 sizeof(F) <= sizeof(uintptr_t) 02848 >::type = detail::nil()) { 02849 this->~Callback(); 02850 new (this) Callback(f); 02851 } 02852 02853 /** Attach a static function with a bound pointer 02854 * @param obj Pointer to object to bind to function 02855 * @param func Static function to attach 02856 * @deprecated 02857 * Arguments to callback have been reordered to attach(func, arg) 02858 */ 02859 template <typename T, typename U> 02860 MBED_DEPRECATED_SINCE("mbed-os-5.1", 02861 "Arguments to callback have been reordered to attach(func, arg)") 02862 void attach(U *obj, R (*func)(T*, A0, A1, A2, A3)) { 02863 this->~Callback(); 02864 new (this) Callback(func, obj); 02865 } 02866 02867 /** Attach a static function with a bound pointer 02868 * @param obj Pointer to object to bind to function 02869 * @param func Static function to attach 02870 * @deprecated 02871 * Arguments to callback have been reordered to attach(func, arg) 02872 */ 02873 template <typename T, typename U> 02874 MBED_DEPRECATED_SINCE("mbed-os-5.1", 02875 "Arguments to callback have been reordered to attach(func, arg)") 02876 void attach(const U *obj, R (*func)(const T*, A0, A1, A2, A3)) { 02877 this->~Callback(); 02878 new (this) Callback(func, obj); 02879 } 02880 02881 /** Attach a static function with a bound pointer 02882 * @param obj Pointer to object to bind to function 02883 * @param func Static function to attach 02884 * @deprecated 02885 * Arguments to callback have been reordered to attach(func, arg) 02886 */ 02887 template <typename T, typename U> 02888 MBED_DEPRECATED_SINCE("mbed-os-5.1", 02889 "Arguments to callback have been reordered to attach(func, arg)") 02890 void attach(volatile U *obj, R (*func)(volatile T*, A0, A1, A2, A3)) { 02891 this->~Callback(); 02892 new (this) Callback(func, obj); 02893 } 02894 02895 /** Attach a static function with a bound pointer 02896 * @param obj Pointer to object to bind to function 02897 * @param func Static function to attach 02898 * @deprecated 02899 * Arguments to callback have been reordered to attach(func, arg) 02900 */ 02901 template <typename T, typename U> 02902 MBED_DEPRECATED_SINCE("mbed-os-5.1", 02903 "Arguments to callback have been reordered to attach(func, arg)") 02904 void attach(const volatile U *obj, R (*func)(const volatile T*, A0, A1, A2, A3)) { 02905 this->~Callback(); 02906 new (this) Callback(func, obj); 02907 } 02908 02909 /** Assign a callback 02910 */ 02911 Callback &operator=(const Callback &that) { 02912 if (this != &that) { 02913 this->~Callback(); 02914 new (this) Callback(that); 02915 } 02916 02917 return *this; 02918 } 02919 02920 /** Call the attached function 02921 */ 02922 R call(A0 a0, A1 a1, A2 a2, A3 a3) const { 02923 MBED_ASSERT(_ops); 02924 return _ops->call(this, a0, a1, a2, a3); 02925 } 02926 02927 /** Call the attached function 02928 */ 02929 R operator()(A0 a0, A1 a1, A2 a2, A3 a3) const { 02930 return call(a0, a1, a2, a3); 02931 } 02932 02933 /** Test if function has been attached 02934 */ 02935 operator bool() const { 02936 return _ops; 02937 } 02938 02939 /** Test for equality 02940 */ 02941 friend bool operator==(const Callback &l, const Callback &r) { 02942 return memcmp(&l, &r, sizeof(Callback)) == 0; 02943 } 02944 02945 /** Test for inequality 02946 */ 02947 friend bool operator!=(const Callback &l, const Callback &r) { 02948 return !(l == r); 02949 } 02950 02951 /** Static thunk for passing as C-style function 02952 * @param func Callback to call passed as void pointer 02953 */ 02954 static R thunk(void *func, A0 a0, A1 a1, A2 a2, A3 a3) { 02955 return static_cast<Callback*>(func)->call(a0, a1, a2, a3); 02956 } 02957 02958 private: 02959 // Stored as pointer to function and pointer to optional object 02960 // Function pointer is stored as union of possible function types 02961 // to garuntee proper size and alignment 02962 struct _class; 02963 union { 02964 void (*_staticfunc)(A0, A1, A2, A3); 02965 void (*_boundfunc)(_class*, A0, A1, A2, A3); 02966 void (_class::*_methodfunc)(A0, A1, A2, A3); 02967 } _func; 02968 void *_obj; 02969 02970 // Dynamically dispatched operations 02971 const struct ops { 02972 R (*call)(const void*, A0, A1, A2, A3); 02973 void (*move)(void*, const void*); 02974 void (*dtor)(void*); 02975 } *_ops; 02976 02977 // Generate operations for function object 02978 template <typename F> 02979 void generate(const F &f) { 02980 static const ops ops = { 02981 &Callback::function_call<F>, 02982 &Callback::function_move<F>, 02983 &Callback::function_dtor<F>, 02984 }; 02985 02986 MBED_STATIC_ASSERT(sizeof(Callback) - sizeof(_ops) >= sizeof(F), 02987 "Type F must not exceed the size of the Callback class"); 02988 new (this) F(f); 02989 _ops = &ops; 02990 } 02991 02992 // Function attributes 02993 template <typename F> 02994 static R function_call(const void *p, A0 a0, A1 a1, A2 a2, A3 a3) { 02995 return (*(F*)p)(a0, a1, a2, a3); 02996 } 02997 02998 template <typename F> 02999 static void function_move(void *d, const void *p) { 03000 new (d) F(*(F*)p); 03001 } 03002 03003 template <typename F> 03004 static void function_dtor(void *p) { 03005 ((F*)p)->~F(); 03006 } 03007 03008 // Wrappers for functions with context 03009 template <typename O, typename M> 03010 struct method_context { 03011 M method; 03012 O *obj; 03013 03014 method_context(O *obj, M method) 03015 : method(method), obj(obj) {} 03016 03017 R operator()(A0 a0, A1 a1, A2 a2, A3 a3) const { 03018 return (obj->*method)(a0, a1, a2, a3); 03019 } 03020 }; 03021 03022 template <typename F, typename A> 03023 struct function_context { 03024 F func; 03025 A *arg; 03026 03027 function_context(F func, A *arg) 03028 : func(func), arg(arg) {} 03029 03030 R operator()(A0 a0, A1 a1, A2 a2, A3 a3) const { 03031 return func(arg, a0, a1, a2, a3); 03032 } 03033 }; 03034 }; 03035 03036 /** Callback class based on template specialization 03037 * 03038 * @Note Synchronization level: Not protected 03039 */ 03040 template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 03041 class Callback<R(A0, A1, A2, A3, A4)> { 03042 public: 03043 /** Create a Callback with a static function 03044 * @param func Static function to attach 03045 */ 03046 Callback(R (*func)(A0, A1, A2, A3, A4) = 0) { 03047 if (!func) { 03048 _ops = 0; 03049 } else { 03050 generate(func); 03051 } 03052 } 03053 03054 /** Attach a Callback 03055 * @param func The Callback to attach 03056 */ 03057 Callback(const Callback<R(A0, A1, A2, A3, A4)> &func) { 03058 if (func._ops) { 03059 func._ops->move(this, &func); 03060 } 03061 _ops = func._ops; 03062 } 03063 03064 /** Create a Callback with a member function 03065 * @param obj Pointer to object to invoke member function on 03066 * @param method Member function to attach 03067 */ 03068 template<typename T, typename U> 03069 Callback(U *obj, R (T::*method)(A0, A1, A2, A3, A4)) { 03070 generate(method_context<T, R (T::*)(A0, A1, A2, A3, A4)>(obj, method)); 03071 } 03072 03073 /** Create a Callback with a member function 03074 * @param obj Pointer to object to invoke member function on 03075 * @param method Member function to attach 03076 */ 03077 template<typename T, typename U> 03078 Callback(const U *obj, R (T::*method)(A0, A1, A2, A3, A4) const) { 03079 generate(method_context<const T, R (T::*)(A0, A1, A2, A3, A4) const>(obj, method)); 03080 } 03081 03082 /** Create a Callback with a member function 03083 * @param obj Pointer to object to invoke member function on 03084 * @param method Member function to attach 03085 */ 03086 template<typename T, typename U> 03087 Callback(volatile U *obj, R (T::*method)(A0, A1, A2, A3, A4) volatile) { 03088 generate(method_context<volatile T, R (T::*)(A0, A1, A2, A3, A4) volatile>(obj, method)); 03089 } 03090 03091 /** Create a Callback with a member function 03092 * @param obj Pointer to object to invoke member function on 03093 * @param method Member function to attach 03094 */ 03095 template<typename T, typename U> 03096 Callback(const volatile U *obj, R (T::*method)(A0, A1, A2, A3, A4) const volatile) { 03097 generate(method_context<const volatile T, R (T::*)(A0, A1, A2, A3, A4) const volatile>(obj, method)); 03098 } 03099 03100 /** Create a Callback with a static function and bound pointer 03101 * @param func Static function to attach 03102 * @param arg Pointer argument to function 03103 */ 03104 template<typename T, typename U> 03105 Callback(R (*func)(T*, A0, A1, A2, A3, A4), U *arg) { 03106 generate(function_context<R (*)(T*, A0, A1, A2, A3, A4), T>(func, arg)); 03107 } 03108 03109 /** Create a Callback with a static function and bound pointer 03110 * @param func Static function to attach 03111 * @param arg Pointer argument to function 03112 */ 03113 template<typename T, typename U> 03114 Callback(R (*func)(const T*, A0, A1, A2, A3, A4), const U *arg) { 03115 generate(function_context<R (*)(const T*, A0, A1, A2, A3, A4), const T>(func, arg)); 03116 } 03117 03118 /** Create a Callback with a static function and bound pointer 03119 * @param func Static function to attach 03120 * @param arg Pointer argument to function 03121 */ 03122 template<typename T, typename U> 03123 Callback(R (*func)(volatile T*, A0, A1, A2, A3, A4), volatile U *arg) { 03124 generate(function_context<R (*)(volatile T*, A0, A1, A2, A3, A4), volatile T>(func, arg)); 03125 } 03126 03127 /** Create a Callback with a static function and bound pointer 03128 * @param func Static function to attach 03129 * @param arg Pointer argument to function 03130 */ 03131 template<typename T, typename U> 03132 Callback(R (*func)(const volatile T*, A0, A1, A2, A3, A4), const volatile U *arg) { 03133 generate(function_context<R (*)(const volatile T*, A0, A1, A2, A3, A4), const volatile T>(func, arg)); 03134 } 03135 03136 /** Create a Callback with a function object 03137 * @param func Function object to attach 03138 * @note The function object is limited to a single word of storage 03139 */ 03140 template <typename F> 03141 Callback(F f, typename detail::enable_if< 03142 detail::is_type<R (F::*)(A0, A1, A2, A3, A4), &F::operator()>::value && 03143 sizeof(F) <= sizeof(uintptr_t) 03144 >::type = detail::nil()) { 03145 generate(f); 03146 } 03147 03148 /** Create a Callback with a function object 03149 * @param func Function object to attach 03150 * @note The function object is limited to a single word of storage 03151 */ 03152 template <typename F> 03153 Callback(const F f, typename detail::enable_if< 03154 detail::is_type<R (F::*)(A0, A1, A2, A3, A4) const, &F::operator()>::value && 03155 sizeof(F) <= sizeof(uintptr_t) 03156 >::type = detail::nil()) { 03157 generate(f); 03158 } 03159 03160 /** Create a Callback with a function object 03161 * @param func Function object to attach 03162 * @note The function object is limited to a single word of storage 03163 */ 03164 template <typename F> 03165 Callback(volatile F f, typename detail::enable_if< 03166 detail::is_type<R (F::*)(A0, A1, A2, A3, A4) volatile, &F::operator()>::value && 03167 sizeof(F) <= sizeof(uintptr_t) 03168 >::type = detail::nil()) { 03169 generate(f); 03170 } 03171 03172 /** Create a Callback with a function object 03173 * @param func Function object to attach 03174 * @note The function object is limited to a single word of storage 03175 */ 03176 template <typename F> 03177 Callback(const volatile F f, typename detail::enable_if< 03178 detail::is_type<R (F::*)(A0, A1, A2, A3, A4) const volatile, &F::operator()>::value && 03179 sizeof(F) <= sizeof(uintptr_t) 03180 >::type = detail::nil()) { 03181 generate(f); 03182 } 03183 03184 /** Create a Callback with a static function and bound pointer 03185 * @param obj Pointer to object to bind to function 03186 * @param func Static function to attach 03187 * @deprecated 03188 * Arguments to callback have been reordered to Callback(func, arg) 03189 */ 03190 template<typename T, typename U> 03191 MBED_DEPRECATED_SINCE("mbed-os-5.1", 03192 "Arguments to callback have been reordered to Callback(func, arg)") 03193 Callback(U *obj, R (*func)(T*, A0, A1, A2, A3, A4)) { 03194 new (this) Callback(func, obj); 03195 } 03196 03197 /** Create a Callback with a static function and bound pointer 03198 * @param obj Pointer to object to bind to function 03199 * @param func Static function to attach 03200 * @deprecated 03201 * Arguments to callback have been reordered to Callback(func, arg) 03202 */ 03203 template<typename T, typename U> 03204 MBED_DEPRECATED_SINCE("mbed-os-5.1", 03205 "Arguments to callback have been reordered to Callback(func, arg)") 03206 Callback(const U *obj, R (*func)(const T*, A0, A1, A2, A3, A4)) { 03207 new (this) Callback(func, obj); 03208 } 03209 03210 /** Create a Callback with a static function and bound pointer 03211 * @param obj Pointer to object to bind to function 03212 * @param func Static function to attach 03213 * @deprecated 03214 * Arguments to callback have been reordered to Callback(func, arg) 03215 */ 03216 template<typename T, typename U> 03217 MBED_DEPRECATED_SINCE("mbed-os-5.1", 03218 "Arguments to callback have been reordered to Callback(func, arg)") 03219 Callback(volatile U *obj, R (*func)(volatile T*, A0, A1, A2, A3, A4)) { 03220 new (this) Callback(func, obj); 03221 } 03222 03223 /** Create a Callback with a static function and bound pointer 03224 * @param obj Pointer to object to bind to function 03225 * @param func Static function to attach 03226 * @deprecated 03227 * Arguments to callback have been reordered to Callback(func, arg) 03228 */ 03229 template<typename T, typename U> 03230 MBED_DEPRECATED_SINCE("mbed-os-5.1", 03231 "Arguments to callback have been reordered to Callback(func, arg)") 03232 Callback(const volatile U *obj, R (*func)(const volatile T*, A0, A1, A2, A3, A4)) { 03233 new (this) Callback(func, obj); 03234 } 03235 03236 /** Destroy a callback 03237 */ 03238 ~Callback() { 03239 if (_ops) { 03240 _ops->dtor(this); 03241 } 03242 } 03243 03244 /** Attach a static function 03245 * @param func Static function to attach 03246 * @deprecated 03247 * Replaced by simple assignment 'Callback cb = func' 03248 */ 03249 MBED_DEPRECATED_SINCE("mbed-os-5.4", 03250 "Replaced by simple assignment 'Callback cb = func") 03251 void attach(R (*func)(A0, A1, A2, A3, A4)) { 03252 this->~Callback(); 03253 new (this) Callback(func); 03254 } 03255 03256 /** Attach a Callback 03257 * @param func The Callback to attach 03258 * @deprecated 03259 * Replaced by simple assignment 'Callback cb = func' 03260 */ 03261 MBED_DEPRECATED_SINCE("mbed-os-5.4", 03262 "Replaced by simple assignment 'Callback cb = func") 03263 void attach(const Callback<R(A0, A1, A2, A3, A4)> &func) { 03264 this->~Callback(); 03265 new (this) Callback(func); 03266 } 03267 03268 /** Attach a member function 03269 * @param obj Pointer to object to invoke member function on 03270 * @param method Member function to attach 03271 * @deprecated 03272 * Replaced by simple assignment 'Callback cb = func' 03273 */ 03274 template<typename T, typename U> 03275 MBED_DEPRECATED_SINCE("mbed-os-5.4", 03276 "Replaced by simple assignment 'Callback cb = func") 03277 void attach(U *obj, R (T::*method)(A0, A1, A2, A3, A4)) { 03278 this->~Callback(); 03279 new (this) Callback(obj, method); 03280 } 03281 03282 /** Attach a member function 03283 * @param obj Pointer to object to invoke member function on 03284 * @param method Member function to attach 03285 * @deprecated 03286 * Replaced by simple assignment 'Callback cb = func' 03287 */ 03288 template<typename T, typename U> 03289 MBED_DEPRECATED_SINCE("mbed-os-5.4", 03290 "Replaced by simple assignment 'Callback cb = func") 03291 void attach(const U *obj, R (T::*method)(A0, A1, A2, A3, A4) const) { 03292 this->~Callback(); 03293 new (this) Callback(obj, method); 03294 } 03295 03296 /** Attach a member function 03297 * @param obj Pointer to object to invoke member function on 03298 * @param method Member function to attach 03299 * @deprecated 03300 * Replaced by simple assignment 'Callback cb = func' 03301 */ 03302 template<typename T, typename U> 03303 MBED_DEPRECATED_SINCE("mbed-os-5.4", 03304 "Replaced by simple assignment 'Callback cb = func") 03305 void attach(volatile U *obj, R (T::*method)(A0, A1, A2, A3, A4) volatile) { 03306 this->~Callback(); 03307 new (this) Callback(obj, method); 03308 } 03309 03310 /** Attach a member function 03311 * @param obj Pointer to object to invoke member function on 03312 * @param method Member function to attach 03313 * @deprecated 03314 * Replaced by simple assignment 'Callback cb = func' 03315 */ 03316 template<typename T, typename U> 03317 MBED_DEPRECATED_SINCE("mbed-os-5.4", 03318 "Replaced by simple assignment 'Callback cb = func") 03319 void attach(const volatile U *obj, R (T::*method)(A0, A1, A2, A3, A4) const volatile) { 03320 this->~Callback(); 03321 new (this) Callback(obj, method); 03322 } 03323 03324 /** Attach a static function with a bound pointer 03325 * @param func Static function to attach 03326 * @param arg Pointer argument to function 03327 * @deprecated 03328 * Replaced by simple assignment 'Callback cb = func' 03329 */ 03330 template <typename T, typename U> 03331 MBED_DEPRECATED_SINCE("mbed-os-5.4", 03332 "Replaced by simple assignment 'Callback cb = func") 03333 void attach(R (*func)(T*, A0, A1, A2, A3, A4), U *arg) { 03334 this->~Callback(); 03335 new (this) Callback(func, arg); 03336 } 03337 03338 /** Attach a static function with a bound pointer 03339 * @param func Static function to attach 03340 * @param arg Pointer argument to function 03341 * @deprecated 03342 * Replaced by simple assignment 'Callback cb = func' 03343 */ 03344 template <typename T, typename U> 03345 MBED_DEPRECATED_SINCE("mbed-os-5.4", 03346 "Replaced by simple assignment 'Callback cb = func") 03347 void attach(R (*func)(const T*, A0, A1, A2, A3, A4), const U *arg) { 03348 this->~Callback(); 03349 new (this) Callback(func, arg); 03350 } 03351 03352 /** Attach a static function with a bound pointer 03353 * @param func Static function to attach 03354 * @param arg Pointer argument to function 03355 * @deprecated 03356 * Replaced by simple assignment 'Callback cb = func' 03357 */ 03358 template <typename T, typename U> 03359 MBED_DEPRECATED_SINCE("mbed-os-5.4", 03360 "Replaced by simple assignment 'Callback cb = func") 03361 void attach(R (*func)(volatile T*, A0, A1, A2, A3, A4), volatile U *arg) { 03362 this->~Callback(); 03363 new (this) Callback(func, arg); 03364 } 03365 03366 /** Attach a static function with a bound pointer 03367 * @param func Static function to attach 03368 * @param arg Pointer argument to function 03369 * @deprecated 03370 * Replaced by simple assignment 'Callback cb = func' 03371 */ 03372 template <typename T, typename U> 03373 MBED_DEPRECATED_SINCE("mbed-os-5.4", 03374 "Replaced by simple assignment 'Callback cb = func") 03375 void attach(R (*func)(const volatile T*, A0, A1, A2, A3, A4), const volatile U *arg) { 03376 this->~Callback(); 03377 new (this) Callback(func, arg); 03378 } 03379 03380 /** Attach a function object 03381 * @param func Function object to attach 03382 * @note The function object is limited to a single word of storage 03383 * @deprecated 03384 * Replaced by simple assignment 'Callback cb = func' 03385 */ 03386 template <typename F> 03387 MBED_DEPRECATED_SINCE("mbed-os-5.4", 03388 "Replaced by simple assignment 'Callback cb = func") 03389 void attach(F f, typename detail::enable_if< 03390 detail::is_type<R (F::*)(A0, A1, A2, A3, A4), &F::operator()>::value && 03391 sizeof(F) <= sizeof(uintptr_t) 03392 >::type = detail::nil()) { 03393 this->~Callback(); 03394 new (this) Callback(f); 03395 } 03396 03397 /** Attach a function object 03398 * @param func Function object to attach 03399 * @note The function object is limited to a single word of storage 03400 * @deprecated 03401 * Replaced by simple assignment 'Callback cb = func' 03402 */ 03403 template <typename F> 03404 MBED_DEPRECATED_SINCE("mbed-os-5.4", 03405 "Replaced by simple assignment 'Callback cb = func") 03406 void attach(const F f, typename detail::enable_if< 03407 detail::is_type<R (F::*)(A0, A1, A2, A3, A4) const, &F::operator()>::value && 03408 sizeof(F) <= sizeof(uintptr_t) 03409 >::type = detail::nil()) { 03410 this->~Callback(); 03411 new (this) Callback(f); 03412 } 03413 03414 /** Attach a function object 03415 * @param func Function object to attach 03416 * @note The function object is limited to a single word of storage 03417 * @deprecated 03418 * Replaced by simple assignment 'Callback cb = func' 03419 */ 03420 template <typename F> 03421 MBED_DEPRECATED_SINCE("mbed-os-5.4", 03422 "Replaced by simple assignment 'Callback cb = func") 03423 void attach(volatile F f, typename detail::enable_if< 03424 detail::is_type<R (F::*)(A0, A1, A2, A3, A4) volatile, &F::operator()>::value && 03425 sizeof(F) <= sizeof(uintptr_t) 03426 >::type = detail::nil()) { 03427 this->~Callback(); 03428 new (this) Callback(f); 03429 } 03430 03431 /** Attach a function object 03432 * @param func Function object to attach 03433 * @note The function object is limited to a single word of storage 03434 * @deprecated 03435 * Replaced by simple assignment 'Callback cb = func' 03436 */ 03437 template <typename F> 03438 MBED_DEPRECATED_SINCE("mbed-os-5.4", 03439 "Replaced by simple assignment 'Callback cb = func") 03440 void attach(const volatile F f, typename detail::enable_if< 03441 detail::is_type<R (F::*)(A0, A1, A2, A3, A4) const volatile, &F::operator()>::value && 03442 sizeof(F) <= sizeof(uintptr_t) 03443 >::type = detail::nil()) { 03444 this->~Callback(); 03445 new (this) Callback(f); 03446 } 03447 03448 /** Attach a static function with a bound pointer 03449 * @param obj Pointer to object to bind to function 03450 * @param func Static function to attach 03451 * @deprecated 03452 * Arguments to callback have been reordered to attach(func, arg) 03453 */ 03454 template <typename T, typename U> 03455 MBED_DEPRECATED_SINCE("mbed-os-5.1", 03456 "Arguments to callback have been reordered to attach(func, arg)") 03457 void attach(U *obj, R (*func)(T*, A0, A1, A2, A3, A4)) { 03458 this->~Callback(); 03459 new (this) Callback(func, obj); 03460 } 03461 03462 /** Attach a static function with a bound pointer 03463 * @param obj Pointer to object to bind to function 03464 * @param func Static function to attach 03465 * @deprecated 03466 * Arguments to callback have been reordered to attach(func, arg) 03467 */ 03468 template <typename T, typename U> 03469 MBED_DEPRECATED_SINCE("mbed-os-5.1", 03470 "Arguments to callback have been reordered to attach(func, arg)") 03471 void attach(const U *obj, R (*func)(const T*, A0, A1, A2, A3, A4)) { 03472 this->~Callback(); 03473 new (this) Callback(func, obj); 03474 } 03475 03476 /** Attach a static function with a bound pointer 03477 * @param obj Pointer to object to bind to function 03478 * @param func Static function to attach 03479 * @deprecated 03480 * Arguments to callback have been reordered to attach(func, arg) 03481 */ 03482 template <typename T, typename U> 03483 MBED_DEPRECATED_SINCE("mbed-os-5.1", 03484 "Arguments to callback have been reordered to attach(func, arg)") 03485 void attach(volatile U *obj, R (*func)(volatile T*, A0, A1, A2, A3, A4)) { 03486 this->~Callback(); 03487 new (this) Callback(func, obj); 03488 } 03489 03490 /** Attach a static function with a bound pointer 03491 * @param obj Pointer to object to bind to function 03492 * @param func Static function to attach 03493 * @deprecated 03494 * Arguments to callback have been reordered to attach(func, arg) 03495 */ 03496 template <typename T, typename U> 03497 MBED_DEPRECATED_SINCE("mbed-os-5.1", 03498 "Arguments to callback have been reordered to attach(func, arg)") 03499 void attach(const volatile U *obj, R (*func)(const volatile T*, A0, A1, A2, A3, A4)) { 03500 this->~Callback(); 03501 new (this) Callback(func, obj); 03502 } 03503 03504 /** Assign a callback 03505 */ 03506 Callback &operator=(const Callback &that) { 03507 if (this != &that) { 03508 this->~Callback(); 03509 new (this) Callback(that); 03510 } 03511 03512 return *this; 03513 } 03514 03515 /** Call the attached function 03516 */ 03517 R call(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const { 03518 MBED_ASSERT(_ops); 03519 return _ops->call(this, a0, a1, a2, a3, a4); 03520 } 03521 03522 /** Call the attached function 03523 */ 03524 R operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const { 03525 return call(a0, a1, a2, a3, a4); 03526 } 03527 03528 /** Test if function has been attached 03529 */ 03530 operator bool() const { 03531 return _ops; 03532 } 03533 03534 /** Test for equality 03535 */ 03536 friend bool operator==(const Callback &l, const Callback &r) { 03537 return memcmp(&l, &r, sizeof(Callback)) == 0; 03538 } 03539 03540 /** Test for inequality 03541 */ 03542 friend bool operator!=(const Callback &l, const Callback &r) { 03543 return !(l == r); 03544 } 03545 03546 /** Static thunk for passing as C-style function 03547 * @param func Callback to call passed as void pointer 03548 */ 03549 static R thunk(void *func, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 03550 return static_cast<Callback*>(func)->call(a0, a1, a2, a3, a4); 03551 } 03552 03553 private: 03554 // Stored as pointer to function and pointer to optional object 03555 // Function pointer is stored as union of possible function types 03556 // to garuntee proper size and alignment 03557 struct _class; 03558 union { 03559 void (*_staticfunc)(A0, A1, A2, A3, A4); 03560 void (*_boundfunc)(_class*, A0, A1, A2, A3, A4); 03561 void (_class::*_methodfunc)(A0, A1, A2, A3, A4); 03562 } _func; 03563 void *_obj; 03564 03565 // Dynamically dispatched operations 03566 const struct ops { 03567 R (*call)(const void*, A0, A1, A2, A3, A4); 03568 void (*move)(void*, const void*); 03569 void (*dtor)(void*); 03570 } *_ops; 03571 03572 // Generate operations for function object 03573 template <typename F> 03574 void generate(const F &f) { 03575 static const ops ops = { 03576 &Callback::function_call<F>, 03577 &Callback::function_move<F>, 03578 &Callback::function_dtor<F>, 03579 }; 03580 03581 MBED_STATIC_ASSERT(sizeof(Callback) - sizeof(_ops) >= sizeof(F), 03582 "Type F must not exceed the size of the Callback class"); 03583 new (this) F(f); 03584 _ops = &ops; 03585 } 03586 03587 // Function attributes 03588 template <typename F> 03589 static R function_call(const void *p, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 03590 return (*(F*)p)(a0, a1, a2, a3, a4); 03591 } 03592 03593 template <typename F> 03594 static void function_move(void *d, const void *p) { 03595 new (d) F(*(F*)p); 03596 } 03597 03598 template <typename F> 03599 static void function_dtor(void *p) { 03600 ((F*)p)->~F(); 03601 } 03602 03603 // Wrappers for functions with context 03604 template <typename O, typename M> 03605 struct method_context { 03606 M method; 03607 O *obj; 03608 03609 method_context(O *obj, M method) 03610 : method(method), obj(obj) {} 03611 03612 R operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const { 03613 return (obj->*method)(a0, a1, a2, a3, a4); 03614 } 03615 }; 03616 03617 template <typename F, typename A> 03618 struct function_context { 03619 F func; 03620 A *arg; 03621 03622 function_context(F func, A *arg) 03623 : func(func), arg(arg) {} 03624 03625 R operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const { 03626 return func(arg, a0, a1, a2, a3, a4); 03627 } 03628 }; 03629 }; 03630 03631 // Internally used event type 03632 typedef Callback<void(int)> event_callback_t; 03633 03634 03635 /** Create a callback class with type infered from the arguments 03636 * 03637 * @param func Static function to attach 03638 * @return Callback with infered type 03639 */ 03640 template <typename R> 03641 Callback<R()> callback(R (*func)() = 0) { 03642 return Callback<R()>(func); 03643 } 03644 03645 /** Create a callback class with type infered from the arguments 03646 * 03647 * @param func Static function to attach 03648 * @return Callback with infered type 03649 */ 03650 template <typename R> 03651 Callback<R()> callback(const Callback<R()> &func) { 03652 return Callback<R()>(func); 03653 } 03654 03655 /** Create a callback class with type infered from the arguments 03656 * 03657 * @param obj Optional pointer to object to bind to function 03658 * @param method Member function to attach 03659 * @return Callback with infered type 03660 */ 03661 template<typename T, typename U, typename R> 03662 Callback<R()> callback(U *obj, R (T::*method)()) { 03663 return Callback<R()>(obj, method); 03664 } 03665 03666 /** Create a callback class with type infered from the arguments 03667 * 03668 * @param obj Optional pointer to object to bind to function 03669 * @param method Member function to attach 03670 * @return Callback with infered type 03671 */ 03672 template<typename T, typename U, typename R> 03673 Callback<R()> callback(const U *obj, R (T::*method)() const) { 03674 return Callback<R()>(obj, method); 03675 } 03676 03677 /** Create a callback class with type infered from the arguments 03678 * 03679 * @param obj Optional pointer to object to bind to function 03680 * @param method Member function to attach 03681 * @return Callback with infered type 03682 */ 03683 template<typename T, typename U, typename R> 03684 Callback<R()> callback(volatile U *obj, R (T::*method)() volatile) { 03685 return Callback<R()>(obj, method); 03686 } 03687 03688 /** Create a callback class with type infered from the arguments 03689 * 03690 * @param obj Optional pointer to object to bind to function 03691 * @param method Member function to attach 03692 * @return Callback with infered type 03693 */ 03694 template<typename T, typename U, typename R> 03695 Callback<R()> callback(const volatile U *obj, R (T::*method)() const volatile) { 03696 return Callback<R()>(obj, method); 03697 } 03698 03699 /** Create a callback class with type infered from the arguments 03700 * 03701 * @param func Static function to attach 03702 * @param arg Pointer argument to function 03703 * @return Callback with infered type 03704 */ 03705 template <typename T, typename U, typename R> 03706 Callback<R()> callback(R (*func)(T*), U *arg) { 03707 return Callback<R()>(func, arg); 03708 } 03709 03710 /** Create a callback class with type infered from the arguments 03711 * 03712 * @param func Static function to attach 03713 * @param arg Pointer argument to function 03714 * @return Callback with infered type 03715 */ 03716 template <typename T, typename U, typename R> 03717 Callback<R()> callback(R (*func)(const T*), const U *arg) { 03718 return Callback<R()>(func, arg); 03719 } 03720 03721 /** Create a callback class with type infered from the arguments 03722 * 03723 * @param func Static function to attach 03724 * @param arg Pointer argument to function 03725 * @return Callback with infered type 03726 */ 03727 template <typename T, typename U, typename R> 03728 Callback<R()> callback(R (*func)(volatile T*), volatile U *arg) { 03729 return Callback<R()>(func, arg); 03730 } 03731 03732 /** Create a callback class with type infered from the arguments 03733 * 03734 * @param func Static function to attach 03735 * @param arg Pointer argument to function 03736 * @return Callback with infered type 03737 */ 03738 template <typename T, typename U, typename R> 03739 Callback<R()> callback(R (*func)(const volatile T*), const volatile U *arg) { 03740 return Callback<R()>(func, arg); 03741 } 03742 03743 /** Create a callback class with type infered from the arguments 03744 * 03745 * @param obj Optional pointer to object to bind to function 03746 * @param func Static function to attach 03747 * @return Callback with infered type 03748 * @deprecated 03749 * Arguments to callback have been reordered to callback(func, arg) 03750 */ 03751 template <typename T, typename U, typename R> 03752 MBED_DEPRECATED_SINCE("mbed-os-5.1", 03753 "Arguments to callback have been reordered to callback(func, arg)") 03754 Callback<R()> callback(U *obj, R (*func)(T*)) { 03755 return Callback<R()>(func, obj); 03756 } 03757 03758 /** Create a callback class with type infered from the arguments 03759 * 03760 * @param obj Optional pointer to object to bind to function 03761 * @param func Static function to attach 03762 * @return Callback with infered type 03763 * @deprecated 03764 * Arguments to callback have been reordered to callback(func, arg) 03765 */ 03766 template <typename T, typename U, typename R> 03767 MBED_DEPRECATED_SINCE("mbed-os-5.1", 03768 "Arguments to callback have been reordered to callback(func, arg)") 03769 Callback<R()> callback(const U *obj, R (*func)(const T*)) { 03770 return Callback<R()>(func, obj); 03771 } 03772 03773 /** Create a callback class with type infered from the arguments 03774 * 03775 * @param obj Optional pointer to object to bind to function 03776 * @param func Static function to attach 03777 * @return Callback with infered type 03778 * @deprecated 03779 * Arguments to callback have been reordered to callback(func, arg) 03780 */ 03781 template <typename T, typename U, typename R> 03782 MBED_DEPRECATED_SINCE("mbed-os-5.1", 03783 "Arguments to callback have been reordered to callback(func, arg)") 03784 Callback<R()> callback(volatile U *obj, R (*func)(volatile T*)) { 03785 return Callback<R()>(func, obj); 03786 } 03787 03788 /** Create a callback class with type infered from the arguments 03789 * 03790 * @param obj Optional pointer to object to bind to function 03791 * @param func Static function to attach 03792 * @return Callback with infered type 03793 * @deprecated 03794 * Arguments to callback have been reordered to callback(func, arg) 03795 */ 03796 template <typename T, typename U, typename R> 03797 MBED_DEPRECATED_SINCE("mbed-os-5.1", 03798 "Arguments to callback have been reordered to callback(func, arg)") 03799 Callback<R()> callback(const volatile U *obj, R (*func)(const volatile T*)) { 03800 return Callback<R()>(func, obj); 03801 } 03802 03803 03804 /** Create a callback class with type infered from the arguments 03805 * 03806 * @param func Static function to attach 03807 * @return Callback with infered type 03808 */ 03809 template <typename R, typename A0> 03810 Callback<R(A0)> callback(R (*func)(A0) = 0) { 03811 return Callback<R(A0)>(func); 03812 } 03813 03814 /** Create a callback class with type infered from the arguments 03815 * 03816 * @param func Static function to attach 03817 * @return Callback with infered type 03818 */ 03819 template <typename R, typename A0> 03820 Callback<R(A0)> callback(const Callback<R(A0)> &func) { 03821 return Callback<R(A0)>(func); 03822 } 03823 03824 /** Create a callback class with type infered from the arguments 03825 * 03826 * @param obj Optional pointer to object to bind to function 03827 * @param method Member function to attach 03828 * @return Callback with infered type 03829 */ 03830 template<typename T, typename U, typename R, typename A0> 03831 Callback<R(A0)> callback(U *obj, R (T::*method)(A0)) { 03832 return Callback<R(A0)>(obj, method); 03833 } 03834 03835 /** Create a callback class with type infered from the arguments 03836 * 03837 * @param obj Optional pointer to object to bind to function 03838 * @param method Member function to attach 03839 * @return Callback with infered type 03840 */ 03841 template<typename T, typename U, typename R, typename A0> 03842 Callback<R(A0)> callback(const U *obj, R (T::*method)(A0) const) { 03843 return Callback<R(A0)>(obj, method); 03844 } 03845 03846 /** Create a callback class with type infered from the arguments 03847 * 03848 * @param obj Optional pointer to object to bind to function 03849 * @param method Member function to attach 03850 * @return Callback with infered type 03851 */ 03852 template<typename T, typename U, typename R, typename A0> 03853 Callback<R(A0)> callback(volatile U *obj, R (T::*method)(A0) volatile) { 03854 return Callback<R(A0)>(obj, method); 03855 } 03856 03857 /** Create a callback class with type infered from the arguments 03858 * 03859 * @param obj Optional pointer to object to bind to function 03860 * @param method Member function to attach 03861 * @return Callback with infered type 03862 */ 03863 template<typename T, typename U, typename R, typename A0> 03864 Callback<R(A0)> callback(const volatile U *obj, R (T::*method)(A0) const volatile) { 03865 return Callback<R(A0)>(obj, method); 03866 } 03867 03868 /** Create a callback class with type infered from the arguments 03869 * 03870 * @param func Static function to attach 03871 * @param arg Pointer argument to function 03872 * @return Callback with infered type 03873 */ 03874 template <typename T, typename U, typename R, typename A0> 03875 Callback<R(A0)> callback(R (*func)(T*, A0), U *arg) { 03876 return Callback<R(A0)>(func, arg); 03877 } 03878 03879 /** Create a callback class with type infered from the arguments 03880 * 03881 * @param func Static function to attach 03882 * @param arg Pointer argument to function 03883 * @return Callback with infered type 03884 */ 03885 template <typename T, typename U, typename R, typename A0> 03886 Callback<R(A0)> callback(R (*func)(const T*, A0), const U *arg) { 03887 return Callback<R(A0)>(func, arg); 03888 } 03889 03890 /** Create a callback class with type infered from the arguments 03891 * 03892 * @param func Static function to attach 03893 * @param arg Pointer argument to function 03894 * @return Callback with infered type 03895 */ 03896 template <typename T, typename U, typename R, typename A0> 03897 Callback<R(A0)> callback(R (*func)(volatile T*, A0), volatile U *arg) { 03898 return Callback<R(A0)>(func, arg); 03899 } 03900 03901 /** Create a callback class with type infered from the arguments 03902 * 03903 * @param func Static function to attach 03904 * @param arg Pointer argument to function 03905 * @return Callback with infered type 03906 */ 03907 template <typename T, typename U, typename R, typename A0> 03908 Callback<R(A0)> callback(R (*func)(const volatile T*, A0), const volatile U *arg) { 03909 return Callback<R(A0)>(func, arg); 03910 } 03911 03912 /** Create a callback class with type infered from the arguments 03913 * 03914 * @param obj Optional pointer to object to bind to function 03915 * @param func Static function to attach 03916 * @return Callback with infered type 03917 * @deprecated 03918 * Arguments to callback have been reordered to callback(func, arg) 03919 */ 03920 template <typename T, typename U, typename R, typename A0> 03921 MBED_DEPRECATED_SINCE("mbed-os-5.1", 03922 "Arguments to callback have been reordered to callback(func, arg)") 03923 Callback<R(A0)> callback(U *obj, R (*func)(T*, A0)) { 03924 return Callback<R(A0)>(func, obj); 03925 } 03926 03927 /** Create a callback class with type infered from the arguments 03928 * 03929 * @param obj Optional pointer to object to bind to function 03930 * @param func Static function to attach 03931 * @return Callback with infered type 03932 * @deprecated 03933 * Arguments to callback have been reordered to callback(func, arg) 03934 */ 03935 template <typename T, typename U, typename R, typename A0> 03936 MBED_DEPRECATED_SINCE("mbed-os-5.1", 03937 "Arguments to callback have been reordered to callback(func, arg)") 03938 Callback<R(A0)> callback(const U *obj, R (*func)(const T*, A0)) { 03939 return Callback<R(A0)>(func, obj); 03940 } 03941 03942 /** Create a callback class with type infered from the arguments 03943 * 03944 * @param obj Optional pointer to object to bind to function 03945 * @param func Static function to attach 03946 * @return Callback with infered type 03947 * @deprecated 03948 * Arguments to callback have been reordered to callback(func, arg) 03949 */ 03950 template <typename T, typename U, typename R, typename A0> 03951 MBED_DEPRECATED_SINCE("mbed-os-5.1", 03952 "Arguments to callback have been reordered to callback(func, arg)") 03953 Callback<R(A0)> callback(volatile U *obj, R (*func)(volatile T*, A0)) { 03954 return Callback<R(A0)>(func, obj); 03955 } 03956 03957 /** Create a callback class with type infered from the arguments 03958 * 03959 * @param obj Optional pointer to object to bind to function 03960 * @param func Static function to attach 03961 * @return Callback with infered type 03962 * @deprecated 03963 * Arguments to callback have been reordered to callback(func, arg) 03964 */ 03965 template <typename T, typename U, typename R, typename A0> 03966 MBED_DEPRECATED_SINCE("mbed-os-5.1", 03967 "Arguments to callback have been reordered to callback(func, arg)") 03968 Callback<R(A0)> callback(const volatile U *obj, R (*func)(const volatile T*, A0)) { 03969 return Callback<R(A0)>(func, obj); 03970 } 03971 03972 03973 /** Create a callback class with type infered from the arguments 03974 * 03975 * @param func Static function to attach 03976 * @return Callback with infered type 03977 */ 03978 template <typename R, typename A0, typename A1> 03979 Callback<R(A0, A1)> callback(R (*func)(A0, A1) = 0) { 03980 return Callback<R(A0, A1)>(func); 03981 } 03982 03983 /** Create a callback class with type infered from the arguments 03984 * 03985 * @param func Static function to attach 03986 * @return Callback with infered type 03987 */ 03988 template <typename R, typename A0, typename A1> 03989 Callback<R(A0, A1)> callback(const Callback<R(A0, A1)> &func) { 03990 return Callback<R(A0, A1)>(func); 03991 } 03992 03993 /** Create a callback class with type infered from the arguments 03994 * 03995 * @param obj Optional pointer to object to bind to function 03996 * @param method Member function to attach 03997 * @return Callback with infered type 03998 */ 03999 template<typename T, typename U, typename R, typename A0, typename A1> 04000 Callback<R(A0, A1)> callback(U *obj, R (T::*method)(A0, A1)) { 04001 return Callback<R(A0, A1)>(obj, method); 04002 } 04003 04004 /** Create a callback class with type infered from the arguments 04005 * 04006 * @param obj Optional pointer to object to bind to function 04007 * @param method Member function to attach 04008 * @return Callback with infered type 04009 */ 04010 template<typename T, typename U, typename R, typename A0, typename A1> 04011 Callback<R(A0, A1)> callback(const U *obj, R (T::*method)(A0, A1) const) { 04012 return Callback<R(A0, A1)>(obj, method); 04013 } 04014 04015 /** Create a callback class with type infered from the arguments 04016 * 04017 * @param obj Optional pointer to object to bind to function 04018 * @param method Member function to attach 04019 * @return Callback with infered type 04020 */ 04021 template<typename T, typename U, typename R, typename A0, typename A1> 04022 Callback<R(A0, A1)> callback(volatile U *obj, R (T::*method)(A0, A1) volatile) { 04023 return Callback<R(A0, A1)>(obj, method); 04024 } 04025 04026 /** Create a callback class with type infered from the arguments 04027 * 04028 * @param obj Optional pointer to object to bind to function 04029 * @param method Member function to attach 04030 * @return Callback with infered type 04031 */ 04032 template<typename T, typename U, typename R, typename A0, typename A1> 04033 Callback<R(A0, A1)> callback(const volatile U *obj, R (T::*method)(A0, A1) const volatile) { 04034 return Callback<R(A0, A1)>(obj, method); 04035 } 04036 04037 /** Create a callback class with type infered from the arguments 04038 * 04039 * @param func Static function to attach 04040 * @param arg Pointer argument to function 04041 * @return Callback with infered type 04042 */ 04043 template <typename T, typename U, typename R, typename A0, typename A1> 04044 Callback<R(A0, A1)> callback(R (*func)(T*, A0, A1), U *arg) { 04045 return Callback<R(A0, A1)>(func, arg); 04046 } 04047 04048 /** Create a callback class with type infered from the arguments 04049 * 04050 * @param func Static function to attach 04051 * @param arg Pointer argument to function 04052 * @return Callback with infered type 04053 */ 04054 template <typename T, typename U, typename R, typename A0, typename A1> 04055 Callback<R(A0, A1)> callback(R (*func)(const T*, A0, A1), const U *arg) { 04056 return Callback<R(A0, A1)>(func, arg); 04057 } 04058 04059 /** Create a callback class with type infered from the arguments 04060 * 04061 * @param func Static function to attach 04062 * @param arg Pointer argument to function 04063 * @return Callback with infered type 04064 */ 04065 template <typename T, typename U, typename R, typename A0, typename A1> 04066 Callback<R(A0, A1)> callback(R (*func)(volatile T*, A0, A1), volatile U *arg) { 04067 return Callback<R(A0, A1)>(func, arg); 04068 } 04069 04070 /** Create a callback class with type infered from the arguments 04071 * 04072 * @param func Static function to attach 04073 * @param arg Pointer argument to function 04074 * @return Callback with infered type 04075 */ 04076 template <typename T, typename U, typename R, typename A0, typename A1> 04077 Callback<R(A0, A1)> callback(R (*func)(const volatile T*, A0, A1), const volatile U *arg) { 04078 return Callback<R(A0, A1)>(func, arg); 04079 } 04080 04081 /** Create a callback class with type infered from the arguments 04082 * 04083 * @param obj Optional pointer to object to bind to function 04084 * @param func Static function to attach 04085 * @return Callback with infered type 04086 * @deprecated 04087 * Arguments to callback have been reordered to callback(func, arg) 04088 */ 04089 template <typename T, typename U, typename R, typename A0, typename A1> 04090 MBED_DEPRECATED_SINCE("mbed-os-5.1", 04091 "Arguments to callback have been reordered to callback(func, arg)") 04092 Callback<R(A0, A1)> callback(U *obj, R (*func)(T*, A0, A1)) { 04093 return Callback<R(A0, A1)>(func, obj); 04094 } 04095 04096 /** Create a callback class with type infered from the arguments 04097 * 04098 * @param obj Optional pointer to object to bind to function 04099 * @param func Static function to attach 04100 * @return Callback with infered type 04101 * @deprecated 04102 * Arguments to callback have been reordered to callback(func, arg) 04103 */ 04104 template <typename T, typename U, typename R, typename A0, typename A1> 04105 MBED_DEPRECATED_SINCE("mbed-os-5.1", 04106 "Arguments to callback have been reordered to callback(func, arg)") 04107 Callback<R(A0, A1)> callback(const U *obj, R (*func)(const T*, A0, A1)) { 04108 return Callback<R(A0, A1)>(func, obj); 04109 } 04110 04111 /** Create a callback class with type infered from the arguments 04112 * 04113 * @param obj Optional pointer to object to bind to function 04114 * @param func Static function to attach 04115 * @return Callback with infered type 04116 * @deprecated 04117 * Arguments to callback have been reordered to callback(func, arg) 04118 */ 04119 template <typename T, typename U, typename R, typename A0, typename A1> 04120 MBED_DEPRECATED_SINCE("mbed-os-5.1", 04121 "Arguments to callback have been reordered to callback(func, arg)") 04122 Callback<R(A0, A1)> callback(volatile U *obj, R (*func)(volatile T*, A0, A1)) { 04123 return Callback<R(A0, A1)>(func, obj); 04124 } 04125 04126 /** Create a callback class with type infered from the arguments 04127 * 04128 * @param obj Optional pointer to object to bind to function 04129 * @param func Static function to attach 04130 * @return Callback with infered type 04131 * @deprecated 04132 * Arguments to callback have been reordered to callback(func, arg) 04133 */ 04134 template <typename T, typename U, typename R, typename A0, typename A1> 04135 MBED_DEPRECATED_SINCE("mbed-os-5.1", 04136 "Arguments to callback have been reordered to callback(func, arg)") 04137 Callback<R(A0, A1)> callback(const volatile U *obj, R (*func)(const volatile T*, A0, A1)) { 04138 return Callback<R(A0, A1)>(func, obj); 04139 } 04140 04141 04142 /** Create a callback class with type infered from the arguments 04143 * 04144 * @param func Static function to attach 04145 * @return Callback with infered type 04146 */ 04147 template <typename R, typename A0, typename A1, typename A2> 04148 Callback<R(A0, A1, A2)> callback(R (*func)(A0, A1, A2) = 0) { 04149 return Callback<R(A0, A1, A2)>(func); 04150 } 04151 04152 /** Create a callback class with type infered from the arguments 04153 * 04154 * @param func Static function to attach 04155 * @return Callback with infered type 04156 */ 04157 template <typename R, typename A0, typename A1, typename A2> 04158 Callback<R(A0, A1, A2)> callback(const Callback<R(A0, A1, A2)> &func) { 04159 return Callback<R(A0, A1, A2)>(func); 04160 } 04161 04162 /** Create a callback class with type infered from the arguments 04163 * 04164 * @param obj Optional pointer to object to bind to function 04165 * @param method Member function to attach 04166 * @return Callback with infered type 04167 */ 04168 template<typename T, typename U, typename R, typename A0, typename A1, typename A2> 04169 Callback<R(A0, A1, A2)> callback(U *obj, R (T::*method)(A0, A1, A2)) { 04170 return Callback<R(A0, A1, A2)>(obj, method); 04171 } 04172 04173 /** Create a callback class with type infered from the arguments 04174 * 04175 * @param obj Optional pointer to object to bind to function 04176 * @param method Member function to attach 04177 * @return Callback with infered type 04178 */ 04179 template<typename T, typename U, typename R, typename A0, typename A1, typename A2> 04180 Callback<R(A0, A1, A2)> callback(const U *obj, R (T::*method)(A0, A1, A2) const) { 04181 return Callback<R(A0, A1, A2)>(obj, method); 04182 } 04183 04184 /** Create a callback class with type infered from the arguments 04185 * 04186 * @param obj Optional pointer to object to bind to function 04187 * @param method Member function to attach 04188 * @return Callback with infered type 04189 */ 04190 template<typename T, typename U, typename R, typename A0, typename A1, typename A2> 04191 Callback<R(A0, A1, A2)> callback(volatile U *obj, R (T::*method)(A0, A1, A2) volatile) { 04192 return Callback<R(A0, A1, A2)>(obj, method); 04193 } 04194 04195 /** Create a callback class with type infered from the arguments 04196 * 04197 * @param obj Optional pointer to object to bind to function 04198 * @param method Member function to attach 04199 * @return Callback with infered type 04200 */ 04201 template<typename T, typename U, typename R, typename A0, typename A1, typename A2> 04202 Callback<R(A0, A1, A2)> callback(const volatile U *obj, R (T::*method)(A0, A1, A2) const volatile) { 04203 return Callback<R(A0, A1, A2)>(obj, method); 04204 } 04205 04206 /** Create a callback class with type infered from the arguments 04207 * 04208 * @param func Static function to attach 04209 * @param arg Pointer argument to function 04210 * @return Callback with infered type 04211 */ 04212 template <typename T, typename U, typename R, typename A0, typename A1, typename A2> 04213 Callback<R(A0, A1, A2)> callback(R (*func)(T*, A0, A1, A2), U *arg) { 04214 return Callback<R(A0, A1, A2)>(func, arg); 04215 } 04216 04217 /** Create a callback class with type infered from the arguments 04218 * 04219 * @param func Static function to attach 04220 * @param arg Pointer argument to function 04221 * @return Callback with infered type 04222 */ 04223 template <typename T, typename U, typename R, typename A0, typename A1, typename A2> 04224 Callback<R(A0, A1, A2)> callback(R (*func)(const T*, A0, A1, A2), const U *arg) { 04225 return Callback<R(A0, A1, A2)>(func, arg); 04226 } 04227 04228 /** Create a callback class with type infered from the arguments 04229 * 04230 * @param func Static function to attach 04231 * @param arg Pointer argument to function 04232 * @return Callback with infered type 04233 */ 04234 template <typename T, typename U, typename R, typename A0, typename A1, typename A2> 04235 Callback<R(A0, A1, A2)> callback(R (*func)(volatile T*, A0, A1, A2), volatile U *arg) { 04236 return Callback<R(A0, A1, A2)>(func, arg); 04237 } 04238 04239 /** Create a callback class with type infered from the arguments 04240 * 04241 * @param func Static function to attach 04242 * @param arg Pointer argument to function 04243 * @return Callback with infered type 04244 */ 04245 template <typename T, typename U, typename R, typename A0, typename A1, typename A2> 04246 Callback<R(A0, A1, A2)> callback(R (*func)(const volatile T*, A0, A1, A2), const volatile U *arg) { 04247 return Callback<R(A0, A1, A2)>(func, arg); 04248 } 04249 04250 /** Create a callback class with type infered from the arguments 04251 * 04252 * @param obj Optional pointer to object to bind to function 04253 * @param func Static function to attach 04254 * @return Callback with infered type 04255 * @deprecated 04256 * Arguments to callback have been reordered to callback(func, arg) 04257 */ 04258 template <typename T, typename U, typename R, typename A0, typename A1, typename A2> 04259 MBED_DEPRECATED_SINCE("mbed-os-5.1", 04260 "Arguments to callback have been reordered to callback(func, arg)") 04261 Callback<R(A0, A1, A2)> callback(U *obj, R (*func)(T*, A0, A1, A2)) { 04262 return Callback<R(A0, A1, A2)>(func, obj); 04263 } 04264 04265 /** Create a callback class with type infered from the arguments 04266 * 04267 * @param obj Optional pointer to object to bind to function 04268 * @param func Static function to attach 04269 * @return Callback with infered type 04270 * @deprecated 04271 * Arguments to callback have been reordered to callback(func, arg) 04272 */ 04273 template <typename T, typename U, typename R, typename A0, typename A1, typename A2> 04274 MBED_DEPRECATED_SINCE("mbed-os-5.1", 04275 "Arguments to callback have been reordered to callback(func, arg)") 04276 Callback<R(A0, A1, A2)> callback(const U *obj, R (*func)(const T*, A0, A1, A2)) { 04277 return Callback<R(A0, A1, A2)>(func, obj); 04278 } 04279 04280 /** Create a callback class with type infered from the arguments 04281 * 04282 * @param obj Optional pointer to object to bind to function 04283 * @param func Static function to attach 04284 * @return Callback with infered type 04285 * @deprecated 04286 * Arguments to callback have been reordered to callback(func, arg) 04287 */ 04288 template <typename T, typename U, typename R, typename A0, typename A1, typename A2> 04289 MBED_DEPRECATED_SINCE("mbed-os-5.1", 04290 "Arguments to callback have been reordered to callback(func, arg)") 04291 Callback<R(A0, A1, A2)> callback(volatile U *obj, R (*func)(volatile T*, A0, A1, A2)) { 04292 return Callback<R(A0, A1, A2)>(func, obj); 04293 } 04294 04295 /** Create a callback class with type infered from the arguments 04296 * 04297 * @param obj Optional pointer to object to bind to function 04298 * @param func Static function to attach 04299 * @return Callback with infered type 04300 * @deprecated 04301 * Arguments to callback have been reordered to callback(func, arg) 04302 */ 04303 template <typename T, typename U, typename R, typename A0, typename A1, typename A2> 04304 MBED_DEPRECATED_SINCE("mbed-os-5.1", 04305 "Arguments to callback have been reordered to callback(func, arg)") 04306 Callback<R(A0, A1, A2)> callback(const volatile U *obj, R (*func)(const volatile T*, A0, A1, A2)) { 04307 return Callback<R(A0, A1, A2)>(func, obj); 04308 } 04309 04310 04311 /** Create a callback class with type infered from the arguments 04312 * 04313 * @param func Static function to attach 04314 * @return Callback with infered type 04315 */ 04316 template <typename R, typename A0, typename A1, typename A2, typename A3> 04317 Callback<R(A0, A1, A2, A3)> callback(R (*func)(A0, A1, A2, A3) = 0) { 04318 return Callback<R(A0, A1, A2, A3)>(func); 04319 } 04320 04321 /** Create a callback class with type infered from the arguments 04322 * 04323 * @param func Static function to attach 04324 * @return Callback with infered type 04325 */ 04326 template <typename R, typename A0, typename A1, typename A2, typename A3> 04327 Callback<R(A0, A1, A2, A3)> callback(const Callback<R(A0, A1, A2, A3)> &func) { 04328 return Callback<R(A0, A1, A2, A3)>(func); 04329 } 04330 04331 /** Create a callback class with type infered from the arguments 04332 * 04333 * @param obj Optional pointer to object to bind to function 04334 * @param method Member function to attach 04335 * @return Callback with infered type 04336 */ 04337 template<typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3> 04338 Callback<R(A0, A1, A2, A3)> callback(U *obj, R (T::*method)(A0, A1, A2, A3)) { 04339 return Callback<R(A0, A1, A2, A3)>(obj, method); 04340 } 04341 04342 /** Create a callback class with type infered from the arguments 04343 * 04344 * @param obj Optional pointer to object to bind to function 04345 * @param method Member function to attach 04346 * @return Callback with infered type 04347 */ 04348 template<typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3> 04349 Callback<R(A0, A1, A2, A3)> callback(const U *obj, R (T::*method)(A0, A1, A2, A3) const) { 04350 return Callback<R(A0, A1, A2, A3)>(obj, method); 04351 } 04352 04353 /** Create a callback class with type infered from the arguments 04354 * 04355 * @param obj Optional pointer to object to bind to function 04356 * @param method Member function to attach 04357 * @return Callback with infered type 04358 */ 04359 template<typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3> 04360 Callback<R(A0, A1, A2, A3)> callback(volatile U *obj, R (T::*method)(A0, A1, A2, A3) volatile) { 04361 return Callback<R(A0, A1, A2, A3)>(obj, method); 04362 } 04363 04364 /** Create a callback class with type infered from the arguments 04365 * 04366 * @param obj Optional pointer to object to bind to function 04367 * @param method Member function to attach 04368 * @return Callback with infered type 04369 */ 04370 template<typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3> 04371 Callback<R(A0, A1, A2, A3)> callback(const volatile U *obj, R (T::*method)(A0, A1, A2, A3) const volatile) { 04372 return Callback<R(A0, A1, A2, A3)>(obj, method); 04373 } 04374 04375 /** Create a callback class with type infered from the arguments 04376 * 04377 * @param func Static function to attach 04378 * @param arg Pointer argument to function 04379 * @return Callback with infered type 04380 */ 04381 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3> 04382 Callback<R(A0, A1, A2, A3)> callback(R (*func)(T*, A0, A1, A2, A3), U *arg) { 04383 return Callback<R(A0, A1, A2, A3)>(func, arg); 04384 } 04385 04386 /** Create a callback class with type infered from the arguments 04387 * 04388 * @param func Static function to attach 04389 * @param arg Pointer argument to function 04390 * @return Callback with infered type 04391 */ 04392 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3> 04393 Callback<R(A0, A1, A2, A3)> callback(R (*func)(const T*, A0, A1, A2, A3), const U *arg) { 04394 return Callback<R(A0, A1, A2, A3)>(func, arg); 04395 } 04396 04397 /** Create a callback class with type infered from the arguments 04398 * 04399 * @param func Static function to attach 04400 * @param arg Pointer argument to function 04401 * @return Callback with infered type 04402 */ 04403 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3> 04404 Callback<R(A0, A1, A2, A3)> callback(R (*func)(volatile T*, A0, A1, A2, A3), volatile U *arg) { 04405 return Callback<R(A0, A1, A2, A3)>(func, arg); 04406 } 04407 04408 /** Create a callback class with type infered from the arguments 04409 * 04410 * @param func Static function to attach 04411 * @param arg Pointer argument to function 04412 * @return Callback with infered type 04413 */ 04414 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3> 04415 Callback<R(A0, A1, A2, A3)> callback(R (*func)(const volatile T*, A0, A1, A2, A3), const volatile U *arg) { 04416 return Callback<R(A0, A1, A2, A3)>(func, arg); 04417 } 04418 04419 /** Create a callback class with type infered from the arguments 04420 * 04421 * @param obj Optional pointer to object to bind to function 04422 * @param func Static function to attach 04423 * @return Callback with infered type 04424 * @deprecated 04425 * Arguments to callback have been reordered to callback(func, arg) 04426 */ 04427 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3> 04428 MBED_DEPRECATED_SINCE("mbed-os-5.1", 04429 "Arguments to callback have been reordered to callback(func, arg)") 04430 Callback<R(A0, A1, A2, A3)> callback(U *obj, R (*func)(T*, A0, A1, A2, A3)) { 04431 return Callback<R(A0, A1, A2, A3)>(func, obj); 04432 } 04433 04434 /** Create a callback class with type infered from the arguments 04435 * 04436 * @param obj Optional pointer to object to bind to function 04437 * @param func Static function to attach 04438 * @return Callback with infered type 04439 * @deprecated 04440 * Arguments to callback have been reordered to callback(func, arg) 04441 */ 04442 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3> 04443 MBED_DEPRECATED_SINCE("mbed-os-5.1", 04444 "Arguments to callback have been reordered to callback(func, arg)") 04445 Callback<R(A0, A1, A2, A3)> callback(const U *obj, R (*func)(const T*, A0, A1, A2, A3)) { 04446 return Callback<R(A0, A1, A2, A3)>(func, obj); 04447 } 04448 04449 /** Create a callback class with type infered from the arguments 04450 * 04451 * @param obj Optional pointer to object to bind to function 04452 * @param func Static function to attach 04453 * @return Callback with infered type 04454 * @deprecated 04455 * Arguments to callback have been reordered to callback(func, arg) 04456 */ 04457 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3> 04458 MBED_DEPRECATED_SINCE("mbed-os-5.1", 04459 "Arguments to callback have been reordered to callback(func, arg)") 04460 Callback<R(A0, A1, A2, A3)> callback(volatile U *obj, R (*func)(volatile T*, A0, A1, A2, A3)) { 04461 return Callback<R(A0, A1, A2, A3)>(func, obj); 04462 } 04463 04464 /** Create a callback class with type infered from the arguments 04465 * 04466 * @param obj Optional pointer to object to bind to function 04467 * @param func Static function to attach 04468 * @return Callback with infered type 04469 * @deprecated 04470 * Arguments to callback have been reordered to callback(func, arg) 04471 */ 04472 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3> 04473 MBED_DEPRECATED_SINCE("mbed-os-5.1", 04474 "Arguments to callback have been reordered to callback(func, arg)") 04475 Callback<R(A0, A1, A2, A3)> callback(const volatile U *obj, R (*func)(const volatile T*, A0, A1, A2, A3)) { 04476 return Callback<R(A0, A1, A2, A3)>(func, obj); 04477 } 04478 04479 04480 /** Create a callback class with type infered from the arguments 04481 * 04482 * @param func Static function to attach 04483 * @return Callback with infered type 04484 */ 04485 template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 04486 Callback<R(A0, A1, A2, A3, A4)> callback(R (*func)(A0, A1, A2, A3, A4) = 0) { 04487 return Callback<R(A0, A1, A2, A3, A4)>(func); 04488 } 04489 04490 /** Create a callback class with type infered from the arguments 04491 * 04492 * @param func Static function to attach 04493 * @return Callback with infered type 04494 */ 04495 template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 04496 Callback<R(A0, A1, A2, A3, A4)> callback(const Callback<R(A0, A1, A2, A3, A4)> &func) { 04497 return Callback<R(A0, A1, A2, A3, A4)>(func); 04498 } 04499 04500 /** Create a callback class with type infered from the arguments 04501 * 04502 * @param obj Optional pointer to object to bind to function 04503 * @param method Member function to attach 04504 * @return Callback with infered type 04505 */ 04506 template<typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 04507 Callback<R(A0, A1, A2, A3, A4)> callback(U *obj, R (T::*method)(A0, A1, A2, A3, A4)) { 04508 return Callback<R(A0, A1, A2, A3, A4)>(obj, method); 04509 } 04510 04511 /** Create a callback class with type infered from the arguments 04512 * 04513 * @param obj Optional pointer to object to bind to function 04514 * @param method Member function to attach 04515 * @return Callback with infered type 04516 */ 04517 template<typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 04518 Callback<R(A0, A1, A2, A3, A4)> callback(const U *obj, R (T::*method)(A0, A1, A2, A3, A4) const) { 04519 return Callback<R(A0, A1, A2, A3, A4)>(obj, method); 04520 } 04521 04522 /** Create a callback class with type infered from the arguments 04523 * 04524 * @param obj Optional pointer to object to bind to function 04525 * @param method Member function to attach 04526 * @return Callback with infered type 04527 */ 04528 template<typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 04529 Callback<R(A0, A1, A2, A3, A4)> callback(volatile U *obj, R (T::*method)(A0, A1, A2, A3, A4) volatile) { 04530 return Callback<R(A0, A1, A2, A3, A4)>(obj, method); 04531 } 04532 04533 /** Create a callback class with type infered from the arguments 04534 * 04535 * @param obj Optional pointer to object to bind to function 04536 * @param method Member function to attach 04537 * @return Callback with infered type 04538 */ 04539 template<typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 04540 Callback<R(A0, A1, A2, A3, A4)> callback(const volatile U *obj, R (T::*method)(A0, A1, A2, A3, A4) const volatile) { 04541 return Callback<R(A0, A1, A2, A3, A4)>(obj, method); 04542 } 04543 04544 /** Create a callback class with type infered from the arguments 04545 * 04546 * @param func Static function to attach 04547 * @param arg Pointer argument to function 04548 * @return Callback with infered type 04549 */ 04550 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 04551 Callback<R(A0, A1, A2, A3, A4)> callback(R (*func)(T*, A0, A1, A2, A3, A4), U *arg) { 04552 return Callback<R(A0, A1, A2, A3, A4)>(func, arg); 04553 } 04554 04555 /** Create a callback class with type infered from the arguments 04556 * 04557 * @param func Static function to attach 04558 * @param arg Pointer argument to function 04559 * @return Callback with infered type 04560 */ 04561 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 04562 Callback<R(A0, A1, A2, A3, A4)> callback(R (*func)(const T*, A0, A1, A2, A3, A4), const U *arg) { 04563 return Callback<R(A0, A1, A2, A3, A4)>(func, arg); 04564 } 04565 04566 /** Create a callback class with type infered from the arguments 04567 * 04568 * @param func Static function to attach 04569 * @param arg Pointer argument to function 04570 * @return Callback with infered type 04571 */ 04572 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 04573 Callback<R(A0, A1, A2, A3, A4)> callback(R (*func)(volatile T*, A0, A1, A2, A3, A4), volatile U *arg) { 04574 return Callback<R(A0, A1, A2, A3, A4)>(func, arg); 04575 } 04576 04577 /** Create a callback class with type infered from the arguments 04578 * 04579 * @param func Static function to attach 04580 * @param arg Pointer argument to function 04581 * @return Callback with infered type 04582 */ 04583 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 04584 Callback<R(A0, A1, A2, A3, A4)> callback(R (*func)(const volatile T*, A0, A1, A2, A3, A4), const volatile U *arg) { 04585 return Callback<R(A0, A1, A2, A3, A4)>(func, arg); 04586 } 04587 04588 /** Create a callback class with type infered from the arguments 04589 * 04590 * @param obj Optional pointer to object to bind to function 04591 * @param func Static function to attach 04592 * @return Callback with infered type 04593 * @deprecated 04594 * Arguments to callback have been reordered to callback(func, arg) 04595 */ 04596 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 04597 MBED_DEPRECATED_SINCE("mbed-os-5.1", 04598 "Arguments to callback have been reordered to callback(func, arg)") 04599 Callback<R(A0, A1, A2, A3, A4)> callback(U *obj, R (*func)(T*, A0, A1, A2, A3, A4)) { 04600 return Callback<R(A0, A1, A2, A3, A4)>(func, obj); 04601 } 04602 04603 /** Create a callback class with type infered from the arguments 04604 * 04605 * @param obj Optional pointer to object to bind to function 04606 * @param func Static function to attach 04607 * @return Callback with infered type 04608 * @deprecated 04609 * Arguments to callback have been reordered to callback(func, arg) 04610 */ 04611 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 04612 MBED_DEPRECATED_SINCE("mbed-os-5.1", 04613 "Arguments to callback have been reordered to callback(func, arg)") 04614 Callback<R(A0, A1, A2, A3, A4)> callback(const U *obj, R (*func)(const T*, A0, A1, A2, A3, A4)) { 04615 return Callback<R(A0, A1, A2, A3, A4)>(func, obj); 04616 } 04617 04618 /** Create a callback class with type infered from the arguments 04619 * 04620 * @param obj Optional pointer to object to bind to function 04621 * @param func Static function to attach 04622 * @return Callback with infered type 04623 * @deprecated 04624 * Arguments to callback have been reordered to callback(func, arg) 04625 */ 04626 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 04627 MBED_DEPRECATED_SINCE("mbed-os-5.1", 04628 "Arguments to callback have been reordered to callback(func, arg)") 04629 Callback<R(A0, A1, A2, A3, A4)> callback(volatile U *obj, R (*func)(volatile T*, A0, A1, A2, A3, A4)) { 04630 return Callback<R(A0, A1, A2, A3, A4)>(func, obj); 04631 } 04632 04633 /** Create a callback class with type infered from the arguments 04634 * 04635 * @param obj Optional pointer to object to bind to function 04636 * @param func Static function to attach 04637 * @return Callback with infered type 04638 * @deprecated 04639 * Arguments to callback have been reordered to callback(func, arg) 04640 */ 04641 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 04642 MBED_DEPRECATED_SINCE("mbed-os-5.1", 04643 "Arguments to callback have been reordered to callback(func, arg)") 04644 Callback<R(A0, A1, A2, A3, A4)> callback(const volatile U *obj, R (*func)(const volatile T*, A0, A1, A2, A3, A4)) { 04645 return Callback<R(A0, A1, A2, A3, A4)>(func, obj); 04646 } 04647 04648 04649 } // namespace mbed 04650 04651 #endif 04652 04653 04654 /** @}*/
Generated on Tue Jul 12 2022 19:00:53 by
1.7.2