Mbed OS Reference | Callback.h Source File

 /* mbed Microcontroller Library
  * Copyright (c) 2006-2015 ARM Limited
  * SPDX-License-Identifier: Apache-2.0
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 #ifndef MBED_CALLBACK_H
 #define MBED_CALLBACK_H
 
 #include <string.h>
 #include <stdint.h>
 #include <new>
 #include "platform/mbed_assert.h"
 #include "platform/mbed_toolchain.h"
 
 namespace mbed {
 /** \addtogroup platform */
 /** @{*/
 /**
  * \defgroup platform_Callback Callback class
  * @{
  */
 
 /** Callback class based on template specialization
  *
  * @note Synchronization level: Not protected
  */
 template <typename F>
 class Callback;
 
 // Internal sfinae declarations
 //
 // These are used to eliminate overloads based on type attributes
 // 1. Does a function object have a call operator
 // 2. Does a function object fit in the available storage
 //
 // These eliminations are handled cleanly by the compiler and avoid
 // massive and misleading error messages when confronted with an
 // invalid type (or worse, runtime failures)
 namespace detail {
 struct nil {};
 
 template <bool B, typename R = nil>
 struct enable_if {
     typedef R type;
 };
 
 template <typename R>
 struct enable_if<false, R> {};
 
 template <typename M, M>
 struct is_type {
     static const bool value = true;
 };
 }
 
 #define MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, M)                            \
     typename detail::enable_if<                                             \
             detail::is_type<M, &F::operator()>::value &&                    \
             sizeof(F) <= sizeof(uintptr_t)                                  \
         >::type = detail::nil()
 
 /** Callback class based on template specialization
  *
  * @note Synchronization level: Not protected
  */
 template <typename R>
 class Callback<R()> {
 public:
     /** Create a Callback with a static function
      *  @param func     Static function to attach
      */
     Callback(R(*func)() = 0)
     {
         if (!func) {
             memset(this, 0, sizeof(Callback));
         } else {
             generate(func);
         }
     }
 
     /** Attach a Callback
      *  @param func     The Callback to attach
      */
     Callback(const Callback<R()> &func)
     {
         memset(this, 0, sizeof(Callback));
         if (func._ops) {
             func._ops->move(this, &func);
         }
         _ops = func._ops;
     }
 
     /** Create a Callback with a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      */
     template<typename T, typename U>
     Callback(U *obj, R(T::*method)())
     {
         generate(method_context<T, R(T::*)()>(obj, method));
     }
 
     /** Create a Callback with a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      */
     template<typename T, typename U>
     Callback(const U *obj, R(T::*method)() const)
     {
         generate(method_context<const T, R(T::*)() const>(obj, method));
     }
 
     /** Create a Callback with a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      */
     template<typename T, typename U>
     Callback(volatile U *obj, R(T::*method)() volatile)
     {
         generate(method_context<volatile T, R(T::*)() volatile>(obj, method));
     }
 
     /** Create a Callback with a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      */
     template<typename T, typename U>
     Callback(const volatile U *obj, R(T::*method)() const volatile)
     {
         generate(method_context<const volatile T, R(T::*)() const volatile>(obj, method));
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      */
     template<typename T, typename U>
     Callback(R(*func)(T *), U *arg)
     {
         generate(function_context<R(*)(T *), T>(func, arg));
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      */
     template<typename T, typename U>
     Callback(R(*func)(const T *), const U *arg)
     {
         generate(function_context<R(*)(const T *), const T>(func, arg));
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      */
     template<typename T, typename U>
     Callback(R(*func)(volatile T *), volatile U *arg)
     {
         generate(function_context<R(*)(volatile T *), volatile T>(func, arg));
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      */
     template<typename T, typename U>
     Callback(R(*func)(const volatile T *), const volatile U *arg)
     {
         generate(function_context<R(*)(const volatile T *), const volatile T>(func, arg));
     }
 
     /** Create a Callback with a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      */
     template <typename F>
     Callback(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)()))
     {
         generate(f);
     }
 
     /** Create a Callback with a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      */
     template <typename F>
     Callback(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)() const))
     {
         generate(f);
     }
 
     /** Create a Callback with a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      */
     template <typename F>
     Callback(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)() volatile))
     {
         generate(f);
     }
 
     /** Create a Callback with a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      */
     template <typename F>
     Callback(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)() const volatile))
     {
         generate(f);
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to Callback(func, arg)
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to Callback(func, arg)")
     Callback(U *obj, R(*func)(T *))
     {
         new (this) Callback(func, obj);
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to Callback(func, arg)
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to Callback(func, arg)")
     Callback(const U *obj, R(*func)(const T *))
     {
         new (this) Callback(func, obj);
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to Callback(func, arg)
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to Callback(func, arg)")
     Callback(volatile U *obj, R(*func)(volatile T *))
     {
         new (this) Callback(func, obj);
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to Callback(func, arg)
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to Callback(func, arg)")
     Callback(const volatile U *obj, R(*func)(const volatile T *))
     {
         new (this) Callback(func, obj);
     }
 
     /** Destroy a callback
      */
     ~Callback()
     {
         if (_ops) {
             _ops->dtor(this);
         }
     }
 
     /** Attach a static function
      *  @param func     Static function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)())
     {
         this->~Callback();
         new (this) Callback(func);
     }
 
     /** Attach a Callback
      *  @param func     The Callback to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const Callback<R()> &func)
     {
         this->~Callback();
         new (this) Callback(func);
     }
 
     /** Attach a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(U *obj, R(T::*method)())
     {
         this->~Callback();
         new (this) Callback(obj, method);
     }
 
     /** Attach a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const U *obj, R(T::*method)() const)
     {
         this->~Callback();
         new (this) Callback(obj, method);
     }
 
     /** Attach a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(volatile U *obj, R(T::*method)() volatile)
     {
         this->~Callback();
         new (this) Callback(obj, method);
     }
 
     /** Attach a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const volatile U *obj, R(T::*method)() const volatile)
     {
         this->~Callback();
         new (this) Callback(obj, method);
     }
 
     /** Attach a static function with a bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(T *), U *arg)
     {
         this->~Callback();
         new (this) Callback(func, arg);
     }
 
     /** Attach a static function with a bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(const T *), const U *arg)
     {
         this->~Callback();
         new (this) Callback(func, arg);
     }
 
     /** Attach a static function with a bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(volatile T *), volatile U *arg)
     {
         this->~Callback();
         new (this) Callback(func, arg);
     }
 
     /** Attach a static function with a bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(const volatile T *), const volatile U *arg)
     {
         this->~Callback();
         new (this) Callback(func, arg);
     }
 
     /** Attach a function object
      *  @param f     Function object to attach
      *  @note The function object is limited to a single word of storage
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename F>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)()))
     {
         this->~Callback();
         new (this) Callback(f);
     }
 
     /** Attach a function object
      *  @param f     Function object to attach
      *  @note The function object is limited to a single word of storage
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename F>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)() const))
     {
         this->~Callback();
         new (this) Callback(f);
     }
 
     /** Attach a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename F>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)() volatile))
     {
         this->~Callback();
         new (this) Callback(f);
     }
 
     /** Attach a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename F>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)() const volatile))
     {
         this->~Callback();
         new (this) Callback(f);
     }
 
     /** Attach a static function with a bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to attach(func, arg)
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to attach(func, arg)")
     void attach(U *obj, R(*func)(T *))
     {
         this->~Callback();
         new (this) Callback(func, obj);
     }
 
     /** Attach a static function with a bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to attach(func, arg)
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to attach(func, arg)")
     void attach(const U *obj, R(*func)(const T *))
     {
         this->~Callback();
         new (this) Callback(func, obj);
     }
 
     /** Attach a static function with a bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to attach(func, arg)
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to attach(func, arg)")
     void attach(volatile U *obj, R(*func)(volatile T *))
     {
         this->~Callback();
         new (this) Callback(func, obj);
     }
 
     /** Attach a static function with a bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to attach(func, arg)
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to attach(func, arg)")
     void attach(const volatile U *obj, R(*func)(const volatile T *))
     {
         this->~Callback();
         new (this) Callback(func, obj);
     }
 
     /** Assign a callback
      */
     Callback &operator=(const Callback &that)
     {
         if (this != &that) {
             this->~Callback();
             new (this) Callback(that);
         }
 
         return *this;
     }
 
     /** Call the attached function
      */
     R call() const
     {
         MBED_ASSERT(_ops);
         return _ops->call(this);
     }
 
     /** Call the attached function
      */
     R operator()() const
     {
         return call();
     }
 
     /** Test if function has been attached
      */
     operator bool() const
     {
         return _ops;
     }
 
     /** Test for equality
      */
     friend bool operator==(const Callback &l, const Callback &r)
     {
         return memcmp(&l, &r, sizeof(Callback)) == 0;
     }
 
     /** Test for inequality
      */
     friend bool operator!=(const Callback &l, const Callback &r)
     {
         return !(l == r);
     }
 
     /** Static thunk for passing as C-style function
      *  @param func Callback to call passed as void pointer
      *  @return the value as determined by func which is of
      *      type and determined by the signature of func
      */
     static R thunk(void *func)
     {
         return static_cast<Callback *>(func)->call();
     }
 
 private:
     // Stored as pointer to function and pointer to optional object
     // Function pointer is stored as union of possible function types
     // to guarantee proper size and alignment
     struct _class;
     union {
         void (*_staticfunc)();
         void (*_boundfunc)(_class *);
         void (_class::*_methodfunc)();
     } _func;
     void *_obj;
 
     // Dynamically dispatched operations
     const struct ops {
         R(*call)(const void *);
         void (*move)(void *, const void *);
         void (*dtor)(void *);
     } *_ops;
 
     // Generate operations for function object
     template <typename F>
     void generate(const F &f)
     {
         static const ops ops = {
             &Callback::function_call<F>,
             &Callback::function_move<F>,
             &Callback::function_dtor<F>,
         };
 
         MBED_STATIC_ASSERT(sizeof(Callback) - sizeof(_ops) >= sizeof(F),
                            "Type F must not exceed the size of the Callback class");
         memset(this, 0, sizeof(Callback));
         new (this) F(f);
         _ops = &ops;
     }
 
     // Function attributes
     template <typename F>
     static R function_call(const void *p)
     {
         return (*(F *)p)();
     }
 
     template <typename F>
     static void function_move(void *d, const void *p)
     {
         new (d) F(*(F *)p);
     }
 
     template <typename F>
     static void function_dtor(void *p)
     {
         ((F *)p)->~F();
     }
 
     // Wrappers for functions with context
     template <typename O, typename M>
     struct method_context {
         M method;
         O *obj;
 
         method_context(O *obj, M method)
             : method(method), obj(obj) {}
 
         R operator()() const
         {
             return (obj->*method)();
         }
     };
 
     template <typename F, typename A>
     struct function_context {
         F func;
         A *arg;
 
         function_context(F func, A *arg)
             : func(func), arg(arg) {}
 
         R operator()() const
         {
             return func(arg);
         }
     };
 };
 
 /** Callback class based on template specialization
  *
  * @note Synchronization level: Not protected
  */
 template <typename R, typename A0>
 class Callback<R(A0)> {
 public:
     /** Create a Callback with a static function
      *  @param func     Static function to attach
      */
     Callback(R(*func)(A0) = 0)
     {
         if (!func) {
             memset(this, 0, sizeof(Callback));
         } else {
             generate(func);
         }
     }
 
     /** Attach a Callback
      *  @param func     The Callback to attach
      */
     Callback(const Callback<R(A0)> &func)
     {
         memset(this, 0, sizeof(Callback));
         if (func._ops) {
             func._ops->move(this, &func);
         }
         _ops = func._ops;
     }
 
     /** Create a Callback with a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      */
     template<typename T, typename U>
     Callback(U *obj, R(T::*method)(A0))
     {
         generate(method_context<T, R(T::*)(A0)>(obj, method));
     }
 
     /** Create a Callback with a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      */
     template<typename T, typename U>
     Callback(const U *obj, R(T::*method)(A0) const)
     {
         generate(method_context<const T, R(T::*)(A0) const>(obj, method));
     }
 
     /** Create a Callback with a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      */
     template<typename T, typename U>
     Callback(volatile U *obj, R(T::*method)(A0) volatile)
     {
         generate(method_context<volatile T, R(T::*)(A0) volatile>(obj, method));
     }
 
     /** Create a Callback with a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      */
     template<typename T, typename U>
     Callback(const volatile U *obj, R(T::*method)(A0) const volatile)
     {
         generate(method_context<const volatile T, R(T::*)(A0) const volatile>(obj, method));
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      */
     template<typename T, typename U>
     Callback(R(*func)(T *, A0), U *arg)
     {
         generate(function_context<R(*)(T *, A0), T>(func, arg));
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      */
     template<typename T, typename U>
     Callback(R(*func)(const T *, A0), const U *arg)
     {
         generate(function_context<R(*)(const T *, A0), const T>(func, arg));
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      */
     template<typename T, typename U>
     Callback(R(*func)(volatile T *, A0), volatile U *arg)
     {
         generate(function_context<R(*)(volatile T *, A0), volatile T>(func, arg));
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      */
     template<typename T, typename U>
     Callback(R(*func)(const volatile T *, A0), const volatile U *arg)
     {
         generate(function_context<R(*)(const volatile T *, A0), const volatile T>(func, arg));
     }
 
     /** Create a Callback with a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      */
     template <typename F>
     Callback(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0)))
     {
         generate(f);
     }
 
     /** Create a Callback with a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      */
     template <typename F>
     Callback(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0) const))
     {
         generate(f);
     }
 
     /** Create a Callback with a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      */
     template <typename F>
     Callback(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0) volatile))
     {
         generate(f);
     }
 
     /** Create a Callback with a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      */
     template <typename F>
     Callback(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0) const volatile))
     {
         generate(f);
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to Callback(func, arg)
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to Callback(func, arg)")
     Callback(U *obj, R(*func)(T *, A0))
     {
         new (this) Callback(func, obj);
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to Callback(func, arg)
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to Callback(func, arg)")
     Callback(const U *obj, R(*func)(const T *, A0))
     {
         new (this) Callback(func, obj);
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to Callback(func, arg)
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to Callback(func, arg)")
     Callback(volatile U *obj, R(*func)(volatile T *, A0))
     {
         new (this) Callback(func, obj);
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to Callback(func, arg)
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to Callback(func, arg)")
     Callback(const volatile U *obj, R(*func)(const volatile T *, A0))
     {
         new (this) Callback(func, obj);
     }
 
     /** Destroy a callback
      */
     ~Callback()
     {
         if (_ops) {
             _ops->dtor(this);
         }
     }
 
     /** Attach a static function
      *  @param func     Static function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(A0))
     {
         this->~Callback();
         new (this) Callback(func);
     }
 
     /** Attach a Callback
      *  @param func     The Callback to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const Callback<R(A0)> &func)
     {
         this->~Callback();
         new (this) Callback(func);
     }
 
     /** Attach a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(U *obj, R(T::*method)(A0))
     {
         this->~Callback();
         new (this) Callback(obj, method);
     }
 
     /** Attach a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const U *obj, R(T::*method)(A0) const)
     {
         this->~Callback();
         new (this) Callback(obj, method);
     }
 
     /** Attach a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(volatile U *obj, R(T::*method)(A0) volatile)
     {
         this->~Callback();
         new (this) Callback(obj, method);
     }
 
     /** Attach a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const volatile U *obj, R(T::*method)(A0) const volatile)
     {
         this->~Callback();
         new (this) Callback(obj, method);
     }
 
     /** Attach a static function with a bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(T *, A0), U *arg)
     {
         this->~Callback();
         new (this) Callback(func, arg);
     }
 
     /** Attach a static function with a bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(const T *, A0), const U *arg)
     {
         this->~Callback();
         new (this) Callback(func, arg);
     }
 
     /** Attach a static function with a bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(volatile T *, A0), volatile U *arg)
     {
         this->~Callback();
         new (this) Callback(func, arg);
     }
 
     /** Attach a static function with a bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(const volatile T *, A0), const volatile U *arg)
     {
         this->~Callback();
         new (this) Callback(func, arg);
     }
 
     /** Attach a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename F>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0)))
     {
         this->~Callback();
         new (this) Callback(f);
     }
 
     /** Attach a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename F>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0) const))
     {
         this->~Callback();
         new (this) Callback(f);
     }
 
     /** Attach a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename F>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0) volatile))
     {
         this->~Callback();
         new (this) Callback(f);
     }
 
     /** Attach a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename F>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0) const volatile))
     {
         this->~Callback();
         new (this) Callback(f);
     }
 
     /** Attach a static function with a bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to attach(func, arg)
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to attach(func, arg)")
     void attach(U *obj, R(*func)(T *, A0))
     {
         this->~Callback();
         new (this) Callback(func, obj);
     }
 
     /** Attach a static function with a bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to attach(func, arg)
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to attach(func, arg)")
     void attach(const U *obj, R(*func)(const T *, A0))
     {
         this->~Callback();
         new (this) Callback(func, obj);
     }
 
     /** Attach a static function with a bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to attach(func, arg)
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to attach(func, arg)")
     void attach(volatile U *obj, R(*func)(volatile T *, A0))
     {
         this->~Callback();
         new (this) Callback(func, obj);
     }
 
     /** Attach a static function with a bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to attach(func, arg)
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to attach(func, arg)")
     void attach(const volatile U *obj, R(*func)(const volatile T *, A0))
     {
         this->~Callback();
         new (this) Callback(func, obj);
     }
 
     /** Assign a callback
      */
     Callback &operator=(const Callback &that)
     {
         if (this != &that) {
             this->~Callback();
             new (this) Callback(that);
         }
 
         return *this;
     }
 
     /** Call the attached function
      */
     R call(A0 a0) const
     {
         MBED_ASSERT(_ops);
         return _ops->call(this, a0);
     }
 
     /** Call the attached function
      */
     R operator()(A0 a0) const
     {
         return call(a0);
     }
 
     /** Test if function has been attached
      */
     operator bool() const
     {
         return _ops;
     }
 
     /** Test for equality
      */
     friend bool operator==(const Callback &l, const Callback &r)
     {
         return memcmp(&l, &r, sizeof(Callback)) == 0;
     }
 
     /** Test for inequality
      */
     friend bool operator!=(const Callback &l, const Callback &r)
     {
         return !(l == r);
     }
 
     /** Static thunk for passing as C-style function
      *  @param func Callback to call passed as void pointer
      *  @param a0 An argument to be called with function func
      *  @return the value as determined by func which is of
      *      type and determined by the signature of func
      */
     static R thunk(void *func, A0 a0)
     {
         return static_cast<Callback *>(func)->call(a0);
     }
 
 private:
     // Stored as pointer to function and pointer to optional object
     // Function pointer is stored as union of possible function types
     // to guarantee proper size and alignment
     struct _class;
     union {
         void (*_staticfunc)(A0);
         void (*_boundfunc)(_class *, A0);
         void (_class::*_methodfunc)(A0);
     } _func;
     void *_obj;
 
     // Dynamically dispatched operations
     const struct ops {
         R(*call)(const void *, A0);
         void (*move)(void *, const void *);
         void (*dtor)(void *);
     } *_ops;
 
     // Generate operations for function object
     template <typename F>
     void generate(const F &f)
     {
         static const ops ops = {
             &Callback::function_call<F>,
             &Callback::function_move<F>,
             &Callback::function_dtor<F>,
         };
 
         MBED_STATIC_ASSERT(sizeof(Callback) - sizeof(_ops) >= sizeof(F),
                            "Type F must not exceed the size of the Callback class");
         memset(this, 0, sizeof(Callback));
         new (this) F(f);
         _ops = &ops;
     }
 
     // Function attributes
     template <typename F>
     static R function_call(const void *p, A0 a0)
     {
         return (*(F *)p)(a0);
     }
 
     template <typename F>
     static void function_move(void *d, const void *p)
     {
         new (d) F(*(F *)p);
     }
 
     template <typename F>
     static void function_dtor(void *p)
     {
         ((F *)p)->~F();
     }
 
     // Wrappers for functions with context
     template <typename O, typename M>
     struct method_context {
         M method;
         O *obj;
 
         method_context(O *obj, M method)
             : method(method), obj(obj) {}
 
         R operator()(A0 a0) const
         {
             return (obj->*method)(a0);
         }
     };
 
     template <typename F, typename A>
     struct function_context {
         F func;
         A *arg;
 
         function_context(F func, A *arg)
             : func(func), arg(arg) {}
 
         R operator()(A0 a0) const
         {
             return func(arg, a0);
         }
     };
 };
 
 /** Callback class based on template specialization
  *
  * @note Synchronization level: Not protected
  */
 template <typename R, typename A0, typename A1>
 class Callback<R(A0, A1)> {
 public:
     /** Create a Callback with a static function
      *  @param func     Static function to attach
      */
     Callback(R(*func)(A0, A1) = 0)
     {
         if (!func) {
             memset(this, 0, sizeof(Callback));
         } else {
             generate(func);
         }
     }
 
     /** Attach a Callback
      *  @param func     The Callback to attach
      */
     Callback(const Callback<R(A0, A1)> &func)
     {
         memset(this, 0, sizeof(Callback));
         if (func._ops) {
             func._ops->move(this, &func);
         }
         _ops = func._ops;
     }
 
     /** Create a Callback with a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      */
     template<typename T, typename U>
     Callback(U *obj, R(T::*method)(A0, A1))
     {
         generate(method_context<T, R(T::*)(A0, A1)>(obj, method));
     }
 
     /** Create a Callback with a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      */
     template<typename T, typename U>
     Callback(const U *obj, R(T::*method)(A0, A1) const)
     {
         generate(method_context<const T, R(T::*)(A0, A1) const>(obj, method));
     }
 
     /** Create a Callback with a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      */
     template<typename T, typename U>
     Callback(volatile U *obj, R(T::*method)(A0, A1) volatile)
     {
         generate(method_context<volatile T, R(T::*)(A0, A1) volatile>(obj, method));
     }
 
     /** Create a Callback with a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      */
     template<typename T, typename U>
     Callback(const volatile U *obj, R(T::*method)(A0, A1) const volatile)
     {
         generate(method_context<const volatile T, R(T::*)(A0, A1) const volatile>(obj, method));
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      */
     template<typename T, typename U>
     Callback(R(*func)(T *, A0, A1), U *arg)
     {
         generate(function_context<R(*)(T *, A0, A1), T>(func, arg));
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      */
     template<typename T, typename U>
     Callback(R(*func)(const T *, A0, A1), const U *arg)
     {
         generate(function_context<R(*)(const T *, A0, A1), const T>(func, arg));
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      */
     template<typename T, typename U>
     Callback(R(*func)(volatile T *, A0, A1), volatile U *arg)
     {
         generate(function_context<R(*)(volatile T *, A0, A1), volatile T>(func, arg));
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      */
     template<typename T, typename U>
     Callback(R(*func)(const volatile T *, A0, A1), const volatile U *arg)
     {
         generate(function_context<R(*)(const volatile T *, A0, A1), const volatile T>(func, arg));
     }
 
     /** Create a Callback with a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      */
     template <typename F>
     Callback(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1)))
     {
         generate(f);
     }
 
     /** Create a Callback with a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      */
     template <typename F>
     Callback(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1) const))
     {
         generate(f);
     }
 
     /** Create a Callback with a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      */
     template <typename F>
     Callback(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1) volatile))
     {
         generate(f);
     }
 
     /** Create a Callback with a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      */
     template <typename F>
     Callback(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1) const volatile))
     {
         generate(f);
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to Callback(func, arg)
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to Callback(func, arg)")
     Callback(U *obj, R(*func)(T *, A0, A1))
     {
         new (this) Callback(func, obj);
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to Callback(func, arg)
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to Callback(func, arg)")
     Callback(const U *obj, R(*func)(const T *, A0, A1))
     {
         new (this) Callback(func, obj);
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to Callback(func, arg)
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to Callback(func, arg)")
     Callback(volatile U *obj, R(*func)(volatile T *, A0, A1))
     {
         new (this) Callback(func, obj);
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to Callback(func, arg)
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to Callback(func, arg)")
     Callback(const volatile U *obj, R(*func)(const volatile T *, A0, A1))
     {
         new (this) Callback(func, obj);
     }
 
     /** Destroy a callback
      */
     ~Callback()
     {
         if (_ops) {
             _ops->dtor(this);
         }
     }
 
     /** Attach a static function
      *  @param func     Static function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(A0, A1))
     {
         this->~Callback();
         new (this) Callback(func);
     }
 
     /** Attach a Callback
      *  @param func     The Callback to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const Callback<R(A0, A1)> &func)
     {
         this->~Callback();
         new (this) Callback(func);
     }
 
     /** Attach a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(U *obj, R(T::*method)(A0, A1))
     {
         this->~Callback();
         new (this) Callback(obj, method);
     }
 
     /** Attach a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const U *obj, R(T::*method)(A0, A1) const)
     {
         this->~Callback();
         new (this) Callback(obj, method);
     }
 
     /** Attach a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(volatile U *obj, R(T::*method)(A0, A1) volatile)
     {
         this->~Callback();
         new (this) Callback(obj, method);
     }
 
     /** Attach a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const volatile U *obj, R(T::*method)(A0, A1) const volatile)
     {
         this->~Callback();
         new (this) Callback(obj, method);
     }
 
     /** Attach a static function with a bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(T *, A0, A1), U *arg)
     {
         this->~Callback();
         new (this) Callback(func, arg);
     }
 
     /** Attach a static function with a bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(const T *, A0, A1), const U *arg)
     {
         this->~Callback();
         new (this) Callback(func, arg);
     }
 
     /** Attach a static function with a bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(volatile T *, A0, A1), volatile U *arg)
     {
         this->~Callback();
         new (this) Callback(func, arg);
     }
 
     /** Attach a static function with a bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(const volatile T *, A0, A1), const volatile U *arg)
     {
         this->~Callback();
         new (this) Callback(func, arg);
     }
 
     /** Attach a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename F>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1)))
     {
         this->~Callback();
         new (this) Callback(f);
     }
 
     /** Attach a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename F>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1) const))
     {
         this->~Callback();
         new (this) Callback(f);
     }
 
     /** Attach a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename F>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1) volatile))
     {
         this->~Callback();
         new (this) Callback(f);
     }
 
     /** Attach a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename F>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1) const volatile))
     {
         this->~Callback();
         new (this) Callback(f);
     }
 
     /** Attach a static function with a bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to attach(func, arg)
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to attach(func, arg)")
     void attach(U *obj, R(*func)(T *, A0, A1))
     {
         this->~Callback();
         new (this) Callback(func, obj);
     }
 
     /** Attach a static function with a bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to attach(func, arg)
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to attach(func, arg)")
     void attach(const U *obj, R(*func)(const T *, A0, A1))
     {
         this->~Callback();
         new (this) Callback(func, obj);
     }
 
     /** Attach a static function with a bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to attach(func, arg)
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to attach(func, arg)")
     void attach(volatile U *obj, R(*func)(volatile T *, A0, A1))
     {
         this->~Callback();
         new (this) Callback(func, obj);
     }
 
     /** Attach a static function with a bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to attach(func, arg)
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to attach(func, arg)")
     void attach(const volatile U *obj, R(*func)(const volatile T *, A0, A1))
     {
         this->~Callback();
         new (this) Callback(func, obj);
     }
 
     /** Assign a callback
      */
     Callback &operator=(const Callback &that)
     {
         if (this != &that) {
             this->~Callback();
             new (this) Callback(that);
         }
 
         return *this;
     }
 
     /** Call the attached function
      */
     R call(A0 a0, A1 a1) const
     {
         MBED_ASSERT(_ops);
         return _ops->call(this, a0, a1);
     }
 
     /** Call the attached function
      */
     R operator()(A0 a0, A1 a1) const
     {
         return call(a0, a1);
     }
 
     /** Test if function has been attached
      */
     operator bool() const
     {
         return _ops;
     }
 
     /** Test for equality
      */
     friend bool operator==(const Callback &l, const Callback &r)
     {
         return memcmp(&l, &r, sizeof(Callback)) == 0;
     }
 
     /** Test for inequality
      */
     friend bool operator!=(const Callback &l, const Callback &r)
     {
         return !(l == r);
     }
 
     /** Static thunk for passing as C-style function
      *  @param func Callback to call passed as void pointer
      *  @param a0 An argument to be called with function func
      *  @param a1 An argument to be called with function func
      *  @return the value as determined by func which is of
      *      type and determined by the signature of func
      */
     static R thunk(void *func, A0 a0, A1 a1)
     {
         return static_cast<Callback *>(func)->call(a0, a1);
     }
 
 private:
     // Stored as pointer to function and pointer to optional object
     // Function pointer is stored as union of possible function types
     // to guarantee proper size and alignment
     struct _class;
     union {
         void (*_staticfunc)(A0, A1);
         void (*_boundfunc)(_class *, A0, A1);
         void (_class::*_methodfunc)(A0, A1);
     } _func;
     void *_obj;
 
     // Dynamically dispatched operations
     const struct ops {
         R(*call)(const void *, A0, A1);
         void (*move)(void *, const void *);
         void (*dtor)(void *);
     } *_ops;
 
     // Generate operations for function object
     template <typename F>
     void generate(const F &f)
     {
         static const ops ops = {
             &Callback::function_call<F>,
             &Callback::function_move<F>,
             &Callback::function_dtor<F>,
         };
 
         MBED_STATIC_ASSERT(sizeof(Callback) - sizeof(_ops) >= sizeof(F),
                            "Type F must not exceed the size of the Callback class");
         memset(this, 0, sizeof(Callback));
         new (this) F(f);
         _ops = &ops;
     }
 
     // Function attributes
     template <typename F>
     static R function_call(const void *p, A0 a0, A1 a1)
     {
         return (*(F *)p)(a0, a1);
     }
 
     template <typename F>
     static void function_move(void *d, const void *p)
     {
         new (d) F(*(F *)p);
     }
 
     template <typename F>
     static void function_dtor(void *p)
     {
         ((F *)p)->~F();
     }
 
     // Wrappers for functions with context
     template <typename O, typename M>
     struct method_context {
         M method;
         O *obj;
 
         method_context(O *obj, M method)
             : method(method), obj(obj) {}
 
         R operator()(A0 a0, A1 a1) const
         {
             return (obj->*method)(a0, a1);
         }
     };
 
     template <typename F, typename A>
     struct function_context {
         F func;
         A *arg;
 
         function_context(F func, A *arg)
             : func(func), arg(arg) {}
 
         R operator()(A0 a0, A1 a1) const
         {
             return func(arg, a0, a1);
         }
     };
 };
 
 /** Callback class based on template specialization
  *
  * @note Synchronization level: Not protected
  */
 template <typename R, typename A0, typename A1, typename A2>
 class Callback<R(A0, A1, A2)> {
 public:
     /** Create a Callback with a static function
      *  @param func     Static function to attach
      */
     Callback(R(*func)(A0, A1, A2) = 0)
     {
         if (!func) {
             memset(this, 0, sizeof(Callback));
         } else {
             generate(func);
         }
     }
 
     /** Attach a Callback
      *  @param func     The Callback to attach
      */
     Callback(const Callback<R(A0, A1, A2)> &func)
     {
         memset(this, 0, sizeof(Callback));
         if (func._ops) {
             func._ops->move(this, &func);
         }
         _ops = func._ops;
     }
 
     /** Create a Callback with a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      */
     template<typename T, typename U>
     Callback(U *obj, R(T::*method)(A0, A1, A2))
     {
         generate(method_context<T, R(T::*)(A0, A1, A2)>(obj, method));
     }
 
     /** Create a Callback with a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      */
     template<typename T, typename U>
     Callback(const U *obj, R(T::*method)(A0, A1, A2) const)
     {
         generate(method_context<const T, R(T::*)(A0, A1, A2) const>(obj, method));
     }
 
     /** Create a Callback with a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      */
     template<typename T, typename U>
     Callback(volatile U *obj, R(T::*method)(A0, A1, A2) volatile)
     {
         generate(method_context<volatile T, R(T::*)(A0, A1, A2) volatile>(obj, method));
     }
 
     /** Create a Callback with a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      */
     template<typename T, typename U>
     Callback(const volatile U *obj, R(T::*method)(A0, A1, A2) const volatile)
     {
         generate(method_context<const volatile T, R(T::*)(A0, A1, A2) const volatile>(obj, method));
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      */
     template<typename T, typename U>
     Callback(R(*func)(T *, A0, A1, A2), U *arg)
     {
         generate(function_context<R(*)(T *, A0, A1, A2), T>(func, arg));
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      */
     template<typename T, typename U>
     Callback(R(*func)(const T *, A0, A1, A2), const U *arg)
     {
         generate(function_context<R(*)(const T *, A0, A1, A2), const T>(func, arg));
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      */
     template<typename T, typename U>
     Callback(R(*func)(volatile T *, A0, A1, A2), volatile U *arg)
     {
         generate(function_context<R(*)(volatile T *, A0, A1, A2), volatile T>(func, arg));
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      */
     template<typename T, typename U>
     Callback(R(*func)(const volatile T *, A0, A1, A2), const volatile U *arg)
     {
         generate(function_context<R(*)(const volatile T *, A0, A1, A2), const volatile T>(func, arg));
     }
 
     /** Create a Callback with a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      */
     template <typename F>
     Callback(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1, A2)))
     {
         generate(f);
     }
 
     /** Create a Callback with a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      */
     template <typename F>
     Callback(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1, A2) const))
     {
         generate(f);
     }
 
     /** Create a Callback with a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      */
     template <typename F>
     Callback(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1, A2) volatile))
     {
         generate(f);
     }
 
     /** Create a Callback with a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      */
     template <typename F>
     Callback(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1, A2) const volatile))
     {
         generate(f);
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to Callback(func, arg)
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to Callback(func, arg)")
     Callback(U *obj, R(*func)(T *, A0, A1, A2))
     {
         new (this) Callback(func, obj);
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to Callback(func, arg)
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to Callback(func, arg)")
     Callback(const U *obj, R(*func)(const T *, A0, A1, A2))
     {
         new (this) Callback(func, obj);
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to Callback(func, arg)
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to Callback(func, arg)")
     Callback(volatile U *obj, R(*func)(volatile T *, A0, A1, A2))
     {
         new (this) Callback(func, obj);
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to Callback(func, arg)
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to Callback(func, arg)")
     Callback(const volatile U *obj, R(*func)(const volatile T *, A0, A1, A2))
     {
         new (this) Callback(func, obj);
     }
 
     /** Destroy a callback
      */
     ~Callback()
     {
         if (_ops) {
             _ops->dtor(this);
         }
     }
 
     /** Attach a static function
      *  @param func     Static function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(A0, A1, A2))
     {
         this->~Callback();
         new (this) Callback(func);
     }
 
     /** Attach a Callback
      *  @param func     The Callback to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const Callback<R(A0, A1, A2)> &func)
     {
         this->~Callback();
         new (this) Callback(func);
     }
 
     /** Attach a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(U *obj, R(T::*method)(A0, A1, A2))
     {
         this->~Callback();
         new (this) Callback(obj, method);
     }
 
     /** Attach a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const U *obj, R(T::*method)(A0, A1, A2) const)
     {
         this->~Callback();
         new (this) Callback(obj, method);
     }
 
     /** Attach a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(volatile U *obj, R(T::*method)(A0, A1, A2) volatile)
     {
         this->~Callback();
         new (this) Callback(obj, method);
     }
 
     /** Attach a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const volatile U *obj, R(T::*method)(A0, A1, A2) const volatile)
     {
         this->~Callback();
         new (this) Callback(obj, method);
     }
 
     /** Attach a static function with a bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(T *, A0, A1, A2), U *arg)
     {
         this->~Callback();
         new (this) Callback(func, arg);
     }
 
     /** Attach a static function with a bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(const T *, A0, A1, A2), const U *arg)
     {
         this->~Callback();
         new (this) Callback(func, arg);
     }
 
     /** Attach a static function with a bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(volatile T *, A0, A1, A2), volatile U *arg)
     {
         this->~Callback();
         new (this) Callback(func, arg);
     }
 
     /** Attach a static function with a bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(const volatile T *, A0, A1, A2), const volatile U *arg)
     {
         this->~Callback();
         new (this) Callback(func, arg);
     }
 
     /** Attach a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename F>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1, A2)))
     {
         this->~Callback();
         new (this) Callback(f);
     }
 
     /** Attach a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename F>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1, A2) const))
     {
         this->~Callback();
         new (this) Callback(f);
     }
 
     /** Attach a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename F>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1, A2) volatile))
     {
         this->~Callback();
         new (this) Callback(f);
     }
 
     /** Attach a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename F>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1, A2) const volatile))
     {
         this->~Callback();
         new (this) Callback(f);
     }
 
     /** Attach a static function with a bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to attach(func, arg)
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to attach(func, arg)")
     void attach(U *obj, R(*func)(T *, A0, A1, A2))
     {
         this->~Callback();
         new (this) Callback(func, obj);
     }
 
     /** Attach a static function with a bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to attach(func, arg)
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to attach(func, arg)")
     void attach(const U *obj, R(*func)(const T *, A0, A1, A2))
     {
         this->~Callback();
         new (this) Callback(func, obj);
     }
 
     /** Attach a static function with a bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to attach(func, arg)
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to attach(func, arg)")
     void attach(volatile U *obj, R(*func)(volatile T *, A0, A1, A2))
     {
         this->~Callback();
         new (this) Callback(func, obj);
     }
 
     /** Attach a static function with a bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to attach(func, arg)
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to attach(func, arg)")
     void attach(const volatile U *obj, R(*func)(const volatile T *, A0, A1, A2))
     {
         this->~Callback();
         new (this) Callback(func, obj);
     }
 
     /** Assign a callback
      */
     Callback &operator=(const Callback &that)
     {
         if (this != &that) {
             this->~Callback();
             new (this) Callback(that);
         }
 
         return *this;
     }
 
     /** Call the attached function
      */
     R call(A0 a0, A1 a1, A2 a2) const
     {
         MBED_ASSERT(_ops);
         return _ops->call(this, a0, a1, a2);
     }
 
     /** Call the attached function
      */
     R operator()(A0 a0, A1 a1, A2 a2) const
     {
         return call(a0, a1, a2);
     }
 
     /** Test if function has been attached
      */
     operator bool() const
     {
         return _ops;
     }
 
     /** Test for equality
      */
     friend bool operator==(const Callback &l, const Callback &r)
     {
         return memcmp(&l, &r, sizeof(Callback)) == 0;
     }
 
     /** Test for inequality
      */
     friend bool operator!=(const Callback &l, const Callback &r)
     {
         return !(l == r);
     }
 
     /** Static thunk for passing as C-style function
      *  @param func Callback to call passed as void pointer
      *  @param a0 An argument to be called with function func
      *  @param a1 An argument to be called with function func
      *  @param a2 An argument to be called with function func
      *  @return the value as determined by func which is of
      *      type and determined by the signature of func
      */
     static R thunk(void *func, A0 a0, A1 a1, A2 a2)
     {
         return static_cast<Callback *>(func)->call(a0, a1, a2);
     }
 
 private:
     // Stored as pointer to function and pointer to optional object
     // Function pointer is stored as union of possible function types
     // to guarantee proper size and alignment
     struct _class;
     union {
         void (*_staticfunc)(A0, A1, A2);
         void (*_boundfunc)(_class *, A0, A1, A2);
         void (_class::*_methodfunc)(A0, A1, A2);
     } _func;
     void *_obj;
 
     // Dynamically dispatched operations
     const struct ops {
         R(*call)(const void *, A0, A1, A2);
         void (*move)(void *, const void *);
         void (*dtor)(void *);
     } *_ops;
 
     // Generate operations for function object
     template <typename F>
     void generate(const F &f)
     {
         static const ops ops = {
             &Callback::function_call<F>,
             &Callback::function_move<F>,
             &Callback::function_dtor<F>,
         };
 
         MBED_STATIC_ASSERT(sizeof(Callback) - sizeof(_ops) >= sizeof(F),
                            "Type F must not exceed the size of the Callback class");
         memset(this, 0, sizeof(Callback));
         new (this) F(f);
         _ops = &ops;
     }
 
     // Function attributes
     template <typename F>
     static R function_call(const void *p, A0 a0, A1 a1, A2 a2)
     {
         return (*(F *)p)(a0, a1, a2);
     }
 
     template <typename F>
     static void function_move(void *d, const void *p)
     {
         new (d) F(*(F *)p);
     }
 
     template <typename F>
     static void function_dtor(void *p)
     {
         ((F *)p)->~F();
     }
 
     // Wrappers for functions with context
     template <typename O, typename M>
     struct method_context {
         M method;
         O *obj;
 
         method_context(O *obj, M method)
             : method(method), obj(obj) {}
 
         R operator()(A0 a0, A1 a1, A2 a2) const
         {
             return (obj->*method)(a0, a1, a2);
         }
     };
 
     template <typename F, typename A>
     struct function_context {
         F func;
         A *arg;
 
         function_context(F func, A *arg)
             : func(func), arg(arg) {}
 
         R operator()(A0 a0, A1 a1, A2 a2) const
         {
             return func(arg, a0, a1, a2);
         }
     };
 };
 
 /** Callback class based on template specialization
  *
  * @note Synchronization level: Not protected
  */
 template <typename R, typename A0, typename A1, typename A2, typename A3>
 class Callback<R(A0, A1, A2, A3)> {
 public:
     /** Create a Callback with a static function
      *  @param func     Static function to attach
      */
     Callback(R(*func)(A0, A1, A2, A3) = 0)
     {
         if (!func) {
             memset(this, 0, sizeof(Callback));
         } else {
             generate(func);
         }
     }
 
     /** Attach a Callback
      *  @param func     The Callback to attach
      */
     Callback(const Callback<R(A0, A1, A2, A3)> &func)
     {
         memset(this, 0, sizeof(Callback));
         if (func._ops) {
             func._ops->move(this, &func);
         }
         _ops = func._ops;
     }
 
     /** Create a Callback with a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      */
     template<typename T, typename U>
     Callback(U *obj, R(T::*method)(A0, A1, A2, A3))
     {
         generate(method_context<T, R(T::*)(A0, A1, A2, A3)>(obj, method));
     }
 
     /** Create a Callback with a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      */
     template<typename T, typename U>
     Callback(const U *obj, R(T::*method)(A0, A1, A2, A3) const)
     {
         generate(method_context<const T, R(T::*)(A0, A1, A2, A3) const>(obj, method));
     }
 
     /** Create a Callback with a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      */
     template<typename T, typename U>
     Callback(volatile U *obj, R(T::*method)(A0, A1, A2, A3) volatile)
     {
         generate(method_context<volatile T, R(T::*)(A0, A1, A2, A3) volatile>(obj, method));
     }
 
     /** Create a Callback with a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      */
     template<typename T, typename U>
     Callback(const volatile U *obj, R(T::*method)(A0, A1, A2, A3) const volatile)
     {
         generate(method_context<const volatile T, R(T::*)(A0, A1, A2, A3) const volatile>(obj, method));
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      */
     template<typename T, typename U>
     Callback(R(*func)(T *, A0, A1, A2, A3), U *arg)
     {
         generate(function_context<R(*)(T *, A0, A1, A2, A3), T>(func, arg));
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      */
     template<typename T, typename U>
     Callback(R(*func)(const T *, A0, A1, A2, A3), const U *arg)
     {
         generate(function_context<R(*)(const T *, A0, A1, A2, A3), const T>(func, arg));
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      */
     template<typename T, typename U>
     Callback(R(*func)(volatile T *, A0, A1, A2, A3), volatile U *arg)
     {
         generate(function_context<R(*)(volatile T *, A0, A1, A2, A3), volatile T>(func, arg));
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      */
     template<typename T, typename U>
     Callback(R(*func)(const volatile T *, A0, A1, A2, A3), const volatile U *arg)
     {
         generate(function_context<R(*)(const volatile T *, A0, A1, A2, A3), const volatile T>(func, arg));
     }
 
     /** Create a Callback with a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      */
     template <typename F>
     Callback(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1, A2, A3)))
     {
         generate(f);
     }
 
     /** Create a Callback with a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      */
     template <typename F>
     Callback(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1, A2, A3) const))
     {
         generate(f);
     }
 
     /** Create a Callback with a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      */
     template <typename F>
     Callback(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1, A2, A3) volatile))
     {
         generate(f);
     }
 
     /** Create a Callback with a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      */
     template <typename F>
     Callback(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1, A2, A3) const volatile))
     {
         generate(f);
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to Callback(func, arg)
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to Callback(func, arg)")
     Callback(U *obj, R(*func)(T *, A0, A1, A2, A3))
     {
         new (this) Callback(func, obj);
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to Callback(func, arg)
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to Callback(func, arg)")
     Callback(const U *obj, R(*func)(const T *, A0, A1, A2, A3))
     {
         new (this) Callback(func, obj);
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to Callback(func, arg)
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to Callback(func, arg)")
     Callback(volatile U *obj, R(*func)(volatile T *, A0, A1, A2, A3))
     {
         new (this) Callback(func, obj);
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to Callback(func, arg)
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to Callback(func, arg)")
     Callback(const volatile U *obj, R(*func)(const volatile T *, A0, A1, A2, A3))
     {
         new (this) Callback(func, obj);
     }
 
     /** Destroy a callback
      */
     ~Callback()
     {
         if (_ops) {
             _ops->dtor(this);
         }
     }
 
     /** Attach a static function
      *  @param func     Static function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(A0, A1, A2, A3))
     {
         this->~Callback();
         new (this) Callback(func);
     }
 
     /** Attach a Callback
      *  @param func     The Callback to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const Callback<R(A0, A1, A2, A3)> &func)
     {
         this->~Callback();
         new (this) Callback(func);
     }
 
     /** Attach a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(U *obj, R(T::*method)(A0, A1, A2, A3))
     {
         this->~Callback();
         new (this) Callback(obj, method);
     }
 
     /** Attach a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const U *obj, R(T::*method)(A0, A1, A2, A3) const)
     {
         this->~Callback();
         new (this) Callback(obj, method);
     }
 
     /** Attach a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(volatile U *obj, R(T::*method)(A0, A1, A2, A3) volatile)
     {
         this->~Callback();
         new (this) Callback(obj, method);
     }
 
     /** Attach a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const volatile U *obj, R(T::*method)(A0, A1, A2, A3) const volatile)
     {
         this->~Callback();
         new (this) Callback(obj, method);
     }
 
     /** Attach a static function with a bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(T *, A0, A1, A2, A3), U *arg)
     {
         this->~Callback();
         new (this) Callback(func, arg);
     }
 
     /** Attach a static function with a bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(const T *, A0, A1, A2, A3), const U *arg)
     {
         this->~Callback();
         new (this) Callback(func, arg);
     }
 
     /** Attach a static function with a bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(volatile T *, A0, A1, A2, A3), volatile U *arg)
     {
         this->~Callback();
         new (this) Callback(func, arg);
     }
 
     /** Attach a static function with a bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(const volatile T *, A0, A1, A2, A3), const volatile U *arg)
     {
         this->~Callback();
         new (this) Callback(func, arg);
     }
 
     /** Attach a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename F>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1, A2, A3)))
     {
         this->~Callback();
         new (this) Callback(f);
     }
 
     /** Attach a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename F>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1, A2, A3) const))
     {
         this->~Callback();
         new (this) Callback(f);
     }
 
     /** Attach a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename F>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1, A2, A3) volatile))
     {
         this->~Callback();
         new (this) Callback(f);
     }
 
     /** Attach a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename F>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1, A2, A3) const volatile))
     {
         this->~Callback();
         new (this) Callback(f);
     }
 
     /** Attach a static function with a bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to attach(func, arg)
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to attach(func, arg)")
     void attach(U *obj, R(*func)(T *, A0, A1, A2, A3))
     {
         this->~Callback();
         new (this) Callback(func, obj);
     }
 
     /** Attach a static function with a bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to attach(func, arg)
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to attach(func, arg)")
     void attach(const U *obj, R(*func)(const T *, A0, A1, A2, A3))
     {
         this->~Callback();
         new (this) Callback(func, obj);
     }
 
     /** Attach a static function with a bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to attach(func, arg)
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to attach(func, arg)")
     void attach(volatile U *obj, R(*func)(volatile T *, A0, A1, A2, A3))
     {
         this->~Callback();
         new (this) Callback(func, obj);
     }
 
     /** Attach a static function with a bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to attach(func, arg)
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to attach(func, arg)")
     void attach(const volatile U *obj, R(*func)(const volatile T *, A0, A1, A2, A3))
     {
         this->~Callback();
         new (this) Callback(func, obj);
     }
 
     /** Assign a callback
      */
     Callback &operator=(const Callback &that)
     {
         if (this != &that) {
             this->~Callback();
             new (this) Callback(that);
         }
 
         return *this;
     }
 
     /** Call the attached function
      */
     R call(A0 a0, A1 a1, A2 a2, A3 a3) const
     {
         MBED_ASSERT(_ops);
         return _ops->call(this, a0, a1, a2, a3);
     }
 
     /** Call the attached function
      */
     R operator()(A0 a0, A1 a1, A2 a2, A3 a3) const
     {
         return call(a0, a1, a2, a3);
     }
 
     /** Test if function has been attached
      */
     operator bool() const
     {
         return _ops;
     }
 
     /** Test for equality
      */
     friend bool operator==(const Callback &l, const Callback &r)
     {
         return memcmp(&l, &r, sizeof(Callback)) == 0;
     }
 
     /** Test for inequality
      */
     friend bool operator!=(const Callback &l, const Callback &r)
     {
         return !(l == r);
     }
 
     /** Static thunk for passing as C-style function
      *  @param func Callback to call passed as void pointer
      *  @param a0 An argument to be called with function func
      *  @param a1 An argument to be called with function func
      *  @param a2 An argument to be called with function func
      *  @param a3 An argument to be called with function func
      *  @return the value as determined by func which is of
      *      type and determined by the signature of func
      */
     static R thunk(void *func, A0 a0, A1 a1, A2 a2, A3 a3)
     {
         return static_cast<Callback *>(func)->call(a0, a1, a2, a3);
     }
 
 private:
     // Stored as pointer to function and pointer to optional object
     // Function pointer is stored as union of possible function types
     // to guarantee proper size and alignment
     struct _class;
     union {
         void (*_staticfunc)(A0, A1, A2, A3);
         void (*_boundfunc)(_class *, A0, A1, A2, A3);
         void (_class::*_methodfunc)(A0, A1, A2, A3);
     } _func;
     void *_obj;
 
     // Dynamically dispatched operations
     const struct ops {
         R(*call)(const void *, A0, A1, A2, A3);
         void (*move)(void *, const void *);
         void (*dtor)(void *);
     } *_ops;
 
     // Generate operations for function object
     template <typename F>
     void generate(const F &f)
     {
         static const ops ops = {
             &Callback::function_call<F>,
             &Callback::function_move<F>,
             &Callback::function_dtor<F>,
         };
 
         MBED_STATIC_ASSERT(sizeof(Callback) - sizeof(_ops) >= sizeof(F),
                            "Type F must not exceed the size of the Callback class");
         memset(this, 0, sizeof(Callback));
         new (this) F(f);
         _ops = &ops;
     }
 
     // Function attributes
     template <typename F>
     static R function_call(const void *p, A0 a0, A1 a1, A2 a2, A3 a3)
     {
         return (*(F *)p)(a0, a1, a2, a3);
     }
 
     template <typename F>
     static void function_move(void *d, const void *p)
     {
         new (d) F(*(F *)p);
     }
 
     template <typename F>
     static void function_dtor(void *p)
     {
         ((F *)p)->~F();
     }
 
     // Wrappers for functions with context
     template <typename O, typename M>
     struct method_context {
         M method;
         O *obj;
 
         method_context(O *obj, M method)
             : method(method), obj(obj) {}
 
         R operator()(A0 a0, A1 a1, A2 a2, A3 a3) const
         {
             return (obj->*method)(a0, a1, a2, a3);
         }
     };
 
     template <typename F, typename A>
     struct function_context {
         F func;
         A *arg;
 
         function_context(F func, A *arg)
             : func(func), arg(arg) {}
 
         R operator()(A0 a0, A1 a1, A2 a2, A3 a3) const
         {
             return func(arg, a0, a1, a2, a3);
         }
     };
 };
 
 /** Callback class based on template specialization
  *
  * @note Synchronization level: Not protected
  */
 template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
 class Callback<R(A0, A1, A2, A3, A4)> {
 public:
     /** Create a Callback with a static function
      *  @param func     Static function to attach
      */
     Callback(R(*func)(A0, A1, A2, A3, A4) = 0)
     {
         if (!func) {
             memset(this, 0, sizeof(Callback));
         } else {
             generate(func);
         }
     }
 
     /** Attach a Callback
      *  @param func     The Callback to attach
      */
     Callback(const Callback<R(A0, A1, A2, A3, A4)> &func)
     {
         memset(this, 0, sizeof(Callback));
         if (func._ops) {
             func._ops->move(this, &func);
         }
         _ops = func._ops;
     }
 
     /** Create a Callback with a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      */
     template<typename T, typename U>
     Callback(U *obj, R(T::*method)(A0, A1, A2, A3, A4))
     {
         generate(method_context<T, R(T::*)(A0, A1, A2, A3, A4)>(obj, method));
     }
 
     /** Create a Callback with a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      */
     template<typename T, typename U>
     Callback(const U *obj, R(T::*method)(A0, A1, A2, A3, A4) const)
     {
         generate(method_context<const T, R(T::*)(A0, A1, A2, A3, A4) const>(obj, method));
     }
 
     /** Create a Callback with a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      */
     template<typename T, typename U>
     Callback(volatile U *obj, R(T::*method)(A0, A1, A2, A3, A4) volatile)
     {
         generate(method_context<volatile T, R(T::*)(A0, A1, A2, A3, A4) volatile>(obj, method));
     }
 
     /** Create a Callback with a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      */
     template<typename T, typename U>
     Callback(const volatile U *obj, R(T::*method)(A0, A1, A2, A3, A4) const volatile)
     {
         generate(method_context<const volatile T, R(T::*)(A0, A1, A2, A3, A4) const volatile>(obj, method));
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      */
     template<typename T, typename U>
     Callback(R(*func)(T *, A0, A1, A2, A3, A4), U *arg)
     {
         generate(function_context<R(*)(T *, A0, A1, A2, A3, A4), T>(func, arg));
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      */
     template<typename T, typename U>
     Callback(R(*func)(const T *, A0, A1, A2, A3, A4), const U *arg)
     {
         generate(function_context<R(*)(const T *, A0, A1, A2, A3, A4), const T>(func, arg));
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      */
     template<typename T, typename U>
     Callback(R(*func)(volatile T *, A0, A1, A2, A3, A4), volatile U *arg)
     {
         generate(function_context<R(*)(volatile T *, A0, A1, A2, A3, A4), volatile T>(func, arg));
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      */
     template<typename T, typename U>
     Callback(R(*func)(const volatile T *, A0, A1, A2, A3, A4), const volatile U *arg)
     {
         generate(function_context<R(*)(const volatile T *, A0, A1, A2, A3, A4), const volatile T>(func, arg));
     }
 
     /** Create a Callback with a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      */
     template <typename F>
     Callback(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1, A2, A3, A4)))
     {
         generate(f);
     }
 
     /** Create a Callback with a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      */
     template <typename F>
     Callback(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1, A2, A3, A4) const))
     {
         generate(f);
     }
 
     /** Create a Callback with a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      */
     template <typename F>
     Callback(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1, A2, A3, A4) volatile))
     {
         generate(f);
     }
 
     /** Create a Callback with a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      */
     template <typename F>
     Callback(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1, A2, A3, A4) const volatile))
     {
         generate(f);
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to Callback(func, arg)
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to Callback(func, arg)")
     Callback(U *obj, R(*func)(T *, A0, A1, A2, A3, A4))
     {
         new (this) Callback(func, obj);
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to Callback(func, arg)
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to Callback(func, arg)")
     Callback(const U *obj, R(*func)(const T *, A0, A1, A2, A3, A4))
     {
         new (this) Callback(func, obj);
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to Callback(func, arg)
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to Callback(func, arg)")
     Callback(volatile U *obj, R(*func)(volatile T *, A0, A1, A2, A3, A4))
     {
         new (this) Callback(func, obj);
     }
 
     /** Create a Callback with a static function and bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to Callback(func, arg)
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to Callback(func, arg)")
     Callback(const volatile U *obj, R(*func)(const volatile T *, A0, A1, A2, A3, A4))
     {
         new (this) Callback(func, obj);
     }
 
     /** Destroy a callback
      */
     ~Callback()
     {
         if (_ops) {
             _ops->dtor(this);
         }
     }
 
     /** Attach a static function
      *  @param func     Static function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(A0, A1, A2, A3, A4))
     {
         this->~Callback();
         new (this) Callback(func);
     }
 
     /** Attach a Callback
      *  @param func     The Callback to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const Callback<R(A0, A1, A2, A3, A4)> &func)
     {
         this->~Callback();
         new (this) Callback(func);
     }
 
     /** Attach a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(U *obj, R(T::*method)(A0, A1, A2, A3, A4))
     {
         this->~Callback();
         new (this) Callback(obj, method);
     }
 
     /** Attach a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const U *obj, R(T::*method)(A0, A1, A2, A3, A4) const)
     {
         this->~Callback();
         new (this) Callback(obj, method);
     }
 
     /** Attach a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(volatile U *obj, R(T::*method)(A0, A1, A2, A3, A4) volatile)
     {
         this->~Callback();
         new (this) Callback(obj, method);
     }
 
     /** Attach a member function
      *  @param obj      Pointer to object to invoke member function on
      *  @param method   Member function to attach
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template<typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const volatile U *obj, R(T::*method)(A0, A1, A2, A3, A4) const volatile)
     {
         this->~Callback();
         new (this) Callback(obj, method);
     }
 
     /** Attach a static function with a bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(T *, A0, A1, A2, A3, A4), U *arg)
     {
         this->~Callback();
         new (this) Callback(func, arg);
     }
 
     /** Attach a static function with a bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(const T *, A0, A1, A2, A3, A4), const U *arg)
     {
         this->~Callback();
         new (this) Callback(func, arg);
     }
 
     /** Attach a static function with a bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(volatile T *, A0, A1, A2, A3, A4), volatile U *arg)
     {
         this->~Callback();
         new (this) Callback(func, arg);
     }
 
     /** Attach a static function with a bound pointer
      *  @param func     Static function to attach
      *  @param arg      Pointer argument to function
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(R(*func)(const volatile T *, A0, A1, A2, A3, A4), const volatile U *arg)
     {
         this->~Callback();
         new (this) Callback(func, arg);
     }
 
     /** Attach a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename F>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1, A2, A3, A4)))
     {
         this->~Callback();
         new (this) Callback(f);
     }
 
     /** Attach a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename F>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1, A2, A3, A4) const))
     {
         this->~Callback();
         new (this) Callback(f);
     }
 
     /** Attach a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename F>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1, A2, A3, A4) volatile))
     {
         this->~Callback();
         new (this) Callback(f);
     }
 
     /** Attach a function object
      *  @param f Function object to attach
      *  @note The function object is limited to a single word of storage
      *  @deprecated
      *      Replaced by simple assignment 'Callback cb = func'
      */
     template <typename F>
     MBED_DEPRECATED_SINCE("mbed-os-5.4",
                           "Replaced by simple assignment 'Callback cb = func")
     void attach(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R(F::*)(A0, A1, A2, A3, A4) const volatile))
     {
         this->~Callback();
         new (this) Callback(f);
     }
 
     /** Attach a static function with a bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to attach(func, arg)
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to attach(func, arg)")
     void attach(U *obj, R(*func)(T *, A0, A1, A2, A3, A4))
     {
         this->~Callback();
         new (this) Callback(func, obj);
     }
 
     /** Attach a static function with a bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to attach(func, arg)
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to attach(func, arg)")
     void attach(const U *obj, R(*func)(const T *, A0, A1, A2, A3, A4))
     {
         this->~Callback();
         new (this) Callback(func, obj);
     }
 
     /** Attach a static function with a bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to attach(func, arg)
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to attach(func, arg)")
     void attach(volatile U *obj, R(*func)(volatile T *, A0, A1, A2, A3, A4))
     {
         this->~Callback();
         new (this) Callback(func, obj);
     }
 
     /** Attach a static function with a bound pointer
      *  @param obj  Pointer to object to bind to function
      *  @param func Static function to attach
      *  @deprecated
      *      Arguments to callback have been reordered to attach(func, arg)
      */
     template <typename T, typename U>
     MBED_DEPRECATED_SINCE("mbed-os-5.1",
                           "Arguments to callback have been reordered to attach(func, arg)")
     void attach(const volatile U *obj, R(*func)(const volatile T *, A0, A1, A2, A3, A4))
     {
         this->~Callback();
         new (this) Callback(func, obj);
     }
 
     /** Assign a callback
      */
     Callback &operator=(const Callback &that)
     {
         if (this != &that) {
             this->~Callback();
             new (this) Callback(that);
         }
 
         return *this;
     }
 
     /** Call the attached function
      */
     R call(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const
     {
         MBED_ASSERT(_ops);
         return _ops->call(this, a0, a1, a2, a3, a4);
     }
 
     /** Call the attached function
      */
     R operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const
     {
         return call(a0, a1, a2, a3, a4);
     }
 
     /** Test if function has been attached
      */
     operator bool() const
     {
         return _ops;
     }
 
     /** Test for equality
      */
     friend bool operator==(const Callback &l, const Callback &r)
     {
         return memcmp(&l, &r, sizeof(Callback)) == 0;
     }
 
     /** Test for inequality
      */
     friend bool operator!=(const Callback &l, const Callback &r)
     {
         return !(l == r);
     }
 
     /** Static thunk for passing as C-style function
      *  @param func Callback to call passed as void pointer
      *  @param a0 An argument to be called with function func
      *  @param a1 An argument to be called with function func
      *  @param a2 An argument to be called with function func
      *  @param a3 An argument to be called with function func
      *  @param a4 An argument to be called with function func
      *  @return the value as determined by func which is of
      *      type and determined by the signature of func
      */
     static R thunk(void *func, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4)
     {
         return static_cast<Callback *>(func)->call(a0, a1, a2, a3, a4);
     }
 
 private:
     // Stored as pointer to function and pointer to optional object
     // Function pointer is stored as union of possible function types
     // to guarantee proper size and alignment
     struct _class;
     union {
         void (*_staticfunc)(A0, A1, A2, A3, A4);
         void (*_boundfunc)(_class *, A0, A1, A2, A3, A4);
         void (_class::*_methodfunc)(A0, A1, A2, A3, A4);
     } _func;
     void *_obj;
 
     // Dynamically dispatched operations
     const struct ops {
         R(*call)(const void *, A0, A1, A2, A3, A4);
         void (*move)(void *, const void *);
         void (*dtor)(void *);
     } *_ops;
 
     // Generate operations for function object
     template <typename F>
     void generate(const F &f)
     {
         static const ops ops = {
             &Callback::function_call<F>,
             &Callback::function_move<F>,
             &Callback::function_dtor<F>,
         };
 
         MBED_STATIC_ASSERT(sizeof(Callback) - sizeof(_ops) >= sizeof(F),
                            "Type F must not exceed the size of the Callback class");
         memset(this, 0, sizeof(Callback));
         new (this) F(f);
         _ops = &ops;
     }
 
     // Function attributes
     template <typename F>
     static R function_call(const void *p, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4)
     {
         return (*(F *)p)(a0, a1, a2, a3, a4);
     }
 
     template <typename F>
     static void function_move(void *d, const void *p)
     {
         new (d) F(*(F *)p);
     }
 
     template <typename F>
     static void function_dtor(void *p)
     {
         ((F *)p)->~F();
     }
 
     // Wrappers for functions with context
     template <typename O, typename M>
     struct method_context {
         M method;
         O *obj;
 
         method_context(O *obj, M method)
             : method(method), obj(obj) {}
 
         R operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const
         {
             return (obj->*method)(a0, a1, a2, a3, a4);
         }
     };
 
     template <typename F, typename A>
     struct function_context {
         F func;
         A *arg;
 
         function_context(F func, A *arg)
             : func(func), arg(arg) {}
 
         R operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const
         {
             return func(arg, a0, a1, a2, a3, a4);
         }
     };
 };
 
 // Internally used event type
 typedef Callback<void(int)> event_callback_t;
 
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @return         Callback with inferred type
  */
 template <typename R>
 Callback<R()> callback(R(*func)() = 0)
 {
     return Callback<R()>(func);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @return         Callback with inferred type
  */
 template <typename R>
 Callback<R()> callback(const Callback<R()> &func)
 {
     return Callback<R()>(func);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj      Optional pointer to object to bind to function
  *  @param method   Member function to attach
  *  @return         Callback with inferred type
  */
 template<typename T, typename U, typename R>
 Callback<R()> callback(U *obj, R(T::*method)())
 {
     return Callback<R()>(obj, method);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj      Optional pointer to object to bind to function
  *  @param method   Member function to attach
  *  @return         Callback with inferred type
  */
 template<typename T, typename U, typename R>
 Callback<R()> callback(const U *obj, R(T::*method)() const)
 {
     return Callback<R()>(obj, method);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj      Optional pointer to object to bind to function
  *  @param method   Member function to attach
  *  @return         Callback with inferred type
  */
 template<typename T, typename U, typename R>
 Callback<R()> callback(volatile U *obj, R(T::*method)() volatile)
 {
     return Callback<R()>(obj, method);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj      Optional pointer to object to bind to function
  *  @param method   Member function to attach
  *  @return         Callback with inferred type
  */
 template<typename T, typename U, typename R>
 Callback<R()> callback(const volatile U *obj, R(T::*method)() const volatile)
 {
     return Callback<R()>(obj, method);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @param arg      Pointer argument to function
  *  @return         Callback with inferred type
  */
 template <typename T, typename U, typename R>
 Callback<R()> callback(R(*func)(T *), U *arg)
 {
     return Callback<R()>(func, arg);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @param arg      Pointer argument to function
  *  @return         Callback with inferred type
  */
 template <typename T, typename U, typename R>
 Callback<R()> callback(R(*func)(const T *), const U *arg)
 {
     return Callback<R()>(func, arg);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @param arg      Pointer argument to function
  *  @return         Callback with inferred type
  */
 template <typename T, typename U, typename R>
 Callback<R()> callback(R(*func)(volatile T *), volatile U *arg)
 {
     return Callback<R()>(func, arg);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @param arg      Pointer argument to function
  *  @return         Callback with inferred type
  */
 template <typename T, typename U, typename R>
 Callback<R()> callback(R(*func)(const volatile T *), const volatile U *arg)
 {
     return Callback<R()>(func, arg);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj  Optional pointer to object to bind to function
  *  @param func Static function to attach
  *  @return     Callback with inferred type
  *  @deprecated
  *      Arguments to callback have been reordered to callback(func, arg)
  */
 template <typename T, typename U, typename R>
 MBED_DEPRECATED_SINCE("mbed-os-5.1",
                       "Arguments to callback have been reordered to callback(func, arg)")
 Callback<R()> callback(U *obj, R(*func)(T *))
 {
     return Callback<R()>(func, obj);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj  Optional pointer to object to bind to function
  *  @param func Static function to attach
  *  @return     Callback with inferred type
  *  @deprecated
  *      Arguments to callback have been reordered to callback(func, arg)
  */
 template <typename T, typename U, typename R>
 MBED_DEPRECATED_SINCE("mbed-os-5.1",
                       "Arguments to callback have been reordered to callback(func, arg)")
 Callback<R()> callback(const U *obj, R(*func)(const T *))
 {
     return Callback<R()>(func, obj);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj  Optional pointer to object to bind to function
  *  @param func Static function to attach
  *  @return     Callback with inferred type
  *  @deprecated
  *      Arguments to callback have been reordered to callback(func, arg)
  */
 template <typename T, typename U, typename R>
 MBED_DEPRECATED_SINCE("mbed-os-5.1",
                       "Arguments to callback have been reordered to callback(func, arg)")
 Callback<R()> callback(volatile U *obj, R(*func)(volatile T *))
 {
     return Callback<R()>(func, obj);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj  Optional pointer to object to bind to function
  *  @param func Static function to attach
  *  @return     Callback with inferred type
  *  @deprecated
  *      Arguments to callback have been reordered to callback(func, arg)
  */
 template <typename T, typename U, typename R>
 MBED_DEPRECATED_SINCE("mbed-os-5.1",
                       "Arguments to callback have been reordered to callback(func, arg)")
 Callback<R()> callback(const volatile U *obj, R(*func)(const volatile T *))
 {
     return Callback<R()>(func, obj);
 }
 
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @return         Callback with inferred type
  */
 template <typename R, typename A0>
 Callback<R(A0)> callback(R(*func)(A0) = 0)
 {
     return Callback<R(A0)>(func);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @return         Callback with inferred type
  */
 template <typename R, typename A0>
 Callback<R(A0)> callback(const Callback<R(A0)> &func)
 {
     return Callback<R(A0)>(func);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj      Optional pointer to object to bind to function
  *  @param method   Member function to attach
  *  @return         Callback with inferred type
  */
 template<typename T, typename U, typename R, typename A0>
 Callback<R(A0)> callback(U *obj, R(T::*method)(A0))
 {
     return Callback<R(A0)>(obj, method);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj      Optional pointer to object to bind to function
  *  @param method   Member function to attach
  *  @return         Callback with inferred type
  */
 template<typename T, typename U, typename R, typename A0>
 Callback<R(A0)> callback(const U *obj, R(T::*method)(A0) const)
 {
     return Callback<R(A0)>(obj, method);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj      Optional pointer to object to bind to function
  *  @param method   Member function to attach
  *  @return         Callback with inferred type
  */
 template<typename T, typename U, typename R, typename A0>
 Callback<R(A0)> callback(volatile U *obj, R(T::*method)(A0) volatile)
 {
     return Callback<R(A0)>(obj, method);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj      Optional pointer to object to bind to function
  *  @param method   Member function to attach
  *  @return         Callback with inferred type
  */
 template<typename T, typename U, typename R, typename A0>
 Callback<R(A0)> callback(const volatile U *obj, R(T::*method)(A0) const volatile)
 {
     return Callback<R(A0)>(obj, method);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @param arg      Pointer argument to function
  *  @return         Callback with inferred type
  */
 template <typename T, typename U, typename R, typename A0>
 Callback<R(A0)> callback(R(*func)(T *, A0), U *arg)
 {
     return Callback<R(A0)>(func, arg);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @param arg      Pointer argument to function
  *  @return         Callback with inferred type
  */
 template <typename T, typename U, typename R, typename A0>
 Callback<R(A0)> callback(R(*func)(const T *, A0), const U *arg)
 {
     return Callback<R(A0)>(func, arg);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @param arg      Pointer argument to function
  *  @return         Callback with inferred type
  */
 template <typename T, typename U, typename R, typename A0>
 Callback<R(A0)> callback(R(*func)(volatile T *, A0), volatile U *arg)
 {
     return Callback<R(A0)>(func, arg);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @param arg      Pointer argument to function
  *  @return         Callback with inferred type
  */
 template <typename T, typename U, typename R, typename A0>
 Callback<R(A0)> callback(R(*func)(const volatile T *, A0), const volatile U *arg)
 {
     return Callback<R(A0)>(func, arg);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj  Optional pointer to object to bind to function
  *  @param func Static function to attach
  *  @return     Callback with inferred type
  *  @deprecated
  *      Arguments to callback have been reordered to callback(func, arg)
  */
 template <typename T, typename U, typename R, typename A0>
 MBED_DEPRECATED_SINCE("mbed-os-5.1",
                       "Arguments to callback have been reordered to callback(func, arg)")
 Callback<R(A0)> callback(U *obj, R(*func)(T *, A0))
 {
     return Callback<R(A0)>(func, obj);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj  Optional pointer to object to bind to function
  *  @param func Static function to attach
  *  @return     Callback with inferred type
  *  @deprecated
  *      Arguments to callback have been reordered to callback(func, arg)
  */
 template <typename T, typename U, typename R, typename A0>
 MBED_DEPRECATED_SINCE("mbed-os-5.1",
                       "Arguments to callback have been reordered to callback(func, arg)")
 Callback<R(A0)> callback(const U *obj, R(*func)(const T *, A0))
 {
     return Callback<R(A0)>(func, obj);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj  Optional pointer to object to bind to function
  *  @param func Static function to attach
  *  @return     Callback with inferred type
  *  @deprecated
  *      Arguments to callback have been reordered to callback(func, arg)
  */
 template <typename T, typename U, typename R, typename A0>
 MBED_DEPRECATED_SINCE("mbed-os-5.1",
                       "Arguments to callback have been reordered to callback(func, arg)")
 Callback<R(A0)> callback(volatile U *obj, R(*func)(volatile T *, A0))
 {
     return Callback<R(A0)>(func, obj);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj  Optional pointer to object to bind to function
  *  @param func Static function to attach
  *  @return     Callback with inferred type
  *  @deprecated
  *      Arguments to callback have been reordered to callback(func, arg)
  */
 template <typename T, typename U, typename R, typename A0>
 MBED_DEPRECATED_SINCE("mbed-os-5.1",
                       "Arguments to callback have been reordered to callback(func, arg)")
 Callback<R(A0)> callback(const volatile U *obj, R(*func)(const volatile T *, A0))
 {
     return Callback<R(A0)>(func, obj);
 }
 
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @return         Callback with inferred type
  */
 template <typename R, typename A0, typename A1>
 Callback<R(A0, A1)> callback(R(*func)(A0, A1) = 0)
 {
     return Callback<R(A0, A1)>(func);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @return         Callback with inferred type
  */
 template <typename R, typename A0, typename A1>
 Callback<R(A0, A1)> callback(const Callback<R(A0, A1)> &func)
 {
     return Callback<R(A0, A1)>(func);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj      Optional pointer to object to bind to function
  *  @param method   Member function to attach
  *  @return         Callback with inferred type
  */
 template<typename T, typename U, typename R, typename A0, typename A1>
 Callback<R(A0, A1)> callback(U *obj, R(T::*method)(A0, A1))
 {
     return Callback<R(A0, A1)>(obj, method);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj      Optional pointer to object to bind to function
  *  @param method   Member function to attach
  *  @return         Callback with inferred type
  */
 template<typename T, typename U, typename R, typename A0, typename A1>
 Callback<R(A0, A1)> callback(const U *obj, R(T::*method)(A0, A1) const)
 {
     return Callback<R(A0, A1)>(obj, method);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj      Optional pointer to object to bind to function
  *  @param method   Member function to attach
  *  @return         Callback with inferred type
  */
 template<typename T, typename U, typename R, typename A0, typename A1>
 Callback<R(A0, A1)> callback(volatile U *obj, R(T::*method)(A0, A1) volatile)
 {
     return Callback<R(A0, A1)>(obj, method);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj      Optional pointer to object to bind to function
  *  @param method   Member function to attach
  *  @return         Callback with inferred type
  */
 template<typename T, typename U, typename R, typename A0, typename A1>
 Callback<R(A0, A1)> callback(const volatile U *obj, R(T::*method)(A0, A1) const volatile)
 {
     return Callback<R(A0, A1)>(obj, method);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @param arg      Pointer argument to function
  *  @return         Callback with inferred type
  */
 template <typename T, typename U, typename R, typename A0, typename A1>
 Callback<R(A0, A1)> callback(R(*func)(T *, A0, A1), U *arg)
 {
     return Callback<R(A0, A1)>(func, arg);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @param arg      Pointer argument to function
  *  @return         Callback with inferred type
  */
 template <typename T, typename U, typename R, typename A0, typename A1>
 Callback<R(A0, A1)> callback(R(*func)(const T *, A0, A1), const U *arg)
 {
     return Callback<R(A0, A1)>(func, arg);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @param arg      Pointer argument to function
  *  @return         Callback with inferred type
  */
 template <typename T, typename U, typename R, typename A0, typename A1>
 Callback<R(A0, A1)> callback(R(*func)(volatile T *, A0, A1), volatile U *arg)
 {
     return Callback<R(A0, A1)>(func, arg);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @param arg      Pointer argument to function
  *  @return         Callback with inferred type
  */
 template <typename T, typename U, typename R, typename A0, typename A1>
 Callback<R(A0, A1)> callback(R(*func)(const volatile T *, A0, A1), const volatile U *arg)
 {
     return Callback<R(A0, A1)>(func, arg);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj  Optional pointer to object to bind to function
  *  @param func Static function to attach
  *  @return     Callback with inferred type
  *  @deprecated
  *      Arguments to callback have been reordered to callback(func, arg)
  */
 template <typename T, typename U, typename R, typename A0, typename A1>
 MBED_DEPRECATED_SINCE("mbed-os-5.1",
                       "Arguments to callback have been reordered to callback(func, arg)")
 Callback<R(A0, A1)> callback(U *obj, R(*func)(T *, A0, A1))
 {
     return Callback<R(A0, A1)>(func, obj);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj  Optional pointer to object to bind to function
  *  @param func Static function to attach
  *  @return     Callback with inferred type
  *  @deprecated
  *      Arguments to callback have been reordered to callback(func, arg)
  */
 template <typename T, typename U, typename R, typename A0, typename A1>
 MBED_DEPRECATED_SINCE("mbed-os-5.1",
                       "Arguments to callback have been reordered to callback(func, arg)")
 Callback<R(A0, A1)> callback(const U *obj, R(*func)(const T *, A0, A1))
 {
     return Callback<R(A0, A1)>(func, obj);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj  Optional pointer to object to bind to function
  *  @param func Static function to attach
  *  @return     Callback with inferred type
  *  @deprecated
  *      Arguments to callback have been reordered to callback(func, arg)
  */
 template <typename T, typename U, typename R, typename A0, typename A1>
 MBED_DEPRECATED_SINCE("mbed-os-5.1",
                       "Arguments to callback have been reordered to callback(func, arg)")
 Callback<R(A0, A1)> callback(volatile U *obj, R(*func)(volatile T *, A0, A1))
 {
     return Callback<R(A0, A1)>(func, obj);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj  Optional pointer to object to bind to function
  *  @param func Static function to attach
  *  @return     Callback with inferred type
  *  @deprecated
  *      Arguments to callback have been reordered to callback(func, arg)
  */
 template <typename T, typename U, typename R, typename A0, typename A1>
 MBED_DEPRECATED_SINCE("mbed-os-5.1",
                       "Arguments to callback have been reordered to callback(func, arg)")
 Callback<R(A0, A1)> callback(const volatile U *obj, R(*func)(const volatile T *, A0, A1))
 {
     return Callback<R(A0, A1)>(func, obj);
 }
 
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @return         Callback with inferred type
  */
 template <typename R, typename A0, typename A1, typename A2>
 Callback<R(A0, A1, A2)> callback(R(*func)(A0, A1, A2) = 0)
 {
     return Callback<R(A0, A1, A2)>(func);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @return         Callback with inferred type
  */
 template <typename R, typename A0, typename A1, typename A2>
 Callback<R(A0, A1, A2)> callback(const Callback<R(A0, A1, A2)> &func)
 {
     return Callback<R(A0, A1, A2)>(func);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj      Optional pointer to object to bind to function
  *  @param method   Member function to attach
  *  @return         Callback with inferred type
  */
 template<typename T, typename U, typename R, typename A0, typename A1, typename A2>
 Callback<R(A0, A1, A2)> callback(U *obj, R(T::*method)(A0, A1, A2))
 {
     return Callback<R(A0, A1, A2)>(obj, method);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj      Optional pointer to object to bind to function
  *  @param method   Member function to attach
  *  @return         Callback with inferred type
  */
 template<typename T, typename U, typename R, typename A0, typename A1, typename A2>
 Callback<R(A0, A1, A2)> callback(const U *obj, R(T::*method)(A0, A1, A2) const)
 {
     return Callback<R(A0, A1, A2)>(obj, method);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj      Optional pointer to object to bind to function
  *  @param method   Member function to attach
  *  @return         Callback with inferred type
  */
 template<typename T, typename U, typename R, typename A0, typename A1, typename A2>
 Callback<R(A0, A1, A2)> callback(volatile U *obj, R(T::*method)(A0, A1, A2) volatile)
 {
     return Callback<R(A0, A1, A2)>(obj, method);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj      Optional pointer to object to bind to function
  *  @param method   Member function to attach
  *  @return         Callback with inferred type
  */
 template<typename T, typename U, typename R, typename A0, typename A1, typename A2>
 Callback<R(A0, A1, A2)> callback(const volatile U *obj, R(T::*method)(A0, A1, A2) const volatile)
 {
     return Callback<R(A0, A1, A2)>(obj, method);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @param arg      Pointer argument to function
  *  @return         Callback with inferred type
  */
 template <typename T, typename U, typename R, typename A0, typename A1, typename A2>
 Callback<R(A0, A1, A2)> callback(R(*func)(T *, A0, A1, A2), U *arg)
 {
     return Callback<R(A0, A1, A2)>(func, arg);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @param arg      Pointer argument to function
  *  @return         Callback with inferred type
  */
 template <typename T, typename U, typename R, typename A0, typename A1, typename A2>
 Callback<R(A0, A1, A2)> callback(R(*func)(const T *, A0, A1, A2), const U *arg)
 {
     return Callback<R(A0, A1, A2)>(func, arg);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @param arg      Pointer argument to function
  *  @return         Callback with inferred type
  */
 template <typename T, typename U, typename R, typename A0, typename A1, typename A2>
 Callback<R(A0, A1, A2)> callback(R(*func)(volatile T *, A0, A1, A2), volatile U *arg)
 {
     return Callback<R(A0, A1, A2)>(func, arg);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @param arg      Pointer argument to function
  *  @return         Callback with inferred type
  */
 template <typename T, typename U, typename R, typename A0, typename A1, typename A2>
 Callback<R(A0, A1, A2)> callback(R(*func)(const volatile T *, A0, A1, A2), const volatile U *arg)
 {
     return Callback<R(A0, A1, A2)>(func, arg);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj  Optional pointer to object to bind to function
  *  @param func Static function to attach
  *  @return     Callback with inferred type
  *  @deprecated
  *      Arguments to callback have been reordered to callback(func, arg)
  */
 template <typename T, typename U, typename R, typename A0, typename A1, typename A2>
 MBED_DEPRECATED_SINCE("mbed-os-5.1",
                       "Arguments to callback have been reordered to callback(func, arg)")
 Callback<R(A0, A1, A2)> callback(U *obj, R(*func)(T *, A0, A1, A2))
 {
     return Callback<R(A0, A1, A2)>(func, obj);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj  Optional pointer to object to bind to function
  *  @param func Static function to attach
  *  @return     Callback with inferred type
  *  @deprecated
  *      Arguments to callback have been reordered to callback(func, arg)
  */
 template <typename T, typename U, typename R, typename A0, typename A1, typename A2>
 MBED_DEPRECATED_SINCE("mbed-os-5.1",
                       "Arguments to callback have been reordered to callback(func, arg)")
 Callback<R(A0, A1, A2)> callback(const U *obj, R(*func)(const T *, A0, A1, A2))
 {
     return Callback<R(A0, A1, A2)>(func, obj);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj  Optional pointer to object to bind to function
  *  @param func Static function to attach
  *  @return     Callback with inferred type
  *  @deprecated
  *      Arguments to callback have been reordered to callback(func, arg)
  */
 template <typename T, typename U, typename R, typename A0, typename A1, typename A2>
 MBED_DEPRECATED_SINCE("mbed-os-5.1",
                       "Arguments to callback have been reordered to callback(func, arg)")
 Callback<R(A0, A1, A2)> callback(volatile U *obj, R(*func)(volatile T *, A0, A1, A2))
 {
     return Callback<R(A0, A1, A2)>(func, obj);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj  Optional pointer to object to bind to function
  *  @param func Static function to attach
  *  @return     Callback with inferred type
  *  @deprecated
  *      Arguments to callback have been reordered to callback(func, arg)
  */
 template <typename T, typename U, typename R, typename A0, typename A1, typename A2>
 MBED_DEPRECATED_SINCE("mbed-os-5.1",
                       "Arguments to callback have been reordered to callback(func, arg)")
 Callback<R(A0, A1, A2)> callback(const volatile U *obj, R(*func)(const volatile T *, A0, A1, A2))
 {
     return Callback<R(A0, A1, A2)>(func, obj);
 }
 
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @return         Callback with inferred type
  */
 template <typename R, typename A0, typename A1, typename A2, typename A3>
 Callback<R(A0, A1, A2, A3)> callback(R(*func)(A0, A1, A2, A3) = 0)
 {
     return Callback<R(A0, A1, A2, A3)>(func);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @return         Callback with inferred type
  */
 template <typename R, typename A0, typename A1, typename A2, typename A3>
 Callback<R(A0, A1, A2, A3)> callback(const Callback<R(A0, A1, A2, A3)> &func)
 {
     return Callback<R(A0, A1, A2, A3)>(func);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj      Optional pointer to object to bind to function
  *  @param method   Member function to attach
  *  @return         Callback with inferred type
  */
 template<typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3>
 Callback<R(A0, A1, A2, A3)> callback(U *obj, R(T::*method)(A0, A1, A2, A3))
 {
     return Callback<R(A0, A1, A2, A3)>(obj, method);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj      Optional pointer to object to bind to function
  *  @param method   Member function to attach
  *  @return         Callback with inferred type
  */
 template<typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3>
 Callback<R(A0, A1, A2, A3)> callback(const U *obj, R(T::*method)(A0, A1, A2, A3) const)
 {
     return Callback<R(A0, A1, A2, A3)>(obj, method);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj      Optional pointer to object to bind to function
  *  @param method   Member function to attach
  *  @return         Callback with inferred type
  */
 template<typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3>
 Callback<R(A0, A1, A2, A3)> callback(volatile U *obj, R(T::*method)(A0, A1, A2, A3) volatile)
 {
     return Callback<R(A0, A1, A2, A3)>(obj, method);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj      Optional pointer to object to bind to function
  *  @param method   Member function to attach
  *  @return         Callback with inferred type
  */
 template<typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3>
 Callback<R(A0, A1, A2, A3)> callback(const volatile U *obj, R(T::*method)(A0, A1, A2, A3) const volatile)
 {
     return Callback<R(A0, A1, A2, A3)>(obj, method);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @param arg      Pointer argument to function
  *  @return         Callback with inferred type
  */
 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3>
 Callback<R(A0, A1, A2, A3)> callback(R(*func)(T *, A0, A1, A2, A3), U *arg)
 {
     return Callback<R(A0, A1, A2, A3)>(func, arg);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @param arg      Pointer argument to function
  *  @return         Callback with inferred type
  */
 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3>
 Callback<R(A0, A1, A2, A3)> callback(R(*func)(const T *, A0, A1, A2, A3), const U *arg)
 {
     return Callback<R(A0, A1, A2, A3)>(func, arg);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @param arg      Pointer argument to function
  *  @return         Callback with inferred type
  */
 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3>
 Callback<R(A0, A1, A2, A3)> callback(R(*func)(volatile T *, A0, A1, A2, A3), volatile U *arg)
 {
     return Callback<R(A0, A1, A2, A3)>(func, arg);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @param arg      Pointer argument to function
  *  @return         Callback with inferred type
  */
 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3>
 Callback<R(A0, A1, A2, A3)> callback(R(*func)(const volatile T *, A0, A1, A2, A3), const volatile U *arg)
 {
     return Callback<R(A0, A1, A2, A3)>(func, arg);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj  Optional pointer to object to bind to function
  *  @param func Static function to attach
  *  @return     Callback with inferred type
  *  @deprecated
  *      Arguments to callback have been reordered to callback(func, arg)
  */
 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3>
 MBED_DEPRECATED_SINCE("mbed-os-5.1",
                       "Arguments to callback have been reordered to callback(func, arg)")
 Callback<R(A0, A1, A2, A3)> callback(U *obj, R(*func)(T *, A0, A1, A2, A3))
 {
     return Callback<R(A0, A1, A2, A3)>(func, obj);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj  Optional pointer to object to bind to function
  *  @param func Static function to attach
  *  @return     Callback with inferred type
  *  @deprecated
  *      Arguments to callback have been reordered to callback(func, arg)
  */
 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3>
 MBED_DEPRECATED_SINCE("mbed-os-5.1",
                       "Arguments to callback have been reordered to callback(func, arg)")
 Callback<R(A0, A1, A2, A3)> callback(const U *obj, R(*func)(const T *, A0, A1, A2, A3))
 {
     return Callback<R(A0, A1, A2, A3)>(func, obj);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj  Optional pointer to object to bind to function
  *  @param func Static function to attach
  *  @return     Callback with inferred type
  *  @deprecated
  *      Arguments to callback have been reordered to callback(func, arg)
  */
 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3>
 MBED_DEPRECATED_SINCE("mbed-os-5.1",
                       "Arguments to callback have been reordered to callback(func, arg)")
 Callback<R(A0, A1, A2, A3)> callback(volatile U *obj, R(*func)(volatile T *, A0, A1, A2, A3))
 {
     return Callback<R(A0, A1, A2, A3)>(func, obj);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj  Optional pointer to object to bind to function
  *  @param func Static function to attach
  *  @return     Callback with inferred type
  *  @deprecated
  *      Arguments to callback have been reordered to callback(func, arg)
  */
 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3>
 MBED_DEPRECATED_SINCE("mbed-os-5.1",
                       "Arguments to callback have been reordered to callback(func, arg)")
 Callback<R(A0, A1, A2, A3)> callback(const volatile U *obj, R(*func)(const volatile T *, A0, A1, A2, A3))
 {
     return Callback<R(A0, A1, A2, A3)>(func, obj);
 }
 
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @return         Callback with inferred type
  */
 template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
 Callback<R(A0, A1, A2, A3, A4)> callback(R(*func)(A0, A1, A2, A3, A4) = 0)
 {
     return Callback<R(A0, A1, A2, A3, A4)>(func);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @return         Callback with inferred type
  */
 template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
 Callback<R(A0, A1, A2, A3, A4)> callback(const Callback<R(A0, A1, A2, A3, A4)> &func)
 {
     return Callback<R(A0, A1, A2, A3, A4)>(func);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj      Optional pointer to object to bind to function
  *  @param method   Member function to attach
  *  @return         Callback with inferred type
  */
 template<typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
 Callback<R(A0, A1, A2, A3, A4)> callback(U *obj, R(T::*method)(A0, A1, A2, A3, A4))
 {
     return Callback<R(A0, A1, A2, A3, A4)>(obj, method);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj      Optional pointer to object to bind to function
  *  @param method   Member function to attach
  *  @return         Callback with inferred type
  */
 template<typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
 Callback<R(A0, A1, A2, A3, A4)> callback(const U *obj, R(T::*method)(A0, A1, A2, A3, A4) const)
 {
     return Callback<R(A0, A1, A2, A3, A4)>(obj, method);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj      Optional pointer to object to bind to function
  *  @param method   Member function to attach
  *  @return         Callback with inferred type
  */
 template<typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
 Callback<R(A0, A1, A2, A3, A4)> callback(volatile U *obj, R(T::*method)(A0, A1, A2, A3, A4) volatile)
 {
     return Callback<R(A0, A1, A2, A3, A4)>(obj, method);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj      Optional pointer to object to bind to function
  *  @param method   Member function to attach
  *  @return         Callback with inferred type
  */
 template<typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
 Callback<R(A0, A1, A2, A3, A4)> callback(const volatile U *obj, R(T::*method)(A0, A1, A2, A3, A4) const volatile)
 {
     return Callback<R(A0, A1, A2, A3, A4)>(obj, method);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @param arg      Pointer argument to function
  *  @return         Callback with inferred type
  */
 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
 Callback<R(A0, A1, A2, A3, A4)> callback(R(*func)(T *, A0, A1, A2, A3, A4), U *arg)
 {
     return Callback<R(A0, A1, A2, A3, A4)>(func, arg);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @param arg      Pointer argument to function
  *  @return         Callback with inferred type
  */
 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
 Callback<R(A0, A1, A2, A3, A4)> callback(R(*func)(const T *, A0, A1, A2, A3, A4), const U *arg)
 {
     return Callback<R(A0, A1, A2, A3, A4)>(func, arg);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @param arg      Pointer argument to function
  *  @return         Callback with inferred type
  */
 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
 Callback<R(A0, A1, A2, A3, A4)> callback(R(*func)(volatile T *, A0, A1, A2, A3, A4), volatile U *arg)
 {
     return Callback<R(A0, A1, A2, A3, A4)>(func, arg);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param func     Static function to attach
  *  @param arg      Pointer argument to function
  *  @return         Callback with inferred type
  */
 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
 Callback<R(A0, A1, A2, A3, A4)> callback(R(*func)(const volatile T *, A0, A1, A2, A3, A4), const volatile U *arg)
 {
     return Callback<R(A0, A1, A2, A3, A4)>(func, arg);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj  Optional pointer to object to bind to function
  *  @param func Static function to attach
  *  @return     Callback with inferred type
  *  @deprecated
  *      Arguments to callback have been reordered to callback(func, arg)
  */
 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
 MBED_DEPRECATED_SINCE("mbed-os-5.1",
                       "Arguments to callback have been reordered to callback(func, arg)")
 Callback<R(A0, A1, A2, A3, A4)> callback(U *obj, R(*func)(T *, A0, A1, A2, A3, A4))
 {
     return Callback<R(A0, A1, A2, A3, A4)>(func, obj);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj  Optional pointer to object to bind to function
  *  @param func Static function to attach
  *  @return     Callback with inferred type
  *  @deprecated
  *      Arguments to callback have been reordered to callback(func, arg)
  */
 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
 MBED_DEPRECATED_SINCE("mbed-os-5.1",
                       "Arguments to callback have been reordered to callback(func, arg)")
 Callback<R(A0, A1, A2, A3, A4)> callback(const U *obj, R(*func)(const T *, A0, A1, A2, A3, A4))
 {
     return Callback<R(A0, A1, A2, A3, A4)>(func, obj);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj  Optional pointer to object to bind to function
  *  @param func Static function to attach
  *  @return     Callback with inferred type
  *  @deprecated
  *      Arguments to callback have been reordered to callback(func, arg)
  */
 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
 MBED_DEPRECATED_SINCE("mbed-os-5.1",
                       "Arguments to callback have been reordered to callback(func, arg)")
 Callback<R(A0, A1, A2, A3, A4)> callback(volatile U *obj, R(*func)(volatile T *, A0, A1, A2, A3, A4))
 {
     return Callback<R(A0, A1, A2, A3, A4)>(func, obj);
 }
 
 /** Create a callback class with type inferred from the arguments
  *
  *  @param obj  Optional pointer to object to bind to function
  *  @param func Static function to attach
  *  @return     Callback with inferred type
  *  @deprecated
  *      Arguments to callback have been reordered to callback(func, arg)
  */
 template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
 MBED_DEPRECATED_SINCE("mbed-os-5.1",
                       "Arguments to callback have been reordered to callback(func, arg)")
 Callback<R(A0, A1, A2, A3, A4)> callback(const volatile U *obj, R(*func)(const volatile T *, A0, A1, A2, A3, A4))
 {
     return Callback<R(A0, A1, A2, A3, A4)>(func, obj);
 }
 
 /**@}*/
 
 /**@}*/
 
 } // namespace mbed
 
 #endif
Important Information for this Arm website
