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