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