mbed-dev - Forked.

Users » Dollyparton » Code » mbed-dev

Forked.

platform/Callback.h@167:e84263d55307, 2017-06-21 (annotated)

Committer:: AnnaBridge
Date:: Wed Jun 21 17:46:44 2017 +0100
Revision:: 167:e84263d55307
Parent:: 160:d5399cc887bb

This updates the lib to the mbed lib v 145

Who changed what in which revision?

User	Revision	Line number	New contents of line
<>	149:156823d33999	1	/* mbed Microcontroller Library
<>	149:156823d33999	2	* Copyright (c) 2006-2015 ARM Limited
<>	149:156823d33999	3	*
<>	149:156823d33999	4	* Licensed under the Apache License, Version 2.0 (the "License");
<>	149:156823d33999	5	* you may not use this file except in compliance with the License.
<>	149:156823d33999	6	* You may obtain a copy of the License at
<>	149:156823d33999	7	*
<>	149:156823d33999	8	* http://www.apache.org/licenses/LICENSE-2.0
<>	149:156823d33999	9	*
<>	149:156823d33999	10	* Unless required by applicable law or agreed to in writing, software
<>	149:156823d33999	11	* distributed under the License is distributed on an "AS IS" BASIS,
<>	149:156823d33999	12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
<>	149:156823d33999	13	* See the License for the specific language governing permissions and
<>	149:156823d33999	14	* limitations under the License.
<>	149:156823d33999	15	*/
<>	149:156823d33999	16	#ifndef MBED_CALLBACK_H
<>	149:156823d33999	17	#define MBED_CALLBACK_H
<>	149:156823d33999	18
<>	149:156823d33999	19	#include <string.h>
<>	149:156823d33999	20	#include <stdint.h>
<>	149:156823d33999	21	#include <new>
<>	149:156823d33999	22	#include "platform/mbed_assert.h"
<>	160:d5399cc887bb	23	#include "platform/mbed_toolchain.h"
<>	149:156823d33999	24
<>	149:156823d33999	25	namespace mbed {
<>	149:156823d33999	26	/** \addtogroup platform */
<>	149:156823d33999	27
<>	149:156823d33999	28
<>	149:156823d33999	29	/** Callback class based on template specialization
<>	149:156823d33999	30	*
AnnaBridge	167:e84263d55307	31	* @note Synchronization level: Not protected
AnnaBridge	167:e84263d55307	32	* @ingroup platform
<>	149:156823d33999	33	*/
<>	149:156823d33999	34	template <typename F>
<>	149:156823d33999	35	class Callback;
<>	149:156823d33999	36
<>	149:156823d33999	37	// Internal sfinae declarations
<>	149:156823d33999	38	//
<>	149:156823d33999	39	// These are used to eliminate overloads based on type attributes
<>	149:156823d33999	40	// 1. Does a function object have a call operator
<>	149:156823d33999	41	// 2. Does a function object fit in the available storage
<>	149:156823d33999	42	//
<>	149:156823d33999	43	// These eliminations are handled cleanly by the compiler and avoid
<>	149:156823d33999	44	// massive and misleading error messages when confronted with an
<>	149:156823d33999	45	// invalid type (or worse, runtime failures)
<>	149:156823d33999	46	namespace detail {
<>	149:156823d33999	47	struct nil {};
<>	149:156823d33999	48
<>	149:156823d33999	49	template <bool B, typename R = nil>
<>	149:156823d33999	50	struct enable_if { typedef R type; };
<>	149:156823d33999	51
<>	149:156823d33999	52	template <typename R>
<>	149:156823d33999	53	struct enable_if<false, R> {};
<>	149:156823d33999	54
<>	149:156823d33999	55	template <typename M, M>
<>	149:156823d33999	56	struct is_type {
<>	149:156823d33999	57	static const bool value = true;
<>	149:156823d33999	58	};
<>	149:156823d33999	59	}
<>	149:156823d33999	60
AnnaBridge	167:e84263d55307	61	#define MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, M) \
AnnaBridge	167:e84263d55307	62	typename detail::enable_if< \
AnnaBridge	167:e84263d55307	63	detail::is_type<M, &F::operator()>::value && \
AnnaBridge	167:e84263d55307	64	sizeof(F) <= sizeof(uintptr_t) \
AnnaBridge	167:e84263d55307	65	>::type = detail::nil()
AnnaBridge	167:e84263d55307	66
<>	149:156823d33999	67	/** Callback class based on template specialization
<>	149:156823d33999	68	*
AnnaBridge	167:e84263d55307	69	* @note Synchronization level: Not protected
AnnaBridge	167:e84263d55307	70	* @ingroup platform
<>	149:156823d33999	71	*/
<>	149:156823d33999	72	template <typename R>
<>	149:156823d33999	73	class Callback<R()> {
<>	149:156823d33999	74	public:
<>	149:156823d33999	75	/** Create a Callback with a static function
<>	149:156823d33999	76	* @param func Static function to attach
<>	149:156823d33999	77	*/
<>	149:156823d33999	78	Callback(R (*func)() = 0) {
<>	149:156823d33999	79	if (!func) {
<>	149:156823d33999	80	_ops = 0;
<>	149:156823d33999	81	} else {
<>	149:156823d33999	82	generate(func);
<>	149:156823d33999	83	}
<>	149:156823d33999	84	}
<>	149:156823d33999	85
<>	149:156823d33999	86	/** Attach a Callback
<>	149:156823d33999	87	* @param func The Callback to attach
<>	149:156823d33999	88	*/
<>	149:156823d33999	89	Callback(const Callback<R()> &func) {
<>	149:156823d33999	90	if (func._ops) {
<>	149:156823d33999	91	func._ops->move(this, &func);
<>	149:156823d33999	92	}
<>	149:156823d33999	93	_ops = func._ops;
<>	149:156823d33999	94	}
<>	149:156823d33999	95
<>	149:156823d33999	96	/** Create a Callback with a member function
<>	149:156823d33999	97	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	98	* @param method Member function to attach
<>	149:156823d33999	99	*/
<>	151:5eaa88a5bcc7	100	template<typename T, typename U>
<>	151:5eaa88a5bcc7	101	Callback(U obj, R (T::method)()) {
<>	149:156823d33999	102	generate(method_context<T, R (T::*)()>(obj, method));
<>	149:156823d33999	103	}
<>	149:156823d33999	104
<>	149:156823d33999	105	/** Create a Callback with a member function
<>	149:156823d33999	106	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	107	* @param method Member function to attach
<>	149:156823d33999	108	*/
<>	151:5eaa88a5bcc7	109	template<typename T, typename U>
<>	151:5eaa88a5bcc7	110	Callback(const U obj, R (T::method)() const) {
<>	149:156823d33999	111	generate(method_context<const T, R (T::*)() const>(obj, method));
<>	149:156823d33999	112	}
<>	149:156823d33999	113
<>	149:156823d33999	114	/** Create a Callback with a member function
<>	149:156823d33999	115	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	116	* @param method Member function to attach
<>	149:156823d33999	117	*/
<>	151:5eaa88a5bcc7	118	template<typename T, typename U>
<>	151:5eaa88a5bcc7	119	Callback(volatile U obj, R (T::method)() volatile) {
<>	149:156823d33999	120	generate(method_context<volatile T, R (T::*)() volatile>(obj, method));
<>	149:156823d33999	121	}
<>	149:156823d33999	122
<>	149:156823d33999	123	/** Create a Callback with a member function
<>	149:156823d33999	124	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	125	* @param method Member function to attach
<>	149:156823d33999	126	*/
<>	151:5eaa88a5bcc7	127	template<typename T, typename U>
<>	151:5eaa88a5bcc7	128	Callback(const volatile U obj, R (T::method)() const volatile) {
<>	149:156823d33999	129	generate(method_context<const volatile T, R (T::*)() const volatile>(obj, method));
<>	149:156823d33999	130	}
<>	149:156823d33999	131
<>	149:156823d33999	132	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	133	* @param func Static function to attach
<>	149:156823d33999	134	* @param arg Pointer argument to function
<>	149:156823d33999	135	*/
<>	151:5eaa88a5bcc7	136	template<typename T, typename U>
<>	151:5eaa88a5bcc7	137	Callback(R (func)(T), U *arg) {
<>	149:156823d33999	138	generate(function_context<R ()(T), T>(func, arg));
<>	149:156823d33999	139	}
<>	149:156823d33999	140
<>	149:156823d33999	141	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	142	* @param func Static function to attach
<>	149:156823d33999	143	* @param arg Pointer argument to function
<>	149:156823d33999	144	*/
<>	151:5eaa88a5bcc7	145	template<typename T, typename U>
<>	151:5eaa88a5bcc7	146	Callback(R (func)(const T), const U *arg) {
<>	149:156823d33999	147	generate(function_context<R ()(const T), const T>(func, arg));
<>	149:156823d33999	148	}
<>	149:156823d33999	149
<>	149:156823d33999	150	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	151	* @param func Static function to attach
<>	149:156823d33999	152	* @param arg Pointer argument to function
<>	149:156823d33999	153	*/
<>	151:5eaa88a5bcc7	154	template<typename T, typename U>
<>	151:5eaa88a5bcc7	155	Callback(R (func)(volatile T), volatile U *arg) {
<>	149:156823d33999	156	generate(function_context<R ()(volatile T), volatile T>(func, arg));
<>	149:156823d33999	157	}
<>	149:156823d33999	158
<>	149:156823d33999	159	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	160	* @param func Static function to attach
<>	149:156823d33999	161	* @param arg Pointer argument to function
<>	149:156823d33999	162	*/
<>	151:5eaa88a5bcc7	163	template<typename T, typename U>
<>	151:5eaa88a5bcc7	164	Callback(R (func)(const volatile T), const volatile U *arg) {
<>	149:156823d33999	165	generate(function_context<R ()(const volatile T), const volatile T>(func, arg));
<>	149:156823d33999	166	}
<>	149:156823d33999	167
<>	149:156823d33999	168	/** Create a Callback with a function object
AnnaBridge	167:e84263d55307	169	* @param f Function object to attach
<>	149:156823d33999	170	* @note The function object is limited to a single word of storage
<>	149:156823d33999	171	*/
<>	149:156823d33999	172	template <typename F>
AnnaBridge	167:e84263d55307	173	Callback(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)())) {
<>	149:156823d33999	174	generate(f);
<>	149:156823d33999	175	}
<>	149:156823d33999	176
<>	149:156823d33999	177	/** Create a Callback with a function object
AnnaBridge	167:e84263d55307	178	* @param f Function object to attach
<>	149:156823d33999	179	* @note The function object is limited to a single word of storage
<>	149:156823d33999	180	*/
<>	149:156823d33999	181	template <typename F>
AnnaBridge	167:e84263d55307	182	Callback(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)() const)) {
<>	149:156823d33999	183	generate(f);
<>	149:156823d33999	184	}
<>	149:156823d33999	185
<>	149:156823d33999	186	/** Create a Callback with a function object
AnnaBridge	167:e84263d55307	187	* @param f Function object to attach
<>	149:156823d33999	188	* @note The function object is limited to a single word of storage
<>	149:156823d33999	189	*/
<>	149:156823d33999	190	template <typename F>
AnnaBridge	167:e84263d55307	191	Callback(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)() volatile)) {
<>	149:156823d33999	192	generate(f);
<>	149:156823d33999	193	}
<>	149:156823d33999	194
<>	149:156823d33999	195	/** Create a Callback with a function object
AnnaBridge	167:e84263d55307	196	* @param f Function object to attach
<>	149:156823d33999	197	* @note The function object is limited to a single word of storage
<>	149:156823d33999	198	*/
<>	149:156823d33999	199	template <typename F>
AnnaBridge	167:e84263d55307	200	Callback(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)() const volatile)) {
<>	149:156823d33999	201	generate(f);
<>	149:156823d33999	202	}
<>	149:156823d33999	203
<>	149:156823d33999	204	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	205	* @param obj Pointer to object to bind to function
<>	149:156823d33999	206	* @param func Static function to attach
<>	149:156823d33999	207	* @deprecated
<>	149:156823d33999	208	* Arguments to callback have been reordered to Callback(func, arg)
<>	149:156823d33999	209	*/
<>	151:5eaa88a5bcc7	210	template<typename T, typename U>
<>	149:156823d33999	211	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	212	"Arguments to callback have been reordered to Callback(func, arg)")
<>	151:5eaa88a5bcc7	213	Callback(U obj, R (func)(T*)) {
<>	149:156823d33999	214	new (this) Callback(func, obj);
<>	149:156823d33999	215	}
<>	149:156823d33999	216
<>	149:156823d33999	217	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	218	* @param obj Pointer to object to bind to function
<>	149:156823d33999	219	* @param func Static function to attach
<>	149:156823d33999	220	* @deprecated
<>	149:156823d33999	221	* Arguments to callback have been reordered to Callback(func, arg)
<>	149:156823d33999	222	*/
<>	151:5eaa88a5bcc7	223	template<typename T, typename U>
<>	149:156823d33999	224	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	225	"Arguments to callback have been reordered to Callback(func, arg)")
<>	151:5eaa88a5bcc7	226	Callback(const U obj, R (func)(const T*)) {
<>	149:156823d33999	227	new (this) Callback(func, obj);
<>	149:156823d33999	228	}
<>	149:156823d33999	229
<>	149:156823d33999	230	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	231	* @param obj Pointer to object to bind to function
<>	149:156823d33999	232	* @param func Static function to attach
<>	149:156823d33999	233	* @deprecated
<>	149:156823d33999	234	* Arguments to callback have been reordered to Callback(func, arg)
<>	149:156823d33999	235	*/
<>	151:5eaa88a5bcc7	236	template<typename T, typename U>
<>	149:156823d33999	237	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	238	"Arguments to callback have been reordered to Callback(func, arg)")
<>	151:5eaa88a5bcc7	239	Callback(volatile U obj, R (func)(volatile T*)) {
<>	149:156823d33999	240	new (this) Callback(func, obj);
<>	149:156823d33999	241	}
<>	149:156823d33999	242
<>	149:156823d33999	243	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	244	* @param obj Pointer to object to bind to function
<>	149:156823d33999	245	* @param func Static function to attach
<>	149:156823d33999	246	* @deprecated
<>	149:156823d33999	247	* Arguments to callback have been reordered to Callback(func, arg)
<>	149:156823d33999	248	*/
<>	151:5eaa88a5bcc7	249	template<typename T, typename U>
<>	149:156823d33999	250	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	251	"Arguments to callback have been reordered to Callback(func, arg)")
<>	151:5eaa88a5bcc7	252	Callback(const volatile U obj, R (func)(const volatile T*)) {
<>	149:156823d33999	253	new (this) Callback(func, obj);
<>	149:156823d33999	254	}
<>	149:156823d33999	255
<>	149:156823d33999	256	/** Destroy a callback
<>	149:156823d33999	257	*/
<>	149:156823d33999	258	~Callback() {
<>	149:156823d33999	259	if (_ops) {
<>	149:156823d33999	260	_ops->dtor(this);
<>	149:156823d33999	261	}
<>	149:156823d33999	262	}
<>	149:156823d33999	263
<>	149:156823d33999	264	/** Attach a static function
<>	149:156823d33999	265	* @param func Static function to attach
<>	160:d5399cc887bb	266	* @deprecated
<>	160:d5399cc887bb	267	* Replaced by simple assignment 'Callback cb = func'
<>	160:d5399cc887bb	268	*/
<>	160:d5399cc887bb	269	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	270	"Replaced by simple assignment 'Callback cb = func")
<>	149:156823d33999	271	void attach(R (*func)()) {
<>	149:156823d33999	272	this->~Callback();
<>	149:156823d33999	273	new (this) Callback(func);
<>	149:156823d33999	274	}
<>	149:156823d33999	275
<>	149:156823d33999	276	/** Attach a Callback
<>	149:156823d33999	277	* @param func The Callback to attach
<>	160:d5399cc887bb	278	* @deprecated
<>	160:d5399cc887bb	279	* Replaced by simple assignment 'Callback cb = func'
<>	160:d5399cc887bb	280	*/
<>	160:d5399cc887bb	281	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	282	"Replaced by simple assignment 'Callback cb = func")
<>	149:156823d33999	283	void attach(const Callback<R()> &func) {
<>	149:156823d33999	284	this->~Callback();
<>	149:156823d33999	285	new (this) Callback(func);
<>	149:156823d33999	286	}
<>	149:156823d33999	287
<>	149:156823d33999	288	/** Attach a member function
<>	149:156823d33999	289	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	290	* @param method Member function to attach
<>	160:d5399cc887bb	291	* @deprecated
<>	160:d5399cc887bb	292	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	293	*/
<>	151:5eaa88a5bcc7	294	template<typename T, typename U>
<>	160:d5399cc887bb	295	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	296	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	297	void attach(U obj, R (T::method)()) {
<>	149:156823d33999	298	this->~Callback();
<>	149:156823d33999	299	new (this) Callback(obj, method);
<>	149:156823d33999	300	}
<>	149:156823d33999	301
<>	149:156823d33999	302	/** Attach a member function
<>	149:156823d33999	303	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	304	* @param method Member function to attach
<>	160:d5399cc887bb	305	* @deprecated
<>	160:d5399cc887bb	306	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	307	*/
<>	151:5eaa88a5bcc7	308	template<typename T, typename U>
<>	160:d5399cc887bb	309	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	310	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	311	void attach(const U obj, R (T::method)() const) {
<>	149:156823d33999	312	this->~Callback();
<>	149:156823d33999	313	new (this) Callback(obj, method);
<>	149:156823d33999	314	}
<>	149:156823d33999	315
<>	149:156823d33999	316	/** Attach a member function
<>	149:156823d33999	317	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	318	* @param method Member function to attach
<>	160:d5399cc887bb	319	* @deprecated
<>	160:d5399cc887bb	320	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	321	*/
<>	151:5eaa88a5bcc7	322	template<typename T, typename U>
<>	160:d5399cc887bb	323	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	324	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	325	void attach(volatile U obj, R (T::method)() volatile) {
<>	149:156823d33999	326	this->~Callback();
<>	149:156823d33999	327	new (this) Callback(obj, method);
<>	149:156823d33999	328	}
<>	149:156823d33999	329
<>	149:156823d33999	330	/** Attach a member function
<>	149:156823d33999	331	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	332	* @param method Member function to attach
<>	160:d5399cc887bb	333	* @deprecated
<>	160:d5399cc887bb	334	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	335	*/
<>	151:5eaa88a5bcc7	336	template<typename T, typename U>
<>	160:d5399cc887bb	337	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	338	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	339	void attach(const volatile U obj, R (T::method)() const volatile) {
<>	149:156823d33999	340	this->~Callback();
<>	149:156823d33999	341	new (this) Callback(obj, method);
<>	149:156823d33999	342	}
<>	149:156823d33999	343
<>	149:156823d33999	344	/** Attach a static function with a bound pointer
<>	149:156823d33999	345	* @param func Static function to attach
<>	149:156823d33999	346	* @param arg Pointer argument to function
<>	160:d5399cc887bb	347	* @deprecated
<>	160:d5399cc887bb	348	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	349	*/
<>	151:5eaa88a5bcc7	350	template <typename T, typename U>
<>	160:d5399cc887bb	351	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	352	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	353	void attach(R (func)(T), U *arg) {
<>	149:156823d33999	354	this->~Callback();
<>	149:156823d33999	355	new (this) Callback(func, arg);
<>	149:156823d33999	356	}
<>	149:156823d33999	357
<>	149:156823d33999	358	/** Attach a static function with a bound pointer
<>	149:156823d33999	359	* @param func Static function to attach
<>	149:156823d33999	360	* @param arg Pointer argument to function
<>	160:d5399cc887bb	361	* @deprecated
<>	160:d5399cc887bb	362	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	363	*/
<>	151:5eaa88a5bcc7	364	template <typename T, typename U>
<>	160:d5399cc887bb	365	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	366	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	367	void attach(R (func)(const T), const U *arg) {
<>	149:156823d33999	368	this->~Callback();
<>	149:156823d33999	369	new (this) Callback(func, arg);
<>	149:156823d33999	370	}
<>	149:156823d33999	371
<>	149:156823d33999	372	/** Attach a static function with a bound pointer
<>	149:156823d33999	373	* @param func Static function to attach
<>	149:156823d33999	374	* @param arg Pointer argument to function
<>	160:d5399cc887bb	375	* @deprecated
<>	160:d5399cc887bb	376	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	377	*/
<>	151:5eaa88a5bcc7	378	template <typename T, typename U>
<>	160:d5399cc887bb	379	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	380	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	381	void attach(R (func)(volatile T), volatile U *arg) {
<>	149:156823d33999	382	this->~Callback();
<>	149:156823d33999	383	new (this) Callback(func, arg);
<>	149:156823d33999	384	}
<>	149:156823d33999	385
<>	149:156823d33999	386	/** Attach a static function with a bound pointer
<>	149:156823d33999	387	* @param func Static function to attach
<>	149:156823d33999	388	* @param arg Pointer argument to function
<>	160:d5399cc887bb	389	* @deprecated
<>	160:d5399cc887bb	390	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	391	*/
<>	151:5eaa88a5bcc7	392	template <typename T, typename U>
<>	160:d5399cc887bb	393	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	394	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	395	void attach(R (func)(const volatile T), const volatile U *arg) {
<>	149:156823d33999	396	this->~Callback();
<>	149:156823d33999	397	new (this) Callback(func, arg);
<>	149:156823d33999	398	}
<>	149:156823d33999	399
<>	149:156823d33999	400	/** Attach a function object
AnnaBridge	167:e84263d55307	401	* @param f Function object to attach
<>	149:156823d33999	402	* @note The function object is limited to a single word of storage
<>	160:d5399cc887bb	403	* @deprecated
<>	160:d5399cc887bb	404	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	405	*/
<>	149:156823d33999	406	template <typename F>
<>	160:d5399cc887bb	407	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	408	"Replaced by simple assignment 'Callback cb = func")
AnnaBridge	167:e84263d55307	409	void attach(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)())) {
<>	149:156823d33999	410	this->~Callback();
<>	149:156823d33999	411	new (this) Callback(f);
<>	149:156823d33999	412	}
<>	149:156823d33999	413
<>	149:156823d33999	414	/** Attach a function object
AnnaBridge	167:e84263d55307	415	* @param f Function object to attach
<>	149:156823d33999	416	* @note The function object is limited to a single word of storage
<>	160:d5399cc887bb	417	* @deprecated
<>	160:d5399cc887bb	418	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	419	*/
<>	149:156823d33999	420	template <typename F>
<>	160:d5399cc887bb	421	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	422	"Replaced by simple assignment 'Callback cb = func")
AnnaBridge	167:e84263d55307	423	void attach(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)() const)) {
<>	149:156823d33999	424	this->~Callback();
<>	149:156823d33999	425	new (this) Callback(f);
<>	149:156823d33999	426	}
<>	149:156823d33999	427
<>	149:156823d33999	428	/** Attach a function object
AnnaBridge	167:e84263d55307	429	* @param f Function object to attach
<>	149:156823d33999	430	* @note The function object is limited to a single word of storage
<>	160:d5399cc887bb	431	* @deprecated
<>	160:d5399cc887bb	432	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	433	*/
<>	149:156823d33999	434	template <typename F>
<>	160:d5399cc887bb	435	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	436	"Replaced by simple assignment 'Callback cb = func")
AnnaBridge	167:e84263d55307	437	void attach(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)() volatile)) {
<>	149:156823d33999	438	this->~Callback();
<>	149:156823d33999	439	new (this) Callback(f);
<>	149:156823d33999	440	}
<>	149:156823d33999	441
<>	149:156823d33999	442	/** Attach a function object
AnnaBridge	167:e84263d55307	443	* @param f Function object to attach
<>	149:156823d33999	444	* @note The function object is limited to a single word of storage
<>	160:d5399cc887bb	445	* @deprecated
<>	160:d5399cc887bb	446	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	447	*/
<>	149:156823d33999	448	template <typename F>
<>	160:d5399cc887bb	449	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	450	"Replaced by simple assignment 'Callback cb = func")
AnnaBridge	167:e84263d55307	451	void attach(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)() const volatile)) {
<>	149:156823d33999	452	this->~Callback();
<>	149:156823d33999	453	new (this) Callback(f);
<>	149:156823d33999	454	}
<>	149:156823d33999	455
<>	149:156823d33999	456	/** Attach a static function with a bound pointer
<>	149:156823d33999	457	* @param obj Pointer to object to bind to function
<>	149:156823d33999	458	* @param func Static function to attach
<>	149:156823d33999	459	* @deprecated
<>	149:156823d33999	460	* Arguments to callback have been reordered to attach(func, arg)
<>	149:156823d33999	461	*/
<>	151:5eaa88a5bcc7	462	template <typename T, typename U>
<>	149:156823d33999	463	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	464	"Arguments to callback have been reordered to attach(func, arg)")
<>	151:5eaa88a5bcc7	465	void attach(U obj, R (func)(T*)) {
<>	149:156823d33999	466	this->~Callback();
<>	149:156823d33999	467	new (this) Callback(func, obj);
<>	149:156823d33999	468	}
<>	149:156823d33999	469
<>	149:156823d33999	470	/** Attach a static function with a bound pointer
<>	149:156823d33999	471	* @param obj Pointer to object to bind to function
<>	149:156823d33999	472	* @param func Static function to attach
<>	149:156823d33999	473	* @deprecated
<>	149:156823d33999	474	* Arguments to callback have been reordered to attach(func, arg)
<>	149:156823d33999	475	*/
<>	151:5eaa88a5bcc7	476	template <typename T, typename U>
<>	149:156823d33999	477	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	478	"Arguments to callback have been reordered to attach(func, arg)")
<>	151:5eaa88a5bcc7	479	void attach(const U obj, R (func)(const T*)) {
<>	149:156823d33999	480	this->~Callback();
<>	149:156823d33999	481	new (this) Callback(func, obj);
<>	149:156823d33999	482	}
<>	149:156823d33999	483
<>	149:156823d33999	484	/** Attach a static function with a bound pointer
<>	149:156823d33999	485	* @param obj Pointer to object to bind to function
<>	149:156823d33999	486	* @param func Static function to attach
<>	149:156823d33999	487	* @deprecated
<>	149:156823d33999	488	* Arguments to callback have been reordered to attach(func, arg)
<>	149:156823d33999	489	*/
<>	151:5eaa88a5bcc7	490	template <typename T, typename U>
<>	149:156823d33999	491	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	492	"Arguments to callback have been reordered to attach(func, arg)")
<>	151:5eaa88a5bcc7	493	void attach(volatile U obj, R (func)(volatile T*)) {
<>	149:156823d33999	494	this->~Callback();
<>	149:156823d33999	495	new (this) Callback(func, obj);
<>	149:156823d33999	496	}
<>	149:156823d33999	497
<>	149:156823d33999	498	/** Attach a static function with a bound pointer
<>	149:156823d33999	499	* @param obj Pointer to object to bind to function
<>	149:156823d33999	500	* @param func Static function to attach
<>	149:156823d33999	501	* @deprecated
<>	149:156823d33999	502	* Arguments to callback have been reordered to attach(func, arg)
<>	149:156823d33999	503	*/
<>	151:5eaa88a5bcc7	504	template <typename T, typename U>
<>	149:156823d33999	505	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	506	"Arguments to callback have been reordered to attach(func, arg)")
<>	151:5eaa88a5bcc7	507	void attach(const volatile U obj, R (func)(const volatile T*)) {
<>	149:156823d33999	508	this->~Callback();
<>	149:156823d33999	509	new (this) Callback(func, obj);
<>	149:156823d33999	510	}
<>	149:156823d33999	511
<>	149:156823d33999	512	/** Assign a callback
<>	149:156823d33999	513	*/
<>	149:156823d33999	514	Callback &operator=(const Callback &that) {
<>	149:156823d33999	515	if (this != &that) {
<>	149:156823d33999	516	this->~Callback();
<>	149:156823d33999	517	new (this) Callback(that);
<>	149:156823d33999	518	}
<>	149:156823d33999	519
<>	149:156823d33999	520	return *this;
<>	149:156823d33999	521	}
<>	149:156823d33999	522
<>	149:156823d33999	523	/** Call the attached function
<>	149:156823d33999	524	*/
<>	149:156823d33999	525	R call() const {
<>	149:156823d33999	526	MBED_ASSERT(_ops);
<>	149:156823d33999	527	return _ops->call(this);
<>	149:156823d33999	528	}
<>	149:156823d33999	529
<>	149:156823d33999	530	/** Call the attached function
<>	149:156823d33999	531	*/
<>	149:156823d33999	532	R operator()() const {
<>	149:156823d33999	533	return call();
<>	149:156823d33999	534	}
<>	149:156823d33999	535
<>	149:156823d33999	536	/** Test if function has been attached
<>	149:156823d33999	537	*/
<>	149:156823d33999	538	operator bool() const {
<>	149:156823d33999	539	return _ops;
<>	149:156823d33999	540	}
<>	149:156823d33999	541
<>	149:156823d33999	542	/** Test for equality
<>	149:156823d33999	543	*/
<>	149:156823d33999	544	friend bool operator==(const Callback &l, const Callback &r) {
<>	149:156823d33999	545	return memcmp(&l, &r, sizeof(Callback)) == 0;
<>	149:156823d33999	546	}
<>	149:156823d33999	547
<>	149:156823d33999	548	/** Test for inequality
<>	149:156823d33999	549	*/
<>	149:156823d33999	550	friend bool operator!=(const Callback &l, const Callback &r) {
<>	149:156823d33999	551	return !(l == r);
<>	149:156823d33999	552	}
<>	149:156823d33999	553
<>	149:156823d33999	554	/** Static thunk for passing as C-style function
<>	149:156823d33999	555	* @param func Callback to call passed as void pointer
AnnaBridge	167:e84263d55307	556	* @return the value as determined by func which is of
AnnaBridge	167:e84263d55307	557	* type and determined by the signiture of func
<>	149:156823d33999	558	*/
<>	149:156823d33999	559	static R thunk(void *func) {
<>	149:156823d33999	560	return static_cast<Callback*>(func)->call();
<>	149:156823d33999	561	}
<>	149:156823d33999	562
<>	149:156823d33999	563	private:
<>	149:156823d33999	564	// Stored as pointer to function and pointer to optional object
<>	149:156823d33999	565	// Function pointer is stored as union of possible function types
<>	149:156823d33999	566	// to garuntee proper size and alignment
<>	149:156823d33999	567	struct _class;
<>	149:156823d33999	568	union {
<>	149:156823d33999	569	void (*_staticfunc)();
<>	149:156823d33999	570	void (_boundfunc)(_class);
<>	149:156823d33999	571	void (_class::*_methodfunc)();
<>	149:156823d33999	572	} _func;
<>	149:156823d33999	573	void *_obj;
<>	149:156823d33999	574
<>	149:156823d33999	575	// Dynamically dispatched operations
<>	149:156823d33999	576	const struct ops {
<>	149:156823d33999	577	R (call)(const void);
<>	149:156823d33999	578	void (move)(void, const void*);
<>	149:156823d33999	579	void (dtor)(void);
<>	149:156823d33999	580	} *_ops;
<>	149:156823d33999	581
<>	149:156823d33999	582	// Generate operations for function object
<>	149:156823d33999	583	template <typename F>
<>	149:156823d33999	584	void generate(const F &f) {
<>	149:156823d33999	585	static const ops ops = {
<>	149:156823d33999	586	&Callback::function_call<F>,
<>	149:156823d33999	587	&Callback::function_move<F>,
<>	149:156823d33999	588	&Callback::function_dtor<F>,
<>	149:156823d33999	589	};
<>	149:156823d33999	590
<>	151:5eaa88a5bcc7	591	MBED_STATIC_ASSERT(sizeof(Callback) - sizeof(_ops) >= sizeof(F),
<>	151:5eaa88a5bcc7	592	"Type F must not exceed the size of the Callback class");
<>	149:156823d33999	593	new (this) F(f);
<>	149:156823d33999	594	_ops = &ops;
<>	149:156823d33999	595	}
<>	149:156823d33999	596
<>	149:156823d33999	597	// Function attributes
<>	149:156823d33999	598	template <typename F>
<>	149:156823d33999	599	static R function_call(const void *p) {
<>	149:156823d33999	600	return ((F)p)();
<>	149:156823d33999	601	}
<>	149:156823d33999	602
<>	149:156823d33999	603	template <typename F>
<>	149:156823d33999	604	static void function_move(void d, const void p) {
<>	149:156823d33999	605	new (d) F((F)p);
<>	149:156823d33999	606	}
<>	149:156823d33999	607
<>	149:156823d33999	608	template <typename F>
<>	149:156823d33999	609	static void function_dtor(void *p) {
<>	149:156823d33999	610	((F*)p)->~F();
<>	149:156823d33999	611	}
<>	149:156823d33999	612
<>	149:156823d33999	613	// Wrappers for functions with context
<>	149:156823d33999	614	template <typename O, typename M>
<>	149:156823d33999	615	struct method_context {
<>	149:156823d33999	616	M method;
<>	149:156823d33999	617	O *obj;
<>	149:156823d33999	618
<>	149:156823d33999	619	method_context(O *obj, M method)
<>	149:156823d33999	620	: method(method), obj(obj) {}
<>	149:156823d33999	621
<>	149:156823d33999	622	R operator()() const {
<>	149:156823d33999	623	return (obj->*method)();
<>	149:156823d33999	624	}
<>	149:156823d33999	625	};
<>	149:156823d33999	626
<>	149:156823d33999	627	template <typename F, typename A>
<>	149:156823d33999	628	struct function_context {
<>	149:156823d33999	629	F func;
<>	149:156823d33999	630	A *arg;
<>	149:156823d33999	631
<>	149:156823d33999	632	function_context(F func, A *arg)
<>	149:156823d33999	633	: func(func), arg(arg) {}
<>	149:156823d33999	634
<>	149:156823d33999	635	R operator()() const {
<>	149:156823d33999	636	return func(arg);
<>	149:156823d33999	637	}
<>	149:156823d33999	638	};
<>	149:156823d33999	639	};
<>	149:156823d33999	640
<>	149:156823d33999	641	/** Callback class based on template specialization
<>	149:156823d33999	642	*
AnnaBridge	167:e84263d55307	643	* @note Synchronization level: Not protected
AnnaBridge	167:e84263d55307	644	* @ingroup platform
<>	149:156823d33999	645	*/
<>	149:156823d33999	646	template <typename R, typename A0>
<>	149:156823d33999	647	class Callback<R(A0)> {
<>	149:156823d33999	648	public:
<>	149:156823d33999	649	/** Create a Callback with a static function
<>	149:156823d33999	650	* @param func Static function to attach
<>	149:156823d33999	651	*/
<>	149:156823d33999	652	Callback(R (*func)(A0) = 0) {
<>	149:156823d33999	653	if (!func) {
<>	149:156823d33999	654	_ops = 0;
<>	149:156823d33999	655	} else {
<>	149:156823d33999	656	generate(func);
<>	149:156823d33999	657	}
<>	149:156823d33999	658	}
<>	149:156823d33999	659
<>	149:156823d33999	660	/** Attach a Callback
<>	149:156823d33999	661	* @param func The Callback to attach
<>	149:156823d33999	662	*/
<>	149:156823d33999	663	Callback(const Callback<R(A0)> &func) {
<>	149:156823d33999	664	if (func._ops) {
<>	149:156823d33999	665	func._ops->move(this, &func);
<>	149:156823d33999	666	}
<>	149:156823d33999	667	_ops = func._ops;
<>	149:156823d33999	668	}
<>	149:156823d33999	669
<>	149:156823d33999	670	/** Create a Callback with a member function
<>	149:156823d33999	671	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	672	* @param method Member function to attach
<>	149:156823d33999	673	*/
<>	151:5eaa88a5bcc7	674	template<typename T, typename U>
<>	151:5eaa88a5bcc7	675	Callback(U obj, R (T::method)(A0)) {
<>	149:156823d33999	676	generate(method_context<T, R (T::*)(A0)>(obj, method));
<>	149:156823d33999	677	}
<>	149:156823d33999	678
<>	149:156823d33999	679	/** Create a Callback with a member function
<>	149:156823d33999	680	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	681	* @param method Member function to attach
<>	149:156823d33999	682	*/
<>	151:5eaa88a5bcc7	683	template<typename T, typename U>
<>	151:5eaa88a5bcc7	684	Callback(const U obj, R (T::method)(A0) const) {
<>	149:156823d33999	685	generate(method_context<const T, R (T::*)(A0) const>(obj, method));
<>	149:156823d33999	686	}
<>	149:156823d33999	687
<>	149:156823d33999	688	/** Create a Callback with a member function
<>	149:156823d33999	689	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	690	* @param method Member function to attach
<>	149:156823d33999	691	*/
<>	151:5eaa88a5bcc7	692	template<typename T, typename U>
<>	151:5eaa88a5bcc7	693	Callback(volatile U obj, R (T::method)(A0) volatile) {
<>	149:156823d33999	694	generate(method_context<volatile T, R (T::*)(A0) volatile>(obj, method));
<>	149:156823d33999	695	}
<>	149:156823d33999	696
<>	149:156823d33999	697	/** Create a Callback with a member function
<>	149:156823d33999	698	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	699	* @param method Member function to attach
<>	149:156823d33999	700	*/
<>	151:5eaa88a5bcc7	701	template<typename T, typename U>
<>	151:5eaa88a5bcc7	702	Callback(const volatile U obj, R (T::method)(A0) const volatile) {
<>	149:156823d33999	703	generate(method_context<const volatile T, R (T::*)(A0) const volatile>(obj, method));
<>	149:156823d33999	704	}
<>	149:156823d33999	705
<>	149:156823d33999	706	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	707	* @param func Static function to attach
<>	149:156823d33999	708	* @param arg Pointer argument to function
<>	149:156823d33999	709	*/
<>	151:5eaa88a5bcc7	710	template<typename T, typename U>
<>	151:5eaa88a5bcc7	711	Callback(R (func)(T, A0), U *arg) {
<>	149:156823d33999	712	generate(function_context<R ()(T, A0), T>(func, arg));
<>	149:156823d33999	713	}
<>	149:156823d33999	714
<>	149:156823d33999	715	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	716	* @param func Static function to attach
<>	149:156823d33999	717	* @param arg Pointer argument to function
<>	149:156823d33999	718	*/
<>	151:5eaa88a5bcc7	719	template<typename T, typename U>
<>	151:5eaa88a5bcc7	720	Callback(R (func)(const T, A0), const U *arg) {
<>	149:156823d33999	721	generate(function_context<R ()(const T, A0), const T>(func, arg));
<>	149:156823d33999	722	}
<>	149:156823d33999	723
<>	149:156823d33999	724	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	725	* @param func Static function to attach
<>	149:156823d33999	726	* @param arg Pointer argument to function
<>	149:156823d33999	727	*/
<>	151:5eaa88a5bcc7	728	template<typename T, typename U>
<>	151:5eaa88a5bcc7	729	Callback(R (func)(volatile T, A0), volatile U *arg) {
<>	149:156823d33999	730	generate(function_context<R ()(volatile T, A0), volatile T>(func, arg));
<>	149:156823d33999	731	}
<>	149:156823d33999	732
<>	149:156823d33999	733	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	734	* @param func Static function to attach
<>	149:156823d33999	735	* @param arg Pointer argument to function
<>	149:156823d33999	736	*/
<>	151:5eaa88a5bcc7	737	template<typename T, typename U>
<>	151:5eaa88a5bcc7	738	Callback(R (func)(const volatile T, A0), const volatile U *arg) {
<>	149:156823d33999	739	generate(function_context<R ()(const volatile T, A0), const volatile T>(func, arg));
<>	149:156823d33999	740	}
<>	149:156823d33999	741
<>	149:156823d33999	742	/** Create a Callback with a function object
AnnaBridge	167:e84263d55307	743	* @param f Function object to attach
<>	149:156823d33999	744	* @note The function object is limited to a single word of storage
<>	149:156823d33999	745	*/
<>	149:156823d33999	746	template <typename F>
AnnaBridge	167:e84263d55307	747	Callback(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0))) {
<>	149:156823d33999	748	generate(f);
<>	149:156823d33999	749	}
<>	149:156823d33999	750
<>	149:156823d33999	751	/** Create a Callback with a function object
AnnaBridge	167:e84263d55307	752	* @param f Function object to attach
<>	149:156823d33999	753	* @note The function object is limited to a single word of storage
<>	149:156823d33999	754	*/
<>	149:156823d33999	755	template <typename F>
AnnaBridge	167:e84263d55307	756	Callback(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0) const)) {
<>	149:156823d33999	757	generate(f);
<>	149:156823d33999	758	}
<>	149:156823d33999	759
<>	149:156823d33999	760	/** Create a Callback with a function object
AnnaBridge	167:e84263d55307	761	* @param f Function object to attach
<>	149:156823d33999	762	* @note The function object is limited to a single word of storage
<>	149:156823d33999	763	*/
<>	149:156823d33999	764	template <typename F>
AnnaBridge	167:e84263d55307	765	Callback(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0) volatile)) {
<>	149:156823d33999	766	generate(f);
<>	149:156823d33999	767	}
<>	149:156823d33999	768
<>	149:156823d33999	769	/** Create a Callback with a function object
AnnaBridge	167:e84263d55307	770	* @param f Function object to attach
<>	149:156823d33999	771	* @note The function object is limited to a single word of storage
<>	149:156823d33999	772	*/
<>	149:156823d33999	773	template <typename F>
AnnaBridge	167:e84263d55307	774	Callback(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0) const volatile)) {
<>	149:156823d33999	775	generate(f);
<>	149:156823d33999	776	}
<>	149:156823d33999	777
<>	149:156823d33999	778	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	779	* @param obj Pointer to object to bind to function
<>	149:156823d33999	780	* @param func Static function to attach
<>	149:156823d33999	781	* @deprecated
<>	149:156823d33999	782	* Arguments to callback have been reordered to Callback(func, arg)
<>	149:156823d33999	783	*/
<>	151:5eaa88a5bcc7	784	template<typename T, typename U>
<>	149:156823d33999	785	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	786	"Arguments to callback have been reordered to Callback(func, arg)")
<>	151:5eaa88a5bcc7	787	Callback(U obj, R (func)(T*, A0)) {
<>	149:156823d33999	788	new (this) Callback(func, obj);
<>	149:156823d33999	789	}
<>	149:156823d33999	790
<>	149:156823d33999	791	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	792	* @param obj Pointer to object to bind to function
<>	149:156823d33999	793	* @param func Static function to attach
<>	149:156823d33999	794	* @deprecated
<>	149:156823d33999	795	* Arguments to callback have been reordered to Callback(func, arg)
<>	149:156823d33999	796	*/
<>	151:5eaa88a5bcc7	797	template<typename T, typename U>
<>	149:156823d33999	798	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	799	"Arguments to callback have been reordered to Callback(func, arg)")
<>	151:5eaa88a5bcc7	800	Callback(const U obj, R (func)(const T*, A0)) {
<>	149:156823d33999	801	new (this) Callback(func, obj);
<>	149:156823d33999	802	}
<>	149:156823d33999	803
<>	149:156823d33999	804	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	805	* @param obj Pointer to object to bind to function
<>	149:156823d33999	806	* @param func Static function to attach
<>	149:156823d33999	807	* @deprecated
<>	149:156823d33999	808	* Arguments to callback have been reordered to Callback(func, arg)
<>	149:156823d33999	809	*/
<>	151:5eaa88a5bcc7	810	template<typename T, typename U>
<>	149:156823d33999	811	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	812	"Arguments to callback have been reordered to Callback(func, arg)")
<>	151:5eaa88a5bcc7	813	Callback(volatile U obj, R (func)(volatile T*, A0)) {
<>	149:156823d33999	814	new (this) Callback(func, obj);
<>	149:156823d33999	815	}
<>	149:156823d33999	816
<>	149:156823d33999	817	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	818	* @param obj Pointer to object to bind to function
<>	149:156823d33999	819	* @param func Static function to attach
<>	149:156823d33999	820	* @deprecated
<>	149:156823d33999	821	* Arguments to callback have been reordered to Callback(func, arg)
<>	149:156823d33999	822	*/
<>	151:5eaa88a5bcc7	823	template<typename T, typename U>
<>	149:156823d33999	824	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	825	"Arguments to callback have been reordered to Callback(func, arg)")
<>	151:5eaa88a5bcc7	826	Callback(const volatile U obj, R (func)(const volatile T*, A0)) {
<>	149:156823d33999	827	new (this) Callback(func, obj);
<>	149:156823d33999	828	}
<>	149:156823d33999	829
<>	149:156823d33999	830	/** Destroy a callback
<>	149:156823d33999	831	*/
<>	149:156823d33999	832	~Callback() {
<>	149:156823d33999	833	if (_ops) {
<>	149:156823d33999	834	_ops->dtor(this);
<>	149:156823d33999	835	}
<>	149:156823d33999	836	}
<>	149:156823d33999	837
<>	149:156823d33999	838	/** Attach a static function
<>	149:156823d33999	839	* @param func Static function to attach
<>	160:d5399cc887bb	840	* @deprecated
<>	160:d5399cc887bb	841	* Replaced by simple assignment 'Callback cb = func'
<>	160:d5399cc887bb	842	*/
<>	160:d5399cc887bb	843	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	844	"Replaced by simple assignment 'Callback cb = func")
<>	149:156823d33999	845	void attach(R (*func)(A0)) {
<>	149:156823d33999	846	this->~Callback();
<>	149:156823d33999	847	new (this) Callback(func);
<>	149:156823d33999	848	}
<>	149:156823d33999	849
<>	149:156823d33999	850	/** Attach a Callback
<>	149:156823d33999	851	* @param func The Callback to attach
<>	160:d5399cc887bb	852	* @deprecated
<>	160:d5399cc887bb	853	* Replaced by simple assignment 'Callback cb = func'
<>	160:d5399cc887bb	854	*/
<>	160:d5399cc887bb	855	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	856	"Replaced by simple assignment 'Callback cb = func")
<>	149:156823d33999	857	void attach(const Callback<R(A0)> &func) {
<>	149:156823d33999	858	this->~Callback();
<>	149:156823d33999	859	new (this) Callback(func);
<>	149:156823d33999	860	}
<>	149:156823d33999	861
<>	149:156823d33999	862	/** Attach a member function
<>	149:156823d33999	863	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	864	* @param method Member function to attach
<>	160:d5399cc887bb	865	* @deprecated
<>	160:d5399cc887bb	866	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	867	*/
<>	151:5eaa88a5bcc7	868	template<typename T, typename U>
<>	160:d5399cc887bb	869	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	870	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	871	void attach(U obj, R (T::method)(A0)) {
<>	149:156823d33999	872	this->~Callback();
<>	149:156823d33999	873	new (this) Callback(obj, method);
<>	149:156823d33999	874	}
<>	149:156823d33999	875
<>	149:156823d33999	876	/** Attach a member function
<>	149:156823d33999	877	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	878	* @param method Member function to attach
<>	160:d5399cc887bb	879	* @deprecated
<>	160:d5399cc887bb	880	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	881	*/
<>	151:5eaa88a5bcc7	882	template<typename T, typename U>
<>	160:d5399cc887bb	883	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	884	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	885	void attach(const U obj, R (T::method)(A0) const) {
<>	149:156823d33999	886	this->~Callback();
<>	149:156823d33999	887	new (this) Callback(obj, method);
<>	149:156823d33999	888	}
<>	149:156823d33999	889
<>	149:156823d33999	890	/** Attach a member function
<>	149:156823d33999	891	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	892	* @param method Member function to attach
<>	160:d5399cc887bb	893	* @deprecated
<>	160:d5399cc887bb	894	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	895	*/
<>	151:5eaa88a5bcc7	896	template<typename T, typename U>
<>	160:d5399cc887bb	897	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	898	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	899	void attach(volatile U obj, R (T::method)(A0) volatile) {
<>	149:156823d33999	900	this->~Callback();
<>	149:156823d33999	901	new (this) Callback(obj, method);
<>	149:156823d33999	902	}
<>	149:156823d33999	903
<>	149:156823d33999	904	/** Attach a member function
<>	149:156823d33999	905	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	906	* @param method Member function to attach
<>	160:d5399cc887bb	907	* @deprecated
<>	160:d5399cc887bb	908	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	909	*/
<>	151:5eaa88a5bcc7	910	template<typename T, typename U>
<>	160:d5399cc887bb	911	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	912	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	913	void attach(const volatile U obj, R (T::method)(A0) const volatile) {
<>	149:156823d33999	914	this->~Callback();
<>	149:156823d33999	915	new (this) Callback(obj, method);
<>	149:156823d33999	916	}
<>	149:156823d33999	917
<>	149:156823d33999	918	/** Attach a static function with a bound pointer
<>	149:156823d33999	919	* @param func Static function to attach
<>	149:156823d33999	920	* @param arg Pointer argument to function
<>	160:d5399cc887bb	921	* @deprecated
<>	160:d5399cc887bb	922	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	923	*/
<>	151:5eaa88a5bcc7	924	template <typename T, typename U>
<>	160:d5399cc887bb	925	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	926	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	927	void attach(R (func)(T, A0), U *arg) {
<>	149:156823d33999	928	this->~Callback();
<>	149:156823d33999	929	new (this) Callback(func, arg);
<>	149:156823d33999	930	}
<>	149:156823d33999	931
<>	149:156823d33999	932	/** Attach a static function with a bound pointer
<>	149:156823d33999	933	* @param func Static function to attach
<>	149:156823d33999	934	* @param arg Pointer argument to function
<>	160:d5399cc887bb	935	* @deprecated
<>	160:d5399cc887bb	936	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	937	*/
<>	151:5eaa88a5bcc7	938	template <typename T, typename U>
<>	160:d5399cc887bb	939	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	940	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	941	void attach(R (func)(const T, A0), const U *arg) {
<>	149:156823d33999	942	this->~Callback();
<>	149:156823d33999	943	new (this) Callback(func, arg);
<>	149:156823d33999	944	}
<>	149:156823d33999	945
<>	149:156823d33999	946	/** Attach a static function with a bound pointer
<>	149:156823d33999	947	* @param func Static function to attach
<>	149:156823d33999	948	* @param arg Pointer argument to function
<>	160:d5399cc887bb	949	* @deprecated
<>	160:d5399cc887bb	950	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	951	*/
<>	151:5eaa88a5bcc7	952	template <typename T, typename U>
<>	160:d5399cc887bb	953	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	954	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	955	void attach(R (func)(volatile T, A0), volatile U *arg) {
<>	149:156823d33999	956	this->~Callback();
<>	149:156823d33999	957	new (this) Callback(func, arg);
<>	149:156823d33999	958	}
<>	149:156823d33999	959
<>	149:156823d33999	960	/** Attach a static function with a bound pointer
<>	149:156823d33999	961	* @param func Static function to attach
<>	149:156823d33999	962	* @param arg Pointer argument to function
<>	160:d5399cc887bb	963	* @deprecated
<>	160:d5399cc887bb	964	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	965	*/
<>	151:5eaa88a5bcc7	966	template <typename T, typename U>
<>	160:d5399cc887bb	967	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	968	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	969	void attach(R (func)(const volatile T, A0), const volatile U *arg) {
<>	149:156823d33999	970	this->~Callback();
<>	149:156823d33999	971	new (this) Callback(func, arg);
<>	149:156823d33999	972	}
<>	149:156823d33999	973
<>	149:156823d33999	974	/** Attach a function object
AnnaBridge	167:e84263d55307	975	* @param f Function object to attach
<>	149:156823d33999	976	* @note The function object is limited to a single word of storage
<>	160:d5399cc887bb	977	* @deprecated
<>	160:d5399cc887bb	978	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	979	*/
<>	149:156823d33999	980	template <typename F>
<>	160:d5399cc887bb	981	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	982	"Replaced by simple assignment 'Callback cb = func")
AnnaBridge	167:e84263d55307	983	void attach(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0))) {
<>	149:156823d33999	984	this->~Callback();
<>	149:156823d33999	985	new (this) Callback(f);
<>	149:156823d33999	986	}
<>	149:156823d33999	987
<>	149:156823d33999	988	/** Attach a function object
AnnaBridge	167:e84263d55307	989	* @param f Function object to attach
<>	149:156823d33999	990	* @note The function object is limited to a single word of storage
<>	160:d5399cc887bb	991	* @deprecated
<>	160:d5399cc887bb	992	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	993	*/
<>	149:156823d33999	994	template <typename F>
<>	160:d5399cc887bb	995	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	996	"Replaced by simple assignment 'Callback cb = func")
AnnaBridge	167:e84263d55307	997	void attach(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0) const)) {
<>	149:156823d33999	998	this->~Callback();
<>	149:156823d33999	999	new (this) Callback(f);
<>	149:156823d33999	1000	}
<>	149:156823d33999	1001
<>	149:156823d33999	1002	/** Attach a function object
AnnaBridge	167:e84263d55307	1003	* @param f Function object to attach
<>	149:156823d33999	1004	* @note The function object is limited to a single word of storage
<>	160:d5399cc887bb	1005	* @deprecated
<>	160:d5399cc887bb	1006	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	1007	*/
<>	149:156823d33999	1008	template <typename F>
<>	160:d5399cc887bb	1009	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	1010	"Replaced by simple assignment 'Callback cb = func")
AnnaBridge	167:e84263d55307	1011	void attach(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0) volatile)) {
<>	149:156823d33999	1012	this->~Callback();
<>	149:156823d33999	1013	new (this) Callback(f);
<>	149:156823d33999	1014	}
<>	149:156823d33999	1015
<>	149:156823d33999	1016	/** Attach a function object
AnnaBridge	167:e84263d55307	1017	* @param f Function object to attach
<>	149:156823d33999	1018	* @note The function object is limited to a single word of storage
<>	160:d5399cc887bb	1019	* @deprecated
<>	160:d5399cc887bb	1020	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	1021	*/
<>	149:156823d33999	1022	template <typename F>
<>	160:d5399cc887bb	1023	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	1024	"Replaced by simple assignment 'Callback cb = func")
AnnaBridge	167:e84263d55307	1025	void attach(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0) const volatile)) {
<>	149:156823d33999	1026	this->~Callback();
<>	149:156823d33999	1027	new (this) Callback(f);
<>	149:156823d33999	1028	}
<>	149:156823d33999	1029
<>	149:156823d33999	1030	/** Attach a static function with a bound pointer
<>	149:156823d33999	1031	* @param obj Pointer to object to bind to function
<>	149:156823d33999	1032	* @param func Static function to attach
<>	149:156823d33999	1033	* @deprecated
<>	149:156823d33999	1034	* Arguments to callback have been reordered to attach(func, arg)
<>	149:156823d33999	1035	*/
<>	151:5eaa88a5bcc7	1036	template <typename T, typename U>
<>	149:156823d33999	1037	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	1038	"Arguments to callback have been reordered to attach(func, arg)")
<>	151:5eaa88a5bcc7	1039	void attach(U obj, R (func)(T*, A0)) {
<>	149:156823d33999	1040	this->~Callback();
<>	149:156823d33999	1041	new (this) Callback(func, obj);
<>	149:156823d33999	1042	}
<>	149:156823d33999	1043
<>	149:156823d33999	1044	/** Attach a static function with a bound pointer
<>	149:156823d33999	1045	* @param obj Pointer to object to bind to function
<>	149:156823d33999	1046	* @param func Static function to attach
<>	149:156823d33999	1047	* @deprecated
<>	149:156823d33999	1048	* Arguments to callback have been reordered to attach(func, arg)
<>	149:156823d33999	1049	*/
<>	151:5eaa88a5bcc7	1050	template <typename T, typename U>
<>	149:156823d33999	1051	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	1052	"Arguments to callback have been reordered to attach(func, arg)")
<>	151:5eaa88a5bcc7	1053	void attach(const U obj, R (func)(const T*, A0)) {
<>	149:156823d33999	1054	this->~Callback();
<>	149:156823d33999	1055	new (this) Callback(func, obj);
<>	149:156823d33999	1056	}
<>	149:156823d33999	1057
<>	149:156823d33999	1058	/** Attach a static function with a bound pointer
<>	149:156823d33999	1059	* @param obj Pointer to object to bind to function
<>	149:156823d33999	1060	* @param func Static function to attach
<>	149:156823d33999	1061	* @deprecated
<>	149:156823d33999	1062	* Arguments to callback have been reordered to attach(func, arg)
<>	149:156823d33999	1063	*/
<>	151:5eaa88a5bcc7	1064	template <typename T, typename U>
<>	149:156823d33999	1065	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	1066	"Arguments to callback have been reordered to attach(func, arg)")
<>	151:5eaa88a5bcc7	1067	void attach(volatile U obj, R (func)(volatile T*, A0)) {
<>	149:156823d33999	1068	this->~Callback();
<>	149:156823d33999	1069	new (this) Callback(func, obj);
<>	149:156823d33999	1070	}
<>	149:156823d33999	1071
<>	149:156823d33999	1072	/** Attach a static function with a bound pointer
<>	149:156823d33999	1073	* @param obj Pointer to object to bind to function
<>	149:156823d33999	1074	* @param func Static function to attach
<>	149:156823d33999	1075	* @deprecated
<>	149:156823d33999	1076	* Arguments to callback have been reordered to attach(func, arg)
<>	149:156823d33999	1077	*/
<>	151:5eaa88a5bcc7	1078	template <typename T, typename U>
<>	149:156823d33999	1079	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	1080	"Arguments to callback have been reordered to attach(func, arg)")
<>	151:5eaa88a5bcc7	1081	void attach(const volatile U obj, R (func)(const volatile T*, A0)) {
<>	149:156823d33999	1082	this->~Callback();
<>	149:156823d33999	1083	new (this) Callback(func, obj);
<>	149:156823d33999	1084	}
<>	149:156823d33999	1085
<>	149:156823d33999	1086	/** Assign a callback
<>	149:156823d33999	1087	*/
<>	149:156823d33999	1088	Callback &operator=(const Callback &that) {
<>	149:156823d33999	1089	if (this != &that) {
<>	149:156823d33999	1090	this->~Callback();
<>	149:156823d33999	1091	new (this) Callback(that);
<>	149:156823d33999	1092	}
<>	149:156823d33999	1093
<>	149:156823d33999	1094	return *this;
<>	149:156823d33999	1095	}
<>	149:156823d33999	1096
<>	149:156823d33999	1097	/** Call the attached function
<>	149:156823d33999	1098	*/
<>	149:156823d33999	1099	R call(A0 a0) const {
<>	149:156823d33999	1100	MBED_ASSERT(_ops);
<>	149:156823d33999	1101	return _ops->call(this, a0);
<>	149:156823d33999	1102	}
<>	149:156823d33999	1103
<>	149:156823d33999	1104	/** Call the attached function
<>	149:156823d33999	1105	*/
<>	149:156823d33999	1106	R operator()(A0 a0) const {
<>	149:156823d33999	1107	return call(a0);
<>	149:156823d33999	1108	}
<>	149:156823d33999	1109
<>	149:156823d33999	1110	/** Test if function has been attached
<>	149:156823d33999	1111	*/
<>	149:156823d33999	1112	operator bool() const {
<>	149:156823d33999	1113	return _ops;
<>	149:156823d33999	1114	}
<>	149:156823d33999	1115
<>	149:156823d33999	1116	/** Test for equality
<>	149:156823d33999	1117	*/
<>	149:156823d33999	1118	friend bool operator==(const Callback &l, const Callback &r) {
<>	149:156823d33999	1119	return memcmp(&l, &r, sizeof(Callback)) == 0;
<>	149:156823d33999	1120	}
<>	149:156823d33999	1121
<>	149:156823d33999	1122	/** Test for inequality
<>	149:156823d33999	1123	*/
<>	149:156823d33999	1124	friend bool operator!=(const Callback &l, const Callback &r) {
<>	149:156823d33999	1125	return !(l == r);
<>	149:156823d33999	1126	}
<>	149:156823d33999	1127
<>	149:156823d33999	1128	/** Static thunk for passing as C-style function
<>	149:156823d33999	1129	* @param func Callback to call passed as void pointer
AnnaBridge	167:e84263d55307	1130	* @param a0 An argument to be called with function func
AnnaBridge	167:e84263d55307	1131	* @return the value as determined by func which is of
AnnaBridge	167:e84263d55307	1132	* type and determined by the signiture of func
<>	149:156823d33999	1133	*/
<>	149:156823d33999	1134	static R thunk(void *func, A0 a0) {
<>	149:156823d33999	1135	return static_cast<Callback*>(func)->call(a0);
<>	149:156823d33999	1136	}
<>	149:156823d33999	1137
<>	149:156823d33999	1138	private:
<>	149:156823d33999	1139	// Stored as pointer to function and pointer to optional object
<>	149:156823d33999	1140	// Function pointer is stored as union of possible function types
<>	149:156823d33999	1141	// to garuntee proper size and alignment
<>	149:156823d33999	1142	struct _class;
<>	149:156823d33999	1143	union {
<>	149:156823d33999	1144	void (*_staticfunc)(A0);
<>	149:156823d33999	1145	void (_boundfunc)(_class, A0);
<>	149:156823d33999	1146	void (_class::*_methodfunc)(A0);
<>	149:156823d33999	1147	} _func;
<>	149:156823d33999	1148	void *_obj;
<>	149:156823d33999	1149
<>	149:156823d33999	1150	// Dynamically dispatched operations
<>	149:156823d33999	1151	const struct ops {
<>	149:156823d33999	1152	R (call)(const void, A0);
<>	149:156823d33999	1153	void (move)(void, const void*);
<>	149:156823d33999	1154	void (dtor)(void);
<>	149:156823d33999	1155	} *_ops;
<>	149:156823d33999	1156
<>	149:156823d33999	1157	// Generate operations for function object
<>	149:156823d33999	1158	template <typename F>
<>	149:156823d33999	1159	void generate(const F &f) {
<>	149:156823d33999	1160	static const ops ops = {
<>	149:156823d33999	1161	&Callback::function_call<F>,
<>	149:156823d33999	1162	&Callback::function_move<F>,
<>	149:156823d33999	1163	&Callback::function_dtor<F>,
<>	149:156823d33999	1164	};
<>	149:156823d33999	1165
<>	151:5eaa88a5bcc7	1166	MBED_STATIC_ASSERT(sizeof(Callback) - sizeof(_ops) >= sizeof(F),
<>	151:5eaa88a5bcc7	1167	"Type F must not exceed the size of the Callback class");
<>	149:156823d33999	1168	new (this) F(f);
<>	149:156823d33999	1169	_ops = &ops;
<>	149:156823d33999	1170	}
<>	149:156823d33999	1171
<>	149:156823d33999	1172	// Function attributes
<>	149:156823d33999	1173	template <typename F>
<>	149:156823d33999	1174	static R function_call(const void *p, A0 a0) {
<>	149:156823d33999	1175	return ((F)p)(a0);
<>	149:156823d33999	1176	}
<>	149:156823d33999	1177
<>	149:156823d33999	1178	template <typename F>
<>	149:156823d33999	1179	static void function_move(void d, const void p) {
<>	149:156823d33999	1180	new (d) F((F)p);
<>	149:156823d33999	1181	}
<>	149:156823d33999	1182
<>	149:156823d33999	1183	template <typename F>
<>	149:156823d33999	1184	static void function_dtor(void *p) {
<>	149:156823d33999	1185	((F*)p)->~F();
<>	149:156823d33999	1186	}
<>	149:156823d33999	1187
<>	149:156823d33999	1188	// Wrappers for functions with context
<>	149:156823d33999	1189	template <typename O, typename M>
<>	149:156823d33999	1190	struct method_context {
<>	149:156823d33999	1191	M method;
<>	149:156823d33999	1192	O *obj;
<>	149:156823d33999	1193
<>	149:156823d33999	1194	method_context(O *obj, M method)
<>	149:156823d33999	1195	: method(method), obj(obj) {}
<>	149:156823d33999	1196
<>	149:156823d33999	1197	R operator()(A0 a0) const {
<>	149:156823d33999	1198	return (obj->*method)(a0);
<>	149:156823d33999	1199	}
<>	149:156823d33999	1200	};
<>	149:156823d33999	1201
<>	149:156823d33999	1202	template <typename F, typename A>
<>	149:156823d33999	1203	struct function_context {
<>	149:156823d33999	1204	F func;
<>	149:156823d33999	1205	A *arg;
<>	149:156823d33999	1206
<>	149:156823d33999	1207	function_context(F func, A *arg)
<>	149:156823d33999	1208	: func(func), arg(arg) {}
<>	149:156823d33999	1209
<>	149:156823d33999	1210	R operator()(A0 a0) const {
<>	149:156823d33999	1211	return func(arg, a0);
<>	149:156823d33999	1212	}
<>	149:156823d33999	1213	};
<>	149:156823d33999	1214	};
<>	149:156823d33999	1215
<>	149:156823d33999	1216	/** Callback class based on template specialization
<>	149:156823d33999	1217	*
AnnaBridge	167:e84263d55307	1218	* @note Synchronization level: Not protected
AnnaBridge	167:e84263d55307	1219	* @ingroup platform
<>	149:156823d33999	1220	*/
<>	149:156823d33999	1221	template <typename R, typename A0, typename A1>
<>	149:156823d33999	1222	class Callback<R(A0, A1)> {
<>	149:156823d33999	1223	public:
<>	149:156823d33999	1224	/** Create a Callback with a static function
<>	149:156823d33999	1225	* @param func Static function to attach
<>	149:156823d33999	1226	*/
<>	149:156823d33999	1227	Callback(R (*func)(A0, A1) = 0) {
<>	149:156823d33999	1228	if (!func) {
<>	149:156823d33999	1229	_ops = 0;
<>	149:156823d33999	1230	} else {
<>	149:156823d33999	1231	generate(func);
<>	149:156823d33999	1232	}
<>	149:156823d33999	1233	}
<>	149:156823d33999	1234
<>	149:156823d33999	1235	/** Attach a Callback
<>	149:156823d33999	1236	* @param func The Callback to attach
<>	149:156823d33999	1237	*/
<>	149:156823d33999	1238	Callback(const Callback<R(A0, A1)> &func) {
<>	149:156823d33999	1239	if (func._ops) {
<>	149:156823d33999	1240	func._ops->move(this, &func);
<>	149:156823d33999	1241	}
<>	149:156823d33999	1242	_ops = func._ops;
<>	149:156823d33999	1243	}
<>	149:156823d33999	1244
<>	149:156823d33999	1245	/** Create a Callback with a member function
<>	149:156823d33999	1246	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	1247	* @param method Member function to attach
<>	149:156823d33999	1248	*/
<>	151:5eaa88a5bcc7	1249	template<typename T, typename U>
<>	151:5eaa88a5bcc7	1250	Callback(U obj, R (T::method)(A0, A1)) {
<>	149:156823d33999	1251	generate(method_context<T, R (T::*)(A0, A1)>(obj, method));
<>	149:156823d33999	1252	}
<>	149:156823d33999	1253
<>	149:156823d33999	1254	/** Create a Callback with a member function
<>	149:156823d33999	1255	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	1256	* @param method Member function to attach
<>	149:156823d33999	1257	*/
<>	151:5eaa88a5bcc7	1258	template<typename T, typename U>
<>	151:5eaa88a5bcc7	1259	Callback(const U obj, R (T::method)(A0, A1) const) {
<>	149:156823d33999	1260	generate(method_context<const T, R (T::*)(A0, A1) const>(obj, method));
<>	149:156823d33999	1261	}
<>	149:156823d33999	1262
<>	149:156823d33999	1263	/** Create a Callback with a member function
<>	149:156823d33999	1264	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	1265	* @param method Member function to attach
<>	149:156823d33999	1266	*/
<>	151:5eaa88a5bcc7	1267	template<typename T, typename U>
<>	151:5eaa88a5bcc7	1268	Callback(volatile U obj, R (T::method)(A0, A1) volatile) {
<>	149:156823d33999	1269	generate(method_context<volatile T, R (T::*)(A0, A1) volatile>(obj, method));
<>	149:156823d33999	1270	}
<>	149:156823d33999	1271
<>	149:156823d33999	1272	/** Create a Callback with a member function
<>	149:156823d33999	1273	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	1274	* @param method Member function to attach
<>	149:156823d33999	1275	*/
<>	151:5eaa88a5bcc7	1276	template<typename T, typename U>
<>	151:5eaa88a5bcc7	1277	Callback(const volatile U obj, R (T::method)(A0, A1) const volatile) {
<>	149:156823d33999	1278	generate(method_context<const volatile T, R (T::*)(A0, A1) const volatile>(obj, method));
<>	149:156823d33999	1279	}
<>	149:156823d33999	1280
<>	149:156823d33999	1281	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	1282	* @param func Static function to attach
<>	149:156823d33999	1283	* @param arg Pointer argument to function
<>	149:156823d33999	1284	*/
<>	151:5eaa88a5bcc7	1285	template<typename T, typename U>
<>	151:5eaa88a5bcc7	1286	Callback(R (func)(T, A0, A1), U *arg) {
<>	149:156823d33999	1287	generate(function_context<R ()(T, A0, A1), T>(func, arg));
<>	149:156823d33999	1288	}
<>	149:156823d33999	1289
<>	149:156823d33999	1290	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	1291	* @param func Static function to attach
<>	149:156823d33999	1292	* @param arg Pointer argument to function
<>	149:156823d33999	1293	*/
<>	151:5eaa88a5bcc7	1294	template<typename T, typename U>
<>	151:5eaa88a5bcc7	1295	Callback(R (func)(const T, A0, A1), const U *arg) {
<>	149:156823d33999	1296	generate(function_context<R ()(const T, A0, A1), const T>(func, arg));
<>	149:156823d33999	1297	}
<>	149:156823d33999	1298
<>	149:156823d33999	1299	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	1300	* @param func Static function to attach
<>	149:156823d33999	1301	* @param arg Pointer argument to function
<>	149:156823d33999	1302	*/
<>	151:5eaa88a5bcc7	1303	template<typename T, typename U>
<>	151:5eaa88a5bcc7	1304	Callback(R (func)(volatile T, A0, A1), volatile U *arg) {
<>	149:156823d33999	1305	generate(function_context<R ()(volatile T, A0, A1), volatile T>(func, arg));
<>	149:156823d33999	1306	}
<>	149:156823d33999	1307
<>	149:156823d33999	1308	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	1309	* @param func Static function to attach
<>	149:156823d33999	1310	* @param arg Pointer argument to function
<>	149:156823d33999	1311	*/
<>	151:5eaa88a5bcc7	1312	template<typename T, typename U>
<>	151:5eaa88a5bcc7	1313	Callback(R (func)(const volatile T, A0, A1), const volatile U *arg) {
<>	149:156823d33999	1314	generate(function_context<R ()(const volatile T, A0, A1), const volatile T>(func, arg));
<>	149:156823d33999	1315	}
<>	149:156823d33999	1316
<>	149:156823d33999	1317	/** Create a Callback with a function object
AnnaBridge	167:e84263d55307	1318	* @param f Function object to attach
<>	149:156823d33999	1319	* @note The function object is limited to a single word of storage
<>	149:156823d33999	1320	*/
<>	149:156823d33999	1321	template <typename F>
AnnaBridge	167:e84263d55307	1322	Callback(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1))) {
<>	149:156823d33999	1323	generate(f);
<>	149:156823d33999	1324	}
<>	149:156823d33999	1325
<>	149:156823d33999	1326	/** Create a Callback with a function object
AnnaBridge	167:e84263d55307	1327	* @param f Function object to attach
<>	149:156823d33999	1328	* @note The function object is limited to a single word of storage
<>	149:156823d33999	1329	*/
<>	149:156823d33999	1330	template <typename F>
AnnaBridge	167:e84263d55307	1331	Callback(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1) const)) {
<>	149:156823d33999	1332	generate(f);
<>	149:156823d33999	1333	}
<>	149:156823d33999	1334
<>	149:156823d33999	1335	/** Create a Callback with a function object
AnnaBridge	167:e84263d55307	1336	* @param f Function object to attach
<>	149:156823d33999	1337	* @note The function object is limited to a single word of storage
<>	149:156823d33999	1338	*/
<>	149:156823d33999	1339	template <typename F>
AnnaBridge	167:e84263d55307	1340	Callback(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1) volatile)) {
<>	149:156823d33999	1341	generate(f);
<>	149:156823d33999	1342	}
<>	149:156823d33999	1343
<>	149:156823d33999	1344	/** Create a Callback with a function object
AnnaBridge	167:e84263d55307	1345	* @param f Function object to attach
<>	149:156823d33999	1346	* @note The function object is limited to a single word of storage
<>	149:156823d33999	1347	*/
<>	149:156823d33999	1348	template <typename F>
AnnaBridge	167:e84263d55307	1349	Callback(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1) const volatile)) {
<>	149:156823d33999	1350	generate(f);
<>	149:156823d33999	1351	}
<>	149:156823d33999	1352
<>	149:156823d33999	1353	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	1354	* @param obj Pointer to object to bind to function
<>	149:156823d33999	1355	* @param func Static function to attach
<>	149:156823d33999	1356	* @deprecated
<>	149:156823d33999	1357	* Arguments to callback have been reordered to Callback(func, arg)
<>	149:156823d33999	1358	*/
<>	151:5eaa88a5bcc7	1359	template<typename T, typename U>
<>	149:156823d33999	1360	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	1361	"Arguments to callback have been reordered to Callback(func, arg)")
<>	151:5eaa88a5bcc7	1362	Callback(U obj, R (func)(T*, A0, A1)) {
<>	149:156823d33999	1363	new (this) Callback(func, obj);
<>	149:156823d33999	1364	}
<>	149:156823d33999	1365
<>	149:156823d33999	1366	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	1367	* @param obj Pointer to object to bind to function
<>	149:156823d33999	1368	* @param func Static function to attach
<>	149:156823d33999	1369	* @deprecated
<>	149:156823d33999	1370	* Arguments to callback have been reordered to Callback(func, arg)
<>	149:156823d33999	1371	*/
<>	151:5eaa88a5bcc7	1372	template<typename T, typename U>
<>	149:156823d33999	1373	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	1374	"Arguments to callback have been reordered to Callback(func, arg)")
<>	151:5eaa88a5bcc7	1375	Callback(const U obj, R (func)(const T*, A0, A1)) {
<>	149:156823d33999	1376	new (this) Callback(func, obj);
<>	149:156823d33999	1377	}
<>	149:156823d33999	1378
<>	149:156823d33999	1379	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	1380	* @param obj Pointer to object to bind to function
<>	149:156823d33999	1381	* @param func Static function to attach
<>	149:156823d33999	1382	* @deprecated
<>	149:156823d33999	1383	* Arguments to callback have been reordered to Callback(func, arg)
<>	149:156823d33999	1384	*/
<>	151:5eaa88a5bcc7	1385	template<typename T, typename U>
<>	149:156823d33999	1386	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	1387	"Arguments to callback have been reordered to Callback(func, arg)")
<>	151:5eaa88a5bcc7	1388	Callback(volatile U obj, R (func)(volatile T*, A0, A1)) {
<>	149:156823d33999	1389	new (this) Callback(func, obj);
<>	149:156823d33999	1390	}
<>	149:156823d33999	1391
<>	149:156823d33999	1392	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	1393	* @param obj Pointer to object to bind to function
<>	149:156823d33999	1394	* @param func Static function to attach
<>	149:156823d33999	1395	* @deprecated
<>	149:156823d33999	1396	* Arguments to callback have been reordered to Callback(func, arg)
<>	149:156823d33999	1397	*/
<>	151:5eaa88a5bcc7	1398	template<typename T, typename U>
<>	149:156823d33999	1399	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	1400	"Arguments to callback have been reordered to Callback(func, arg)")
<>	151:5eaa88a5bcc7	1401	Callback(const volatile U obj, R (func)(const volatile T*, A0, A1)) {
<>	149:156823d33999	1402	new (this) Callback(func, obj);
<>	149:156823d33999	1403	}
<>	149:156823d33999	1404
<>	149:156823d33999	1405	/** Destroy a callback
<>	149:156823d33999	1406	*/
<>	149:156823d33999	1407	~Callback() {
<>	149:156823d33999	1408	if (_ops) {
<>	149:156823d33999	1409	_ops->dtor(this);
<>	149:156823d33999	1410	}
<>	149:156823d33999	1411	}
<>	149:156823d33999	1412
<>	149:156823d33999	1413	/** Attach a static function
<>	149:156823d33999	1414	* @param func Static function to attach
<>	160:d5399cc887bb	1415	* @deprecated
<>	160:d5399cc887bb	1416	* Replaced by simple assignment 'Callback cb = func'
<>	160:d5399cc887bb	1417	*/
<>	160:d5399cc887bb	1418	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	1419	"Replaced by simple assignment 'Callback cb = func")
<>	149:156823d33999	1420	void attach(R (*func)(A0, A1)) {
<>	149:156823d33999	1421	this->~Callback();
<>	149:156823d33999	1422	new (this) Callback(func);
<>	149:156823d33999	1423	}
<>	149:156823d33999	1424
<>	149:156823d33999	1425	/** Attach a Callback
<>	149:156823d33999	1426	* @param func The Callback to attach
<>	160:d5399cc887bb	1427	* @deprecated
<>	160:d5399cc887bb	1428	* Replaced by simple assignment 'Callback cb = func'
<>	160:d5399cc887bb	1429	*/
<>	160:d5399cc887bb	1430	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	1431	"Replaced by simple assignment 'Callback cb = func")
<>	149:156823d33999	1432	void attach(const Callback<R(A0, A1)> &func) {
<>	149:156823d33999	1433	this->~Callback();
<>	149:156823d33999	1434	new (this) Callback(func);
<>	149:156823d33999	1435	}
<>	149:156823d33999	1436
<>	149:156823d33999	1437	/** Attach a member function
<>	149:156823d33999	1438	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	1439	* @param method Member function to attach
<>	160:d5399cc887bb	1440	* @deprecated
<>	160:d5399cc887bb	1441	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	1442	*/
<>	151:5eaa88a5bcc7	1443	template<typename T, typename U>
<>	160:d5399cc887bb	1444	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	1445	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	1446	void attach(U obj, R (T::method)(A0, A1)) {
<>	149:156823d33999	1447	this->~Callback();
<>	149:156823d33999	1448	new (this) Callback(obj, method);
<>	149:156823d33999	1449	}
<>	149:156823d33999	1450
<>	149:156823d33999	1451	/** Attach a member function
<>	149:156823d33999	1452	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	1453	* @param method Member function to attach
<>	160:d5399cc887bb	1454	* @deprecated
<>	160:d5399cc887bb	1455	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	1456	*/
<>	151:5eaa88a5bcc7	1457	template<typename T, typename U>
<>	160:d5399cc887bb	1458	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	1459	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	1460	void attach(const U obj, R (T::method)(A0, A1) const) {
<>	149:156823d33999	1461	this->~Callback();
<>	149:156823d33999	1462	new (this) Callback(obj, method);
<>	149:156823d33999	1463	}
<>	149:156823d33999	1464
<>	149:156823d33999	1465	/** Attach a member function
<>	149:156823d33999	1466	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	1467	* @param method Member function to attach
<>	160:d5399cc887bb	1468	* @deprecated
<>	160:d5399cc887bb	1469	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	1470	*/
<>	151:5eaa88a5bcc7	1471	template<typename T, typename U>
<>	160:d5399cc887bb	1472	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	1473	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	1474	void attach(volatile U obj, R (T::method)(A0, A1) volatile) {
<>	149:156823d33999	1475	this->~Callback();
<>	149:156823d33999	1476	new (this) Callback(obj, method);
<>	149:156823d33999	1477	}
<>	149:156823d33999	1478
<>	149:156823d33999	1479	/** Attach a member function
<>	149:156823d33999	1480	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	1481	* @param method Member function to attach
<>	160:d5399cc887bb	1482	* @deprecated
<>	160:d5399cc887bb	1483	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	1484	*/
<>	151:5eaa88a5bcc7	1485	template<typename T, typename U>
<>	160:d5399cc887bb	1486	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	1487	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	1488	void attach(const volatile U obj, R (T::method)(A0, A1) const volatile) {
<>	149:156823d33999	1489	this->~Callback();
<>	149:156823d33999	1490	new (this) Callback(obj, method);
<>	149:156823d33999	1491	}
<>	149:156823d33999	1492
<>	149:156823d33999	1493	/** Attach a static function with a bound pointer
<>	149:156823d33999	1494	* @param func Static function to attach
<>	149:156823d33999	1495	* @param arg Pointer argument to function
<>	160:d5399cc887bb	1496	* @deprecated
<>	160:d5399cc887bb	1497	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	1498	*/
<>	151:5eaa88a5bcc7	1499	template <typename T, typename U>
<>	160:d5399cc887bb	1500	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	1501	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	1502	void attach(R (func)(T, A0, A1), U *arg) {
<>	149:156823d33999	1503	this->~Callback();
<>	149:156823d33999	1504	new (this) Callback(func, arg);
<>	149:156823d33999	1505	}
<>	149:156823d33999	1506
<>	149:156823d33999	1507	/** Attach a static function with a bound pointer
<>	149:156823d33999	1508	* @param func Static function to attach
<>	149:156823d33999	1509	* @param arg Pointer argument to function
<>	160:d5399cc887bb	1510	* @deprecated
<>	160:d5399cc887bb	1511	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	1512	*/
<>	151:5eaa88a5bcc7	1513	template <typename T, typename U>
<>	160:d5399cc887bb	1514	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	1515	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	1516	void attach(R (func)(const T, A0, A1), const U *arg) {
<>	149:156823d33999	1517	this->~Callback();
<>	149:156823d33999	1518	new (this) Callback(func, arg);
<>	149:156823d33999	1519	}
<>	149:156823d33999	1520
<>	149:156823d33999	1521	/** Attach a static function with a bound pointer
<>	149:156823d33999	1522	* @param func Static function to attach
<>	149:156823d33999	1523	* @param arg Pointer argument to function
<>	160:d5399cc887bb	1524	* @deprecated
<>	160:d5399cc887bb	1525	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	1526	*/
<>	151:5eaa88a5bcc7	1527	template <typename T, typename U>
<>	160:d5399cc887bb	1528	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	1529	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	1530	void attach(R (func)(volatile T, A0, A1), volatile U *arg) {
<>	149:156823d33999	1531	this->~Callback();
<>	149:156823d33999	1532	new (this) Callback(func, arg);
<>	149:156823d33999	1533	}
<>	149:156823d33999	1534
<>	149:156823d33999	1535	/** Attach a static function with a bound pointer
<>	149:156823d33999	1536	* @param func Static function to attach
<>	149:156823d33999	1537	* @param arg Pointer argument to function
<>	160:d5399cc887bb	1538	* @deprecated
<>	160:d5399cc887bb	1539	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	1540	*/
<>	151:5eaa88a5bcc7	1541	template <typename T, typename U>
<>	160:d5399cc887bb	1542	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	1543	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	1544	void attach(R (func)(const volatile T, A0, A1), const volatile U *arg) {
<>	149:156823d33999	1545	this->~Callback();
<>	149:156823d33999	1546	new (this) Callback(func, arg);
<>	149:156823d33999	1547	}
<>	149:156823d33999	1548
<>	149:156823d33999	1549	/** Attach a function object
AnnaBridge	167:e84263d55307	1550	* @param f Function object to attach
<>	149:156823d33999	1551	* @note The function object is limited to a single word of storage
<>	160:d5399cc887bb	1552	* @deprecated
<>	160:d5399cc887bb	1553	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	1554	*/
<>	149:156823d33999	1555	template <typename F>
<>	160:d5399cc887bb	1556	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	1557	"Replaced by simple assignment 'Callback cb = func")
AnnaBridge	167:e84263d55307	1558	void attach(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1))) {
<>	149:156823d33999	1559	this->~Callback();
<>	149:156823d33999	1560	new (this) Callback(f);
<>	149:156823d33999	1561	}
<>	149:156823d33999	1562
<>	149:156823d33999	1563	/** Attach a function object
AnnaBridge	167:e84263d55307	1564	* @param f Function object to attach
<>	149:156823d33999	1565	* @note The function object is limited to a single word of storage
<>	160:d5399cc887bb	1566	* @deprecated
<>	160:d5399cc887bb	1567	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	1568	*/
<>	149:156823d33999	1569	template <typename F>
<>	160:d5399cc887bb	1570	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	1571	"Replaced by simple assignment 'Callback cb = func")
AnnaBridge	167:e84263d55307	1572	void attach(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1) const)) {
<>	149:156823d33999	1573	this->~Callback();
<>	149:156823d33999	1574	new (this) Callback(f);
<>	149:156823d33999	1575	}
<>	149:156823d33999	1576
<>	149:156823d33999	1577	/** Attach a function object
AnnaBridge	167:e84263d55307	1578	* @param f Function object to attach
<>	149:156823d33999	1579	* @note The function object is limited to a single word of storage
<>	160:d5399cc887bb	1580	* @deprecated
<>	160:d5399cc887bb	1581	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	1582	*/
<>	149:156823d33999	1583	template <typename F>
<>	160:d5399cc887bb	1584	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	1585	"Replaced by simple assignment 'Callback cb = func")
AnnaBridge	167:e84263d55307	1586	void attach(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1) volatile)) {
<>	149:156823d33999	1587	this->~Callback();
<>	149:156823d33999	1588	new (this) Callback(f);
<>	149:156823d33999	1589	}
<>	149:156823d33999	1590
<>	149:156823d33999	1591	/** Attach a function object
AnnaBridge	167:e84263d55307	1592	* @param f Function object to attach
<>	149:156823d33999	1593	* @note The function object is limited to a single word of storage
<>	160:d5399cc887bb	1594	* @deprecated
<>	160:d5399cc887bb	1595	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	1596	*/
<>	149:156823d33999	1597	template <typename F>
<>	160:d5399cc887bb	1598	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	1599	"Replaced by simple assignment 'Callback cb = func")
AnnaBridge	167:e84263d55307	1600	void attach(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1) const volatile)) {
<>	149:156823d33999	1601	this->~Callback();
<>	149:156823d33999	1602	new (this) Callback(f);
<>	149:156823d33999	1603	}
<>	149:156823d33999	1604
<>	149:156823d33999	1605	/** Attach a static function with a bound pointer
<>	149:156823d33999	1606	* @param obj Pointer to object to bind to function
<>	149:156823d33999	1607	* @param func Static function to attach
<>	149:156823d33999	1608	* @deprecated
<>	149:156823d33999	1609	* Arguments to callback have been reordered to attach(func, arg)
<>	149:156823d33999	1610	*/
<>	151:5eaa88a5bcc7	1611	template <typename T, typename U>
<>	149:156823d33999	1612	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	1613	"Arguments to callback have been reordered to attach(func, arg)")
<>	151:5eaa88a5bcc7	1614	void attach(U obj, R (func)(T*, A0, A1)) {
<>	149:156823d33999	1615	this->~Callback();
<>	149:156823d33999	1616	new (this) Callback(func, obj);
<>	149:156823d33999	1617	}
<>	149:156823d33999	1618
<>	149:156823d33999	1619	/** Attach a static function with a bound pointer
<>	149:156823d33999	1620	* @param obj Pointer to object to bind to function
<>	149:156823d33999	1621	* @param func Static function to attach
<>	149:156823d33999	1622	* @deprecated
<>	149:156823d33999	1623	* Arguments to callback have been reordered to attach(func, arg)
<>	149:156823d33999	1624	*/
<>	151:5eaa88a5bcc7	1625	template <typename T, typename U>
<>	149:156823d33999	1626	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	1627	"Arguments to callback have been reordered to attach(func, arg)")
<>	151:5eaa88a5bcc7	1628	void attach(const U obj, R (func)(const T*, A0, A1)) {
<>	149:156823d33999	1629	this->~Callback();
<>	149:156823d33999	1630	new (this) Callback(func, obj);
<>	149:156823d33999	1631	}
<>	149:156823d33999	1632
<>	149:156823d33999	1633	/** Attach a static function with a bound pointer
<>	149:156823d33999	1634	* @param obj Pointer to object to bind to function
<>	149:156823d33999	1635	* @param func Static function to attach
<>	149:156823d33999	1636	* @deprecated
<>	149:156823d33999	1637	* Arguments to callback have been reordered to attach(func, arg)
<>	149:156823d33999	1638	*/
<>	151:5eaa88a5bcc7	1639	template <typename T, typename U>
<>	149:156823d33999	1640	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	1641	"Arguments to callback have been reordered to attach(func, arg)")
<>	151:5eaa88a5bcc7	1642	void attach(volatile U obj, R (func)(volatile T*, A0, A1)) {
<>	149:156823d33999	1643	this->~Callback();
<>	149:156823d33999	1644	new (this) Callback(func, obj);
<>	149:156823d33999	1645	}
<>	149:156823d33999	1646
<>	149:156823d33999	1647	/** Attach a static function with a bound pointer
<>	149:156823d33999	1648	* @param obj Pointer to object to bind to function
<>	149:156823d33999	1649	* @param func Static function to attach
<>	149:156823d33999	1650	* @deprecated
<>	149:156823d33999	1651	* Arguments to callback have been reordered to attach(func, arg)
<>	149:156823d33999	1652	*/
<>	151:5eaa88a5bcc7	1653	template <typename T, typename U>
<>	149:156823d33999	1654	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	1655	"Arguments to callback have been reordered to attach(func, arg)")
<>	151:5eaa88a5bcc7	1656	void attach(const volatile U obj, R (func)(const volatile T*, A0, A1)) {
<>	149:156823d33999	1657	this->~Callback();
<>	149:156823d33999	1658	new (this) Callback(func, obj);
<>	149:156823d33999	1659	}
<>	149:156823d33999	1660
<>	149:156823d33999	1661	/** Assign a callback
<>	149:156823d33999	1662	*/
<>	149:156823d33999	1663	Callback &operator=(const Callback &that) {
<>	149:156823d33999	1664	if (this != &that) {
<>	149:156823d33999	1665	this->~Callback();
<>	149:156823d33999	1666	new (this) Callback(that);
<>	149:156823d33999	1667	}
<>	149:156823d33999	1668
<>	149:156823d33999	1669	return *this;
<>	149:156823d33999	1670	}
<>	149:156823d33999	1671
<>	149:156823d33999	1672	/** Call the attached function
<>	149:156823d33999	1673	*/
<>	149:156823d33999	1674	R call(A0 a0, A1 a1) const {
<>	149:156823d33999	1675	MBED_ASSERT(_ops);
<>	149:156823d33999	1676	return _ops->call(this, a0, a1);
<>	149:156823d33999	1677	}
<>	149:156823d33999	1678
<>	149:156823d33999	1679	/** Call the attached function
<>	149:156823d33999	1680	*/
<>	149:156823d33999	1681	R operator()(A0 a0, A1 a1) const {
<>	149:156823d33999	1682	return call(a0, a1);
<>	149:156823d33999	1683	}
<>	149:156823d33999	1684
<>	149:156823d33999	1685	/** Test if function has been attached
<>	149:156823d33999	1686	*/
<>	149:156823d33999	1687	operator bool() const {
<>	149:156823d33999	1688	return _ops;
<>	149:156823d33999	1689	}
<>	149:156823d33999	1690
<>	149:156823d33999	1691	/** Test for equality
<>	149:156823d33999	1692	*/
<>	149:156823d33999	1693	friend bool operator==(const Callback &l, const Callback &r) {
<>	149:156823d33999	1694	return memcmp(&l, &r, sizeof(Callback)) == 0;
<>	149:156823d33999	1695	}
<>	149:156823d33999	1696
<>	149:156823d33999	1697	/** Test for inequality
<>	149:156823d33999	1698	*/
<>	149:156823d33999	1699	friend bool operator!=(const Callback &l, const Callback &r) {
<>	149:156823d33999	1700	return !(l == r);
<>	149:156823d33999	1701	}
<>	149:156823d33999	1702
<>	149:156823d33999	1703	/** Static thunk for passing as C-style function
<>	149:156823d33999	1704	* @param func Callback to call passed as void pointer
AnnaBridge	167:e84263d55307	1705	* @param a0 An argument to be called with function func
AnnaBridge	167:e84263d55307	1706	* @param a1 An argument to be called with function func
AnnaBridge	167:e84263d55307	1707	* @return the value as determined by func which is of
AnnaBridge	167:e84263d55307	1708	* type and determined by the signiture of func
<>	149:156823d33999	1709	*/
<>	149:156823d33999	1710	static R thunk(void *func, A0 a0, A1 a1) {
<>	149:156823d33999	1711	return static_cast<Callback*>(func)->call(a0, a1);
<>	149:156823d33999	1712	}
<>	149:156823d33999	1713
<>	149:156823d33999	1714	private:
<>	149:156823d33999	1715	// Stored as pointer to function and pointer to optional object
<>	149:156823d33999	1716	// Function pointer is stored as union of possible function types
<>	149:156823d33999	1717	// to garuntee proper size and alignment
<>	149:156823d33999	1718	struct _class;
<>	149:156823d33999	1719	union {
<>	149:156823d33999	1720	void (*_staticfunc)(A0, A1);
<>	149:156823d33999	1721	void (_boundfunc)(_class, A0, A1);
<>	149:156823d33999	1722	void (_class::*_methodfunc)(A0, A1);
<>	149:156823d33999	1723	} _func;
<>	149:156823d33999	1724	void *_obj;
<>	149:156823d33999	1725
<>	149:156823d33999	1726	// Dynamically dispatched operations
<>	149:156823d33999	1727	const struct ops {
<>	149:156823d33999	1728	R (call)(const void, A0, A1);
<>	149:156823d33999	1729	void (move)(void, const void*);
<>	149:156823d33999	1730	void (dtor)(void);
<>	149:156823d33999	1731	} *_ops;
<>	149:156823d33999	1732
<>	149:156823d33999	1733	// Generate operations for function object
<>	149:156823d33999	1734	template <typename F>
<>	149:156823d33999	1735	void generate(const F &f) {
<>	149:156823d33999	1736	static const ops ops = {
<>	149:156823d33999	1737	&Callback::function_call<F>,
<>	149:156823d33999	1738	&Callback::function_move<F>,
<>	149:156823d33999	1739	&Callback::function_dtor<F>,
<>	149:156823d33999	1740	};
<>	149:156823d33999	1741
<>	151:5eaa88a5bcc7	1742	MBED_STATIC_ASSERT(sizeof(Callback) - sizeof(_ops) >= sizeof(F),
<>	151:5eaa88a5bcc7	1743	"Type F must not exceed the size of the Callback class");
<>	149:156823d33999	1744	new (this) F(f);
<>	149:156823d33999	1745	_ops = &ops;
<>	149:156823d33999	1746	}
<>	149:156823d33999	1747
<>	149:156823d33999	1748	// Function attributes
<>	149:156823d33999	1749	template <typename F>
<>	149:156823d33999	1750	static R function_call(const void *p, A0 a0, A1 a1) {
<>	149:156823d33999	1751	return ((F)p)(a0, a1);
<>	149:156823d33999	1752	}
<>	149:156823d33999	1753
<>	149:156823d33999	1754	template <typename F>
<>	149:156823d33999	1755	static void function_move(void d, const void p) {
<>	149:156823d33999	1756	new (d) F((F)p);
<>	149:156823d33999	1757	}
<>	149:156823d33999	1758
<>	149:156823d33999	1759	template <typename F>
<>	149:156823d33999	1760	static void function_dtor(void *p) {
<>	149:156823d33999	1761	((F*)p)->~F();
<>	149:156823d33999	1762	}
<>	149:156823d33999	1763
<>	149:156823d33999	1764	// Wrappers for functions with context
<>	149:156823d33999	1765	template <typename O, typename M>
<>	149:156823d33999	1766	struct method_context {
<>	149:156823d33999	1767	M method;
<>	149:156823d33999	1768	O *obj;
<>	149:156823d33999	1769
<>	149:156823d33999	1770	method_context(O *obj, M method)
<>	149:156823d33999	1771	: method(method), obj(obj) {}
<>	149:156823d33999	1772
<>	149:156823d33999	1773	R operator()(A0 a0, A1 a1) const {
<>	149:156823d33999	1774	return (obj->*method)(a0, a1);
<>	149:156823d33999	1775	}
<>	149:156823d33999	1776	};
<>	149:156823d33999	1777
<>	149:156823d33999	1778	template <typename F, typename A>
<>	149:156823d33999	1779	struct function_context {
<>	149:156823d33999	1780	F func;
<>	149:156823d33999	1781	A *arg;
<>	149:156823d33999	1782
<>	149:156823d33999	1783	function_context(F func, A *arg)
<>	149:156823d33999	1784	: func(func), arg(arg) {}
<>	149:156823d33999	1785
<>	149:156823d33999	1786	R operator()(A0 a0, A1 a1) const {
<>	149:156823d33999	1787	return func(arg, a0, a1);
<>	149:156823d33999	1788	}
<>	149:156823d33999	1789	};
<>	149:156823d33999	1790	};
<>	149:156823d33999	1791
<>	149:156823d33999	1792	/** Callback class based on template specialization
<>	149:156823d33999	1793	*
AnnaBridge	167:e84263d55307	1794	* @note Synchronization level: Not protected
AnnaBridge	167:e84263d55307	1795	* @ingroup platform
<>	149:156823d33999	1796	*/
<>	149:156823d33999	1797	template <typename R, typename A0, typename A1, typename A2>
<>	149:156823d33999	1798	class Callback<R(A0, A1, A2)> {
<>	149:156823d33999	1799	public:
<>	149:156823d33999	1800	/** Create a Callback with a static function
<>	149:156823d33999	1801	* @param func Static function to attach
<>	149:156823d33999	1802	*/
<>	149:156823d33999	1803	Callback(R (*func)(A0, A1, A2) = 0) {
<>	149:156823d33999	1804	if (!func) {
<>	149:156823d33999	1805	_ops = 0;
<>	149:156823d33999	1806	} else {
<>	149:156823d33999	1807	generate(func);
<>	149:156823d33999	1808	}
<>	149:156823d33999	1809	}
<>	149:156823d33999	1810
<>	149:156823d33999	1811	/** Attach a Callback
<>	149:156823d33999	1812	* @param func The Callback to attach
<>	149:156823d33999	1813	*/
<>	149:156823d33999	1814	Callback(const Callback<R(A0, A1, A2)> &func) {
<>	149:156823d33999	1815	if (func._ops) {
<>	149:156823d33999	1816	func._ops->move(this, &func);
<>	149:156823d33999	1817	}
<>	149:156823d33999	1818	_ops = func._ops;
<>	149:156823d33999	1819	}
<>	149:156823d33999	1820
<>	149:156823d33999	1821	/** Create a Callback with a member function
<>	149:156823d33999	1822	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	1823	* @param method Member function to attach
<>	149:156823d33999	1824	*/
<>	151:5eaa88a5bcc7	1825	template<typename T, typename U>
<>	151:5eaa88a5bcc7	1826	Callback(U obj, R (T::method)(A0, A1, A2)) {
<>	149:156823d33999	1827	generate(method_context<T, R (T::*)(A0, A1, A2)>(obj, method));
<>	149:156823d33999	1828	}
<>	149:156823d33999	1829
<>	149:156823d33999	1830	/** Create a Callback with a member function
<>	149:156823d33999	1831	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	1832	* @param method Member function to attach
<>	149:156823d33999	1833	*/
<>	151:5eaa88a5bcc7	1834	template<typename T, typename U>
<>	151:5eaa88a5bcc7	1835	Callback(const U obj, R (T::method)(A0, A1, A2) const) {
<>	149:156823d33999	1836	generate(method_context<const T, R (T::*)(A0, A1, A2) const>(obj, method));
<>	149:156823d33999	1837	}
<>	149:156823d33999	1838
<>	149:156823d33999	1839	/** Create a Callback with a member function
<>	149:156823d33999	1840	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	1841	* @param method Member function to attach
<>	149:156823d33999	1842	*/
<>	151:5eaa88a5bcc7	1843	template<typename T, typename U>
<>	151:5eaa88a5bcc7	1844	Callback(volatile U obj, R (T::method)(A0, A1, A2) volatile) {
<>	149:156823d33999	1845	generate(method_context<volatile T, R (T::*)(A0, A1, A2) volatile>(obj, method));
<>	149:156823d33999	1846	}
<>	149:156823d33999	1847
<>	149:156823d33999	1848	/** Create a Callback with a member function
<>	149:156823d33999	1849	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	1850	* @param method Member function to attach
<>	149:156823d33999	1851	*/
<>	151:5eaa88a5bcc7	1852	template<typename T, typename U>
<>	151:5eaa88a5bcc7	1853	Callback(const volatile U obj, R (T::method)(A0, A1, A2) const volatile) {
<>	149:156823d33999	1854	generate(method_context<const volatile T, R (T::*)(A0, A1, A2) const volatile>(obj, method));
<>	149:156823d33999	1855	}
<>	149:156823d33999	1856
<>	149:156823d33999	1857	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	1858	* @param func Static function to attach
<>	149:156823d33999	1859	* @param arg Pointer argument to function
<>	149:156823d33999	1860	*/
<>	151:5eaa88a5bcc7	1861	template<typename T, typename U>
<>	151:5eaa88a5bcc7	1862	Callback(R (func)(T, A0, A1, A2), U *arg) {
<>	149:156823d33999	1863	generate(function_context<R ()(T, A0, A1, A2), T>(func, arg));
<>	149:156823d33999	1864	}
<>	149:156823d33999	1865
<>	149:156823d33999	1866	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	1867	* @param func Static function to attach
<>	149:156823d33999	1868	* @param arg Pointer argument to function
<>	149:156823d33999	1869	*/
<>	151:5eaa88a5bcc7	1870	template<typename T, typename U>
<>	151:5eaa88a5bcc7	1871	Callback(R (func)(const T, A0, A1, A2), const U *arg) {
<>	149:156823d33999	1872	generate(function_context<R ()(const T, A0, A1, A2), const T>(func, arg));
<>	149:156823d33999	1873	}
<>	149:156823d33999	1874
<>	149:156823d33999	1875	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	1876	* @param func Static function to attach
<>	149:156823d33999	1877	* @param arg Pointer argument to function
<>	149:156823d33999	1878	*/
<>	151:5eaa88a5bcc7	1879	template<typename T, typename U>
<>	151:5eaa88a5bcc7	1880	Callback(R (func)(volatile T, A0, A1, A2), volatile U *arg) {
<>	149:156823d33999	1881	generate(function_context<R ()(volatile T, A0, A1, A2), volatile T>(func, arg));
<>	149:156823d33999	1882	}
<>	149:156823d33999	1883
<>	149:156823d33999	1884	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	1885	* @param func Static function to attach
<>	149:156823d33999	1886	* @param arg Pointer argument to function
<>	149:156823d33999	1887	*/
<>	151:5eaa88a5bcc7	1888	template<typename T, typename U>
<>	151:5eaa88a5bcc7	1889	Callback(R (func)(const volatile T, A0, A1, A2), const volatile U *arg) {
<>	149:156823d33999	1890	generate(function_context<R ()(const volatile T, A0, A1, A2), const volatile T>(func, arg));
<>	149:156823d33999	1891	}
<>	149:156823d33999	1892
<>	149:156823d33999	1893	/** Create a Callback with a function object
AnnaBridge	167:e84263d55307	1894	* @param f Function object to attach
<>	149:156823d33999	1895	* @note The function object is limited to a single word of storage
<>	149:156823d33999	1896	*/
<>	149:156823d33999	1897	template <typename F>
AnnaBridge	167:e84263d55307	1898	Callback(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2))) {
<>	149:156823d33999	1899	generate(f);
<>	149:156823d33999	1900	}
<>	149:156823d33999	1901
<>	149:156823d33999	1902	/** Create a Callback with a function object
AnnaBridge	167:e84263d55307	1903	* @param f Function object to attach
<>	149:156823d33999	1904	* @note The function object is limited to a single word of storage
<>	149:156823d33999	1905	*/
<>	149:156823d33999	1906	template <typename F>
AnnaBridge	167:e84263d55307	1907	Callback(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2) const)) {
<>	149:156823d33999	1908	generate(f);
<>	149:156823d33999	1909	}
<>	149:156823d33999	1910
<>	149:156823d33999	1911	/** Create a Callback with a function object
AnnaBridge	167:e84263d55307	1912	* @param f Function object to attach
<>	149:156823d33999	1913	* @note The function object is limited to a single word of storage
<>	149:156823d33999	1914	*/
<>	149:156823d33999	1915	template <typename F>
AnnaBridge	167:e84263d55307	1916	Callback(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2) volatile)) {
<>	149:156823d33999	1917	generate(f);
<>	149:156823d33999	1918	}
<>	149:156823d33999	1919
<>	149:156823d33999	1920	/** Create a Callback with a function object
AnnaBridge	167:e84263d55307	1921	* @param f Function object to attach
<>	149:156823d33999	1922	* @note The function object is limited to a single word of storage
<>	149:156823d33999	1923	*/
<>	149:156823d33999	1924	template <typename F>
AnnaBridge	167:e84263d55307	1925	Callback(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2) const volatile)) {
<>	149:156823d33999	1926	generate(f);
<>	149:156823d33999	1927	}
<>	149:156823d33999	1928
<>	149:156823d33999	1929	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	1930	* @param obj Pointer to object to bind to function
<>	149:156823d33999	1931	* @param func Static function to attach
<>	149:156823d33999	1932	* @deprecated
<>	149:156823d33999	1933	* Arguments to callback have been reordered to Callback(func, arg)
<>	149:156823d33999	1934	*/
<>	151:5eaa88a5bcc7	1935	template<typename T, typename U>
<>	149:156823d33999	1936	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	1937	"Arguments to callback have been reordered to Callback(func, arg)")
<>	151:5eaa88a5bcc7	1938	Callback(U obj, R (func)(T*, A0, A1, A2)) {
<>	149:156823d33999	1939	new (this) Callback(func, obj);
<>	149:156823d33999	1940	}
<>	149:156823d33999	1941
<>	149:156823d33999	1942	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	1943	* @param obj Pointer to object to bind to function
<>	149:156823d33999	1944	* @param func Static function to attach
<>	149:156823d33999	1945	* @deprecated
<>	149:156823d33999	1946	* Arguments to callback have been reordered to Callback(func, arg)
<>	149:156823d33999	1947	*/
<>	151:5eaa88a5bcc7	1948	template<typename T, typename U>
<>	149:156823d33999	1949	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	1950	"Arguments to callback have been reordered to Callback(func, arg)")
<>	151:5eaa88a5bcc7	1951	Callback(const U obj, R (func)(const T*, A0, A1, A2)) {
<>	149:156823d33999	1952	new (this) Callback(func, obj);
<>	149:156823d33999	1953	}
<>	149:156823d33999	1954
<>	149:156823d33999	1955	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	1956	* @param obj Pointer to object to bind to function
<>	149:156823d33999	1957	* @param func Static function to attach
<>	149:156823d33999	1958	* @deprecated
<>	149:156823d33999	1959	* Arguments to callback have been reordered to Callback(func, arg)
<>	149:156823d33999	1960	*/
<>	151:5eaa88a5bcc7	1961	template<typename T, typename U>
<>	149:156823d33999	1962	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	1963	"Arguments to callback have been reordered to Callback(func, arg)")
<>	151:5eaa88a5bcc7	1964	Callback(volatile U obj, R (func)(volatile T*, A0, A1, A2)) {
<>	149:156823d33999	1965	new (this) Callback(func, obj);
<>	149:156823d33999	1966	}
<>	149:156823d33999	1967
<>	149:156823d33999	1968	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	1969	* @param obj Pointer to object to bind to function
<>	149:156823d33999	1970	* @param func Static function to attach
<>	149:156823d33999	1971	* @deprecated
<>	149:156823d33999	1972	* Arguments to callback have been reordered to Callback(func, arg)
<>	149:156823d33999	1973	*/
<>	151:5eaa88a5bcc7	1974	template<typename T, typename U>
<>	149:156823d33999	1975	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	1976	"Arguments to callback have been reordered to Callback(func, arg)")
<>	151:5eaa88a5bcc7	1977	Callback(const volatile U obj, R (func)(const volatile T*, A0, A1, A2)) {
<>	149:156823d33999	1978	new (this) Callback(func, obj);
<>	149:156823d33999	1979	}
<>	149:156823d33999	1980
<>	149:156823d33999	1981	/** Destroy a callback
<>	149:156823d33999	1982	*/
<>	149:156823d33999	1983	~Callback() {
<>	149:156823d33999	1984	if (_ops) {
<>	149:156823d33999	1985	_ops->dtor(this);
<>	149:156823d33999	1986	}
<>	149:156823d33999	1987	}
<>	149:156823d33999	1988
<>	149:156823d33999	1989	/** Attach a static function
<>	149:156823d33999	1990	* @param func Static function to attach
<>	160:d5399cc887bb	1991	* @deprecated
<>	160:d5399cc887bb	1992	* Replaced by simple assignment 'Callback cb = func'
<>	160:d5399cc887bb	1993	*/
<>	160:d5399cc887bb	1994	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	1995	"Replaced by simple assignment 'Callback cb = func")
<>	149:156823d33999	1996	void attach(R (*func)(A0, A1, A2)) {
<>	149:156823d33999	1997	this->~Callback();
<>	149:156823d33999	1998	new (this) Callback(func);
<>	149:156823d33999	1999	}
<>	149:156823d33999	2000
<>	149:156823d33999	2001	/** Attach a Callback
<>	149:156823d33999	2002	* @param func The Callback to attach
<>	160:d5399cc887bb	2003	* @deprecated
<>	160:d5399cc887bb	2004	* Replaced by simple assignment 'Callback cb = func'
<>	160:d5399cc887bb	2005	*/
<>	160:d5399cc887bb	2006	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	2007	"Replaced by simple assignment 'Callback cb = func")
<>	149:156823d33999	2008	void attach(const Callback<R(A0, A1, A2)> &func) {
<>	149:156823d33999	2009	this->~Callback();
<>	149:156823d33999	2010	new (this) Callback(func);
<>	149:156823d33999	2011	}
<>	149:156823d33999	2012
<>	149:156823d33999	2013	/** Attach a member function
<>	149:156823d33999	2014	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	2015	* @param method Member function to attach
<>	160:d5399cc887bb	2016	* @deprecated
<>	160:d5399cc887bb	2017	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	2018	*/
<>	151:5eaa88a5bcc7	2019	template<typename T, typename U>
<>	160:d5399cc887bb	2020	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	2021	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	2022	void attach(U obj, R (T::method)(A0, A1, A2)) {
<>	149:156823d33999	2023	this->~Callback();
<>	149:156823d33999	2024	new (this) Callback(obj, method);
<>	149:156823d33999	2025	}
<>	149:156823d33999	2026
<>	149:156823d33999	2027	/** Attach a member function
<>	149:156823d33999	2028	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	2029	* @param method Member function to attach
<>	160:d5399cc887bb	2030	* @deprecated
<>	160:d5399cc887bb	2031	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	2032	*/
<>	151:5eaa88a5bcc7	2033	template<typename T, typename U>
<>	160:d5399cc887bb	2034	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	2035	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	2036	void attach(const U obj, R (T::method)(A0, A1, A2) const) {
<>	149:156823d33999	2037	this->~Callback();
<>	149:156823d33999	2038	new (this) Callback(obj, method);
<>	149:156823d33999	2039	}
<>	149:156823d33999	2040
<>	149:156823d33999	2041	/** Attach a member function
<>	149:156823d33999	2042	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	2043	* @param method Member function to attach
<>	160:d5399cc887bb	2044	* @deprecated
<>	160:d5399cc887bb	2045	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	2046	*/
<>	151:5eaa88a5bcc7	2047	template<typename T, typename U>
<>	160:d5399cc887bb	2048	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	2049	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	2050	void attach(volatile U obj, R (T::method)(A0, A1, A2) volatile) {
<>	149:156823d33999	2051	this->~Callback();
<>	149:156823d33999	2052	new (this) Callback(obj, method);
<>	149:156823d33999	2053	}
<>	149:156823d33999	2054
<>	149:156823d33999	2055	/** Attach a member function
<>	149:156823d33999	2056	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	2057	* @param method Member function to attach
<>	160:d5399cc887bb	2058	* @deprecated
<>	160:d5399cc887bb	2059	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	2060	*/
<>	151:5eaa88a5bcc7	2061	template<typename T, typename U>
<>	160:d5399cc887bb	2062	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	2063	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	2064	void attach(const volatile U obj, R (T::method)(A0, A1, A2) const volatile) {
<>	149:156823d33999	2065	this->~Callback();
<>	149:156823d33999	2066	new (this) Callback(obj, method);
<>	149:156823d33999	2067	}
<>	149:156823d33999	2068
<>	149:156823d33999	2069	/** Attach a static function with a bound pointer
<>	149:156823d33999	2070	* @param func Static function to attach
<>	149:156823d33999	2071	* @param arg Pointer argument to function
<>	160:d5399cc887bb	2072	* @deprecated
<>	160:d5399cc887bb	2073	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	2074	*/
<>	151:5eaa88a5bcc7	2075	template <typename T, typename U>
<>	160:d5399cc887bb	2076	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	2077	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	2078	void attach(R (func)(T, A0, A1, A2), U *arg) {
<>	149:156823d33999	2079	this->~Callback();
<>	149:156823d33999	2080	new (this) Callback(func, arg);
<>	149:156823d33999	2081	}
<>	149:156823d33999	2082
<>	149:156823d33999	2083	/** Attach a static function with a bound pointer
<>	149:156823d33999	2084	* @param func Static function to attach
<>	149:156823d33999	2085	* @param arg Pointer argument to function
<>	160:d5399cc887bb	2086	* @deprecated
<>	160:d5399cc887bb	2087	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	2088	*/
<>	151:5eaa88a5bcc7	2089	template <typename T, typename U>
<>	160:d5399cc887bb	2090	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	2091	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	2092	void attach(R (func)(const T, A0, A1, A2), const U *arg) {
<>	149:156823d33999	2093	this->~Callback();
<>	149:156823d33999	2094	new (this) Callback(func, arg);
<>	149:156823d33999	2095	}
<>	149:156823d33999	2096
<>	149:156823d33999	2097	/** Attach a static function with a bound pointer
<>	149:156823d33999	2098	* @param func Static function to attach
<>	149:156823d33999	2099	* @param arg Pointer argument to function
<>	160:d5399cc887bb	2100	* @deprecated
<>	160:d5399cc887bb	2101	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	2102	*/
<>	151:5eaa88a5bcc7	2103	template <typename T, typename U>
<>	160:d5399cc887bb	2104	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	2105	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	2106	void attach(R (func)(volatile T, A0, A1, A2), volatile U *arg) {
<>	149:156823d33999	2107	this->~Callback();
<>	149:156823d33999	2108	new (this) Callback(func, arg);
<>	149:156823d33999	2109	}
<>	149:156823d33999	2110
<>	149:156823d33999	2111	/** Attach a static function with a bound pointer
<>	149:156823d33999	2112	* @param func Static function to attach
<>	149:156823d33999	2113	* @param arg Pointer argument to function
<>	160:d5399cc887bb	2114	* @deprecated
<>	160:d5399cc887bb	2115	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	2116	*/
<>	151:5eaa88a5bcc7	2117	template <typename T, typename U>
<>	160:d5399cc887bb	2118	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	2119	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	2120	void attach(R (func)(const volatile T, A0, A1, A2), const volatile U *arg) {
<>	149:156823d33999	2121	this->~Callback();
<>	149:156823d33999	2122	new (this) Callback(func, arg);
<>	149:156823d33999	2123	}
<>	149:156823d33999	2124
<>	149:156823d33999	2125	/** Attach a function object
AnnaBridge	167:e84263d55307	2126	* @param f Function object to attach
<>	149:156823d33999	2127	* @note The function object is limited to a single word of storage
<>	160:d5399cc887bb	2128	* @deprecated
<>	160:d5399cc887bb	2129	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	2130	*/
<>	149:156823d33999	2131	template <typename F>
<>	160:d5399cc887bb	2132	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	2133	"Replaced by simple assignment 'Callback cb = func")
AnnaBridge	167:e84263d55307	2134	void attach(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2))) {
<>	149:156823d33999	2135	this->~Callback();
<>	149:156823d33999	2136	new (this) Callback(f);
<>	149:156823d33999	2137	}
<>	149:156823d33999	2138
<>	149:156823d33999	2139	/** Attach a function object
AnnaBridge	167:e84263d55307	2140	* @param f Function object to attach
<>	149:156823d33999	2141	* @note The function object is limited to a single word of storage
<>	160:d5399cc887bb	2142	* @deprecated
<>	160:d5399cc887bb	2143	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	2144	*/
<>	149:156823d33999	2145	template <typename F>
<>	160:d5399cc887bb	2146	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	2147	"Replaced by simple assignment 'Callback cb = func")
AnnaBridge	167:e84263d55307	2148	void attach(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2) const)) {
<>	149:156823d33999	2149	this->~Callback();
<>	149:156823d33999	2150	new (this) Callback(f);
<>	149:156823d33999	2151	}
<>	149:156823d33999	2152
<>	149:156823d33999	2153	/** Attach a function object
AnnaBridge	167:e84263d55307	2154	* @param f Function object to attach
<>	149:156823d33999	2155	* @note The function object is limited to a single word of storage
<>	160:d5399cc887bb	2156	* @deprecated
<>	160:d5399cc887bb	2157	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	2158	*/
<>	149:156823d33999	2159	template <typename F>
<>	160:d5399cc887bb	2160	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	2161	"Replaced by simple assignment 'Callback cb = func")
AnnaBridge	167:e84263d55307	2162	void attach(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2) volatile)) {
<>	149:156823d33999	2163	this->~Callback();
<>	149:156823d33999	2164	new (this) Callback(f);
<>	149:156823d33999	2165	}
<>	149:156823d33999	2166
<>	149:156823d33999	2167	/** Attach a function object
AnnaBridge	167:e84263d55307	2168	* @param f Function object to attach
<>	149:156823d33999	2169	* @note The function object is limited to a single word of storage
<>	160:d5399cc887bb	2170	* @deprecated
<>	160:d5399cc887bb	2171	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	2172	*/
<>	149:156823d33999	2173	template <typename F>
<>	160:d5399cc887bb	2174	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	2175	"Replaced by simple assignment 'Callback cb = func")
AnnaBridge	167:e84263d55307	2176	void attach(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2) const volatile)) {
<>	149:156823d33999	2177	this->~Callback();
<>	149:156823d33999	2178	new (this) Callback(f);
<>	149:156823d33999	2179	}
<>	149:156823d33999	2180
<>	149:156823d33999	2181	/** Attach a static function with a bound pointer
<>	149:156823d33999	2182	* @param obj Pointer to object to bind to function
<>	149:156823d33999	2183	* @param func Static function to attach
<>	149:156823d33999	2184	* @deprecated
<>	149:156823d33999	2185	* Arguments to callback have been reordered to attach(func, arg)
<>	149:156823d33999	2186	*/
<>	151:5eaa88a5bcc7	2187	template <typename T, typename U>
<>	149:156823d33999	2188	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	2189	"Arguments to callback have been reordered to attach(func, arg)")
<>	151:5eaa88a5bcc7	2190	void attach(U obj, R (func)(T*, A0, A1, A2)) {
<>	149:156823d33999	2191	this->~Callback();
<>	149:156823d33999	2192	new (this) Callback(func, obj);
<>	149:156823d33999	2193	}
<>	149:156823d33999	2194
<>	149:156823d33999	2195	/** Attach a static function with a bound pointer
<>	149:156823d33999	2196	* @param obj Pointer to object to bind to function
<>	149:156823d33999	2197	* @param func Static function to attach
<>	149:156823d33999	2198	* @deprecated
<>	149:156823d33999	2199	* Arguments to callback have been reordered to attach(func, arg)
<>	149:156823d33999	2200	*/
<>	151:5eaa88a5bcc7	2201	template <typename T, typename U>
<>	149:156823d33999	2202	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	2203	"Arguments to callback have been reordered to attach(func, arg)")
<>	151:5eaa88a5bcc7	2204	void attach(const U obj, R (func)(const T*, A0, A1, A2)) {
<>	149:156823d33999	2205	this->~Callback();
<>	149:156823d33999	2206	new (this) Callback(func, obj);
<>	149:156823d33999	2207	}
<>	149:156823d33999	2208
<>	149:156823d33999	2209	/** Attach a static function with a bound pointer
<>	149:156823d33999	2210	* @param obj Pointer to object to bind to function
<>	149:156823d33999	2211	* @param func Static function to attach
<>	149:156823d33999	2212	* @deprecated
<>	149:156823d33999	2213	* Arguments to callback have been reordered to attach(func, arg)
<>	149:156823d33999	2214	*/
<>	151:5eaa88a5bcc7	2215	template <typename T, typename U>
<>	149:156823d33999	2216	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	2217	"Arguments to callback have been reordered to attach(func, arg)")
<>	151:5eaa88a5bcc7	2218	void attach(volatile U obj, R (func)(volatile T*, A0, A1, A2)) {
<>	149:156823d33999	2219	this->~Callback();
<>	149:156823d33999	2220	new (this) Callback(func, obj);
<>	149:156823d33999	2221	}
<>	149:156823d33999	2222
<>	149:156823d33999	2223	/** Attach a static function with a bound pointer
<>	149:156823d33999	2224	* @param obj Pointer to object to bind to function
<>	149:156823d33999	2225	* @param func Static function to attach
<>	149:156823d33999	2226	* @deprecated
<>	149:156823d33999	2227	* Arguments to callback have been reordered to attach(func, arg)
<>	149:156823d33999	2228	*/
<>	151:5eaa88a5bcc7	2229	template <typename T, typename U>
<>	149:156823d33999	2230	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	2231	"Arguments to callback have been reordered to attach(func, arg)")
<>	151:5eaa88a5bcc7	2232	void attach(const volatile U obj, R (func)(const volatile T*, A0, A1, A2)) {
<>	149:156823d33999	2233	this->~Callback();
<>	149:156823d33999	2234	new (this) Callback(func, obj);
<>	149:156823d33999	2235	}
<>	149:156823d33999	2236
<>	149:156823d33999	2237	/** Assign a callback
<>	149:156823d33999	2238	*/
<>	149:156823d33999	2239	Callback &operator=(const Callback &that) {
<>	149:156823d33999	2240	if (this != &that) {
<>	149:156823d33999	2241	this->~Callback();
<>	149:156823d33999	2242	new (this) Callback(that);
<>	149:156823d33999	2243	}
<>	149:156823d33999	2244
<>	149:156823d33999	2245	return *this;
<>	149:156823d33999	2246	}
<>	149:156823d33999	2247
<>	149:156823d33999	2248	/** Call the attached function
<>	149:156823d33999	2249	*/
<>	149:156823d33999	2250	R call(A0 a0, A1 a1, A2 a2) const {
<>	149:156823d33999	2251	MBED_ASSERT(_ops);
<>	149:156823d33999	2252	return _ops->call(this, a0, a1, a2);
<>	149:156823d33999	2253	}
<>	149:156823d33999	2254
<>	149:156823d33999	2255	/** Call the attached function
<>	149:156823d33999	2256	*/
<>	149:156823d33999	2257	R operator()(A0 a0, A1 a1, A2 a2) const {
<>	149:156823d33999	2258	return call(a0, a1, a2);
<>	149:156823d33999	2259	}
<>	149:156823d33999	2260
<>	149:156823d33999	2261	/** Test if function has been attached
<>	149:156823d33999	2262	*/
<>	149:156823d33999	2263	operator bool() const {
<>	149:156823d33999	2264	return _ops;
<>	149:156823d33999	2265	}
<>	149:156823d33999	2266
<>	149:156823d33999	2267	/** Test for equality
<>	149:156823d33999	2268	*/
<>	149:156823d33999	2269	friend bool operator==(const Callback &l, const Callback &r) {
<>	149:156823d33999	2270	return memcmp(&l, &r, sizeof(Callback)) == 0;
<>	149:156823d33999	2271	}
<>	149:156823d33999	2272
<>	149:156823d33999	2273	/** Test for inequality
<>	149:156823d33999	2274	*/
<>	149:156823d33999	2275	friend bool operator!=(const Callback &l, const Callback &r) {
<>	149:156823d33999	2276	return !(l == r);
<>	149:156823d33999	2277	}
<>	149:156823d33999	2278
<>	149:156823d33999	2279	/** Static thunk for passing as C-style function
<>	149:156823d33999	2280	* @param func Callback to call passed as void pointer
AnnaBridge	167:e84263d55307	2281	* @param a0 An argument to be called with function func
AnnaBridge	167:e84263d55307	2282	* @param a1 An argument to be called with function func
AnnaBridge	167:e84263d55307	2283	* @param a2 An argument to be called with function func
AnnaBridge	167:e84263d55307	2284	* @return the value as determined by func which is of
AnnaBridge	167:e84263d55307	2285	* type and determined by the signiture of func
<>	149:156823d33999	2286	*/
<>	149:156823d33999	2287	static R thunk(void *func, A0 a0, A1 a1, A2 a2) {
<>	149:156823d33999	2288	return static_cast<Callback*>(func)->call(a0, a1, a2);
<>	149:156823d33999	2289	}
<>	149:156823d33999	2290
<>	149:156823d33999	2291	private:
<>	149:156823d33999	2292	// Stored as pointer to function and pointer to optional object
<>	149:156823d33999	2293	// Function pointer is stored as union of possible function types
<>	149:156823d33999	2294	// to garuntee proper size and alignment
<>	149:156823d33999	2295	struct _class;
<>	149:156823d33999	2296	union {
<>	149:156823d33999	2297	void (*_staticfunc)(A0, A1, A2);
<>	149:156823d33999	2298	void (_boundfunc)(_class, A0, A1, A2);
<>	149:156823d33999	2299	void (_class::*_methodfunc)(A0, A1, A2);
<>	149:156823d33999	2300	} _func;
<>	149:156823d33999	2301	void *_obj;
<>	149:156823d33999	2302
<>	149:156823d33999	2303	// Dynamically dispatched operations
<>	149:156823d33999	2304	const struct ops {
<>	149:156823d33999	2305	R (call)(const void, A0, A1, A2);
<>	149:156823d33999	2306	void (move)(void, const void*);
<>	149:156823d33999	2307	void (dtor)(void);
<>	149:156823d33999	2308	} *_ops;
<>	149:156823d33999	2309
<>	149:156823d33999	2310	// Generate operations for function object
<>	149:156823d33999	2311	template <typename F>
<>	149:156823d33999	2312	void generate(const F &f) {
<>	149:156823d33999	2313	static const ops ops = {
<>	149:156823d33999	2314	&Callback::function_call<F>,
<>	149:156823d33999	2315	&Callback::function_move<F>,
<>	149:156823d33999	2316	&Callback::function_dtor<F>,
<>	149:156823d33999	2317	};
<>	149:156823d33999	2318
<>	151:5eaa88a5bcc7	2319	MBED_STATIC_ASSERT(sizeof(Callback) - sizeof(_ops) >= sizeof(F),
<>	151:5eaa88a5bcc7	2320	"Type F must not exceed the size of the Callback class");
<>	149:156823d33999	2321	new (this) F(f);
<>	149:156823d33999	2322	_ops = &ops;
<>	149:156823d33999	2323	}
<>	149:156823d33999	2324
<>	149:156823d33999	2325	// Function attributes
<>	149:156823d33999	2326	template <typename F>
<>	149:156823d33999	2327	static R function_call(const void *p, A0 a0, A1 a1, A2 a2) {
<>	149:156823d33999	2328	return ((F)p)(a0, a1, a2);
<>	149:156823d33999	2329	}
<>	149:156823d33999	2330
<>	149:156823d33999	2331	template <typename F>
<>	149:156823d33999	2332	static void function_move(void d, const void p) {
<>	149:156823d33999	2333	new (d) F((F)p);
<>	149:156823d33999	2334	}
<>	149:156823d33999	2335
<>	149:156823d33999	2336	template <typename F>
<>	149:156823d33999	2337	static void function_dtor(void *p) {
<>	149:156823d33999	2338	((F*)p)->~F();
<>	149:156823d33999	2339	}
<>	149:156823d33999	2340
<>	149:156823d33999	2341	// Wrappers for functions with context
<>	149:156823d33999	2342	template <typename O, typename M>
<>	149:156823d33999	2343	struct method_context {
<>	149:156823d33999	2344	M method;
<>	149:156823d33999	2345	O *obj;
<>	149:156823d33999	2346
<>	149:156823d33999	2347	method_context(O *obj, M method)
<>	149:156823d33999	2348	: method(method), obj(obj) {}
<>	149:156823d33999	2349
<>	149:156823d33999	2350	R operator()(A0 a0, A1 a1, A2 a2) const {
<>	149:156823d33999	2351	return (obj->*method)(a0, a1, a2);
<>	149:156823d33999	2352	}
<>	149:156823d33999	2353	};
<>	149:156823d33999	2354
<>	149:156823d33999	2355	template <typename F, typename A>
<>	149:156823d33999	2356	struct function_context {
<>	149:156823d33999	2357	F func;
<>	149:156823d33999	2358	A *arg;
<>	149:156823d33999	2359
<>	149:156823d33999	2360	function_context(F func, A *arg)
<>	149:156823d33999	2361	: func(func), arg(arg) {}
<>	149:156823d33999	2362
<>	149:156823d33999	2363	R operator()(A0 a0, A1 a1, A2 a2) const {
<>	149:156823d33999	2364	return func(arg, a0, a1, a2);
<>	149:156823d33999	2365	}
<>	149:156823d33999	2366	};
<>	149:156823d33999	2367	};
<>	149:156823d33999	2368
<>	149:156823d33999	2369	/** Callback class based on template specialization
<>	149:156823d33999	2370	*
AnnaBridge	167:e84263d55307	2371	* @note Synchronization level: Not protected
AnnaBridge	167:e84263d55307	2372	* @ingroup platform
<>	149:156823d33999	2373	*/
<>	149:156823d33999	2374	template <typename R, typename A0, typename A1, typename A2, typename A3>
<>	149:156823d33999	2375	class Callback<R(A0, A1, A2, A3)> {
<>	149:156823d33999	2376	public:
<>	149:156823d33999	2377	/** Create a Callback with a static function
<>	149:156823d33999	2378	* @param func Static function to attach
<>	149:156823d33999	2379	*/
<>	149:156823d33999	2380	Callback(R (*func)(A0, A1, A2, A3) = 0) {
<>	149:156823d33999	2381	if (!func) {
<>	149:156823d33999	2382	_ops = 0;
<>	149:156823d33999	2383	} else {
<>	149:156823d33999	2384	generate(func);
<>	149:156823d33999	2385	}
<>	149:156823d33999	2386	}
<>	149:156823d33999	2387
<>	149:156823d33999	2388	/** Attach a Callback
<>	149:156823d33999	2389	* @param func The Callback to attach
<>	149:156823d33999	2390	*/
<>	149:156823d33999	2391	Callback(const Callback<R(A0, A1, A2, A3)> &func) {
<>	149:156823d33999	2392	if (func._ops) {
<>	149:156823d33999	2393	func._ops->move(this, &func);
<>	149:156823d33999	2394	}
<>	149:156823d33999	2395	_ops = func._ops;
<>	149:156823d33999	2396	}
<>	149:156823d33999	2397
<>	149:156823d33999	2398	/** Create a Callback with a member function
<>	149:156823d33999	2399	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	2400	* @param method Member function to attach
<>	149:156823d33999	2401	*/
<>	151:5eaa88a5bcc7	2402	template<typename T, typename U>
<>	151:5eaa88a5bcc7	2403	Callback(U obj, R (T::method)(A0, A1, A2, A3)) {
<>	149:156823d33999	2404	generate(method_context<T, R (T::*)(A0, A1, A2, A3)>(obj, method));
<>	149:156823d33999	2405	}
<>	149:156823d33999	2406
<>	149:156823d33999	2407	/** Create a Callback with a member function
<>	149:156823d33999	2408	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	2409	* @param method Member function to attach
<>	149:156823d33999	2410	*/
<>	151:5eaa88a5bcc7	2411	template<typename T, typename U>
<>	151:5eaa88a5bcc7	2412	Callback(const U obj, R (T::method)(A0, A1, A2, A3) const) {
<>	149:156823d33999	2413	generate(method_context<const T, R (T::*)(A0, A1, A2, A3) const>(obj, method));
<>	149:156823d33999	2414	}
<>	149:156823d33999	2415
<>	149:156823d33999	2416	/** Create a Callback with a member function
<>	149:156823d33999	2417	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	2418	* @param method Member function to attach
<>	149:156823d33999	2419	*/
<>	151:5eaa88a5bcc7	2420	template<typename T, typename U>
<>	151:5eaa88a5bcc7	2421	Callback(volatile U obj, R (T::method)(A0, A1, A2, A3) volatile) {
<>	149:156823d33999	2422	generate(method_context<volatile T, R (T::*)(A0, A1, A2, A3) volatile>(obj, method));
<>	149:156823d33999	2423	}
<>	149:156823d33999	2424
<>	149:156823d33999	2425	/** Create a Callback with a member function
<>	149:156823d33999	2426	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	2427	* @param method Member function to attach
<>	149:156823d33999	2428	*/
<>	151:5eaa88a5bcc7	2429	template<typename T, typename U>
<>	151:5eaa88a5bcc7	2430	Callback(const volatile U obj, R (T::method)(A0, A1, A2, A3) const volatile) {
<>	149:156823d33999	2431	generate(method_context<const volatile T, R (T::*)(A0, A1, A2, A3) const volatile>(obj, method));
<>	149:156823d33999	2432	}
<>	149:156823d33999	2433
<>	149:156823d33999	2434	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	2435	* @param func Static function to attach
<>	149:156823d33999	2436	* @param arg Pointer argument to function
<>	149:156823d33999	2437	*/
<>	151:5eaa88a5bcc7	2438	template<typename T, typename U>
<>	151:5eaa88a5bcc7	2439	Callback(R (func)(T, A0, A1, A2, A3), U *arg) {
<>	149:156823d33999	2440	generate(function_context<R ()(T, A0, A1, A2, A3), T>(func, arg));
<>	149:156823d33999	2441	}
<>	149:156823d33999	2442
<>	149:156823d33999	2443	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	2444	* @param func Static function to attach
<>	149:156823d33999	2445	* @param arg Pointer argument to function
<>	149:156823d33999	2446	*/
<>	151:5eaa88a5bcc7	2447	template<typename T, typename U>
<>	151:5eaa88a5bcc7	2448	Callback(R (func)(const T, A0, A1, A2, A3), const U *arg) {
<>	149:156823d33999	2449	generate(function_context<R ()(const T, A0, A1, A2, A3), const T>(func, arg));
<>	149:156823d33999	2450	}
<>	149:156823d33999	2451
<>	149:156823d33999	2452	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	2453	* @param func Static function to attach
<>	149:156823d33999	2454	* @param arg Pointer argument to function
<>	149:156823d33999	2455	*/
<>	151:5eaa88a5bcc7	2456	template<typename T, typename U>
<>	151:5eaa88a5bcc7	2457	Callback(R (func)(volatile T, A0, A1, A2, A3), volatile U *arg) {
<>	149:156823d33999	2458	generate(function_context<R ()(volatile T, A0, A1, A2, A3), volatile T>(func, arg));
<>	149:156823d33999	2459	}
<>	149:156823d33999	2460
<>	149:156823d33999	2461	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	2462	* @param func Static function to attach
<>	149:156823d33999	2463	* @param arg Pointer argument to function
<>	149:156823d33999	2464	*/
<>	151:5eaa88a5bcc7	2465	template<typename T, typename U>
<>	151:5eaa88a5bcc7	2466	Callback(R (func)(const volatile T, A0, A1, A2, A3), const volatile U *arg) {
<>	149:156823d33999	2467	generate(function_context<R ()(const volatile T, A0, A1, A2, A3), const volatile T>(func, arg));
<>	149:156823d33999	2468	}
<>	149:156823d33999	2469
<>	149:156823d33999	2470	/** Create a Callback with a function object
AnnaBridge	167:e84263d55307	2471	* @param f Function object to attach
<>	149:156823d33999	2472	* @note The function object is limited to a single word of storage
<>	149:156823d33999	2473	*/
<>	149:156823d33999	2474	template <typename F>
AnnaBridge	167:e84263d55307	2475	Callback(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3))) {
<>	149:156823d33999	2476	generate(f);
<>	149:156823d33999	2477	}
<>	149:156823d33999	2478
<>	149:156823d33999	2479	/** Create a Callback with a function object
AnnaBridge	167:e84263d55307	2480	* @param f Function object to attach
<>	149:156823d33999	2481	* @note The function object is limited to a single word of storage
<>	149:156823d33999	2482	*/
<>	149:156823d33999	2483	template <typename F>
AnnaBridge	167:e84263d55307	2484	Callback(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3) const)) {
<>	149:156823d33999	2485	generate(f);
<>	149:156823d33999	2486	}
<>	149:156823d33999	2487
<>	149:156823d33999	2488	/** Create a Callback with a function object
AnnaBridge	167:e84263d55307	2489	* @param f Function object to attach
<>	149:156823d33999	2490	* @note The function object is limited to a single word of storage
<>	149:156823d33999	2491	*/
<>	149:156823d33999	2492	template <typename F>
AnnaBridge	167:e84263d55307	2493	Callback(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3) volatile)) {
<>	149:156823d33999	2494	generate(f);
<>	149:156823d33999	2495	}
<>	149:156823d33999	2496
<>	149:156823d33999	2497	/** Create a Callback with a function object
AnnaBridge	167:e84263d55307	2498	* @param f Function object to attach
<>	149:156823d33999	2499	* @note The function object is limited to a single word of storage
<>	149:156823d33999	2500	*/
<>	149:156823d33999	2501	template <typename F>
AnnaBridge	167:e84263d55307	2502	Callback(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3) const volatile)) {
<>	149:156823d33999	2503	generate(f);
<>	149:156823d33999	2504	}
<>	149:156823d33999	2505
<>	149:156823d33999	2506	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	2507	* @param obj Pointer to object to bind to function
<>	149:156823d33999	2508	* @param func Static function to attach
<>	149:156823d33999	2509	* @deprecated
<>	149:156823d33999	2510	* Arguments to callback have been reordered to Callback(func, arg)
<>	149:156823d33999	2511	*/
<>	151:5eaa88a5bcc7	2512	template<typename T, typename U>
<>	149:156823d33999	2513	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	2514	"Arguments to callback have been reordered to Callback(func, arg)")
<>	151:5eaa88a5bcc7	2515	Callback(U obj, R (func)(T*, A0, A1, A2, A3)) {
<>	149:156823d33999	2516	new (this) Callback(func, obj);
<>	149:156823d33999	2517	}
<>	149:156823d33999	2518
<>	149:156823d33999	2519	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	2520	* @param obj Pointer to object to bind to function
<>	149:156823d33999	2521	* @param func Static function to attach
<>	149:156823d33999	2522	* @deprecated
<>	149:156823d33999	2523	* Arguments to callback have been reordered to Callback(func, arg)
<>	149:156823d33999	2524	*/
<>	151:5eaa88a5bcc7	2525	template<typename T, typename U>
<>	149:156823d33999	2526	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	2527	"Arguments to callback have been reordered to Callback(func, arg)")
<>	151:5eaa88a5bcc7	2528	Callback(const U obj, R (func)(const T*, A0, A1, A2, A3)) {
<>	149:156823d33999	2529	new (this) Callback(func, obj);
<>	149:156823d33999	2530	}
<>	149:156823d33999	2531
<>	149:156823d33999	2532	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	2533	* @param obj Pointer to object to bind to function
<>	149:156823d33999	2534	* @param func Static function to attach
<>	149:156823d33999	2535	* @deprecated
<>	149:156823d33999	2536	* Arguments to callback have been reordered to Callback(func, arg)
<>	149:156823d33999	2537	*/
<>	151:5eaa88a5bcc7	2538	template<typename T, typename U>
<>	149:156823d33999	2539	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	2540	"Arguments to callback have been reordered to Callback(func, arg)")
<>	151:5eaa88a5bcc7	2541	Callback(volatile U obj, R (func)(volatile T*, A0, A1, A2, A3)) {
<>	149:156823d33999	2542	new (this) Callback(func, obj);
<>	149:156823d33999	2543	}
<>	149:156823d33999	2544
<>	149:156823d33999	2545	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	2546	* @param obj Pointer to object to bind to function
<>	149:156823d33999	2547	* @param func Static function to attach
<>	149:156823d33999	2548	* @deprecated
<>	149:156823d33999	2549	* Arguments to callback have been reordered to Callback(func, arg)
<>	149:156823d33999	2550	*/
<>	151:5eaa88a5bcc7	2551	template<typename T, typename U>
<>	149:156823d33999	2552	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	2553	"Arguments to callback have been reordered to Callback(func, arg)")
<>	151:5eaa88a5bcc7	2554	Callback(const volatile U obj, R (func)(const volatile T*, A0, A1, A2, A3)) {
<>	149:156823d33999	2555	new (this) Callback(func, obj);
<>	149:156823d33999	2556	}
<>	149:156823d33999	2557
<>	149:156823d33999	2558	/** Destroy a callback
<>	149:156823d33999	2559	*/
<>	149:156823d33999	2560	~Callback() {
<>	149:156823d33999	2561	if (_ops) {
<>	149:156823d33999	2562	_ops->dtor(this);
<>	149:156823d33999	2563	}
<>	149:156823d33999	2564	}
<>	149:156823d33999	2565
<>	149:156823d33999	2566	/** Attach a static function
<>	149:156823d33999	2567	* @param func Static function to attach
<>	160:d5399cc887bb	2568	* @deprecated
<>	160:d5399cc887bb	2569	* Replaced by simple assignment 'Callback cb = func'
<>	160:d5399cc887bb	2570	*/
<>	160:d5399cc887bb	2571	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	2572	"Replaced by simple assignment 'Callback cb = func")
<>	149:156823d33999	2573	void attach(R (*func)(A0, A1, A2, A3)) {
<>	149:156823d33999	2574	this->~Callback();
<>	149:156823d33999	2575	new (this) Callback(func);
<>	149:156823d33999	2576	}
<>	149:156823d33999	2577
<>	149:156823d33999	2578	/** Attach a Callback
<>	149:156823d33999	2579	* @param func The Callback to attach
<>	160:d5399cc887bb	2580	* @deprecated
<>	160:d5399cc887bb	2581	* Replaced by simple assignment 'Callback cb = func'
<>	160:d5399cc887bb	2582	*/
<>	160:d5399cc887bb	2583	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	2584	"Replaced by simple assignment 'Callback cb = func")
<>	149:156823d33999	2585	void attach(const Callback<R(A0, A1, A2, A3)> &func) {
<>	149:156823d33999	2586	this->~Callback();
<>	149:156823d33999	2587	new (this) Callback(func);
<>	149:156823d33999	2588	}
<>	149:156823d33999	2589
<>	149:156823d33999	2590	/** Attach a member function
<>	149:156823d33999	2591	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	2592	* @param method Member function to attach
<>	160:d5399cc887bb	2593	* @deprecated
<>	160:d5399cc887bb	2594	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	2595	*/
<>	151:5eaa88a5bcc7	2596	template<typename T, typename U>
<>	160:d5399cc887bb	2597	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	2598	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	2599	void attach(U obj, R (T::method)(A0, A1, A2, A3)) {
<>	149:156823d33999	2600	this->~Callback();
<>	149:156823d33999	2601	new (this) Callback(obj, method);
<>	149:156823d33999	2602	}
<>	149:156823d33999	2603
<>	149:156823d33999	2604	/** Attach a member function
<>	149:156823d33999	2605	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	2606	* @param method Member function to attach
<>	160:d5399cc887bb	2607	* @deprecated
<>	160:d5399cc887bb	2608	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	2609	*/
<>	151:5eaa88a5bcc7	2610	template<typename T, typename U>
<>	160:d5399cc887bb	2611	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	2612	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	2613	void attach(const U obj, R (T::method)(A0, A1, A2, A3) const) {
<>	149:156823d33999	2614	this->~Callback();
<>	149:156823d33999	2615	new (this) Callback(obj, method);
<>	149:156823d33999	2616	}
<>	149:156823d33999	2617
<>	149:156823d33999	2618	/** Attach a member function
<>	149:156823d33999	2619	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	2620	* @param method Member function to attach
<>	160:d5399cc887bb	2621	* @deprecated
<>	160:d5399cc887bb	2622	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	2623	*/
<>	151:5eaa88a5bcc7	2624	template<typename T, typename U>
<>	160:d5399cc887bb	2625	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	2626	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	2627	void attach(volatile U obj, R (T::method)(A0, A1, A2, A3) volatile) {
<>	149:156823d33999	2628	this->~Callback();
<>	149:156823d33999	2629	new (this) Callback(obj, method);
<>	149:156823d33999	2630	}
<>	149:156823d33999	2631
<>	149:156823d33999	2632	/** Attach a member function
<>	149:156823d33999	2633	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	2634	* @param method Member function to attach
<>	160:d5399cc887bb	2635	* @deprecated
<>	160:d5399cc887bb	2636	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	2637	*/
<>	151:5eaa88a5bcc7	2638	template<typename T, typename U>
<>	160:d5399cc887bb	2639	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	2640	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	2641	void attach(const volatile U obj, R (T::method)(A0, A1, A2, A3) const volatile) {
<>	149:156823d33999	2642	this->~Callback();
<>	149:156823d33999	2643	new (this) Callback(obj, method);
<>	149:156823d33999	2644	}
<>	149:156823d33999	2645
<>	149:156823d33999	2646	/** Attach a static function with a bound pointer
<>	149:156823d33999	2647	* @param func Static function to attach
<>	149:156823d33999	2648	* @param arg Pointer argument to function
<>	160:d5399cc887bb	2649	* @deprecated
<>	160:d5399cc887bb	2650	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	2651	*/
<>	151:5eaa88a5bcc7	2652	template <typename T, typename U>
<>	160:d5399cc887bb	2653	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	2654	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	2655	void attach(R (func)(T, A0, A1, A2, A3), U *arg) {
<>	149:156823d33999	2656	this->~Callback();
<>	149:156823d33999	2657	new (this) Callback(func, arg);
<>	149:156823d33999	2658	}
<>	149:156823d33999	2659
<>	149:156823d33999	2660	/** Attach a static function with a bound pointer
<>	149:156823d33999	2661	* @param func Static function to attach
<>	149:156823d33999	2662	* @param arg Pointer argument to function
<>	160:d5399cc887bb	2663	* @deprecated
<>	160:d5399cc887bb	2664	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	2665	*/
<>	151:5eaa88a5bcc7	2666	template <typename T, typename U>
<>	160:d5399cc887bb	2667	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	2668	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	2669	void attach(R (func)(const T, A0, A1, A2, A3), const U *arg) {
<>	149:156823d33999	2670	this->~Callback();
<>	149:156823d33999	2671	new (this) Callback(func, arg);
<>	149:156823d33999	2672	}
<>	149:156823d33999	2673
<>	149:156823d33999	2674	/** Attach a static function with a bound pointer
<>	149:156823d33999	2675	* @param func Static function to attach
<>	149:156823d33999	2676	* @param arg Pointer argument to function
<>	160:d5399cc887bb	2677	* @deprecated
<>	160:d5399cc887bb	2678	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	2679	*/
<>	151:5eaa88a5bcc7	2680	template <typename T, typename U>
<>	160:d5399cc887bb	2681	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	2682	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	2683	void attach(R (func)(volatile T, A0, A1, A2, A3), volatile U *arg) {
<>	149:156823d33999	2684	this->~Callback();
<>	149:156823d33999	2685	new (this) Callback(func, arg);
<>	149:156823d33999	2686	}
<>	149:156823d33999	2687
<>	149:156823d33999	2688	/** Attach a static function with a bound pointer
<>	149:156823d33999	2689	* @param func Static function to attach
<>	149:156823d33999	2690	* @param arg Pointer argument to function
<>	160:d5399cc887bb	2691	* @deprecated
<>	160:d5399cc887bb	2692	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	2693	*/
<>	151:5eaa88a5bcc7	2694	template <typename T, typename U>
<>	160:d5399cc887bb	2695	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	2696	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	2697	void attach(R (func)(const volatile T, A0, A1, A2, A3), const volatile U *arg) {
<>	149:156823d33999	2698	this->~Callback();
<>	149:156823d33999	2699	new (this) Callback(func, arg);
<>	149:156823d33999	2700	}
<>	149:156823d33999	2701
<>	149:156823d33999	2702	/** Attach a function object
AnnaBridge	167:e84263d55307	2703	* @param f Function object to attach
<>	149:156823d33999	2704	* @note The function object is limited to a single word of storage
<>	160:d5399cc887bb	2705	* @deprecated
<>	160:d5399cc887bb	2706	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	2707	*/
<>	149:156823d33999	2708	template <typename F>
<>	160:d5399cc887bb	2709	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	2710	"Replaced by simple assignment 'Callback cb = func")
AnnaBridge	167:e84263d55307	2711	void attach(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3))) {
<>	149:156823d33999	2712	this->~Callback();
<>	149:156823d33999	2713	new (this) Callback(f);
<>	149:156823d33999	2714	}
<>	149:156823d33999	2715
<>	149:156823d33999	2716	/** Attach a function object
AnnaBridge	167:e84263d55307	2717	* @param f Function object to attach
<>	149:156823d33999	2718	* @note The function object is limited to a single word of storage
<>	160:d5399cc887bb	2719	* @deprecated
<>	160:d5399cc887bb	2720	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	2721	*/
<>	149:156823d33999	2722	template <typename F>
<>	160:d5399cc887bb	2723	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	2724	"Replaced by simple assignment 'Callback cb = func")
AnnaBridge	167:e84263d55307	2725	void attach(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3) const)) {
<>	149:156823d33999	2726	this->~Callback();
<>	149:156823d33999	2727	new (this) Callback(f);
<>	149:156823d33999	2728	}
<>	149:156823d33999	2729
<>	149:156823d33999	2730	/** Attach a function object
AnnaBridge	167:e84263d55307	2731	* @param f Function object to attach
<>	149:156823d33999	2732	* @note The function object is limited to a single word of storage
<>	160:d5399cc887bb	2733	* @deprecated
<>	160:d5399cc887bb	2734	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	2735	*/
<>	149:156823d33999	2736	template <typename F>
<>	160:d5399cc887bb	2737	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	2738	"Replaced by simple assignment 'Callback cb = func")
AnnaBridge	167:e84263d55307	2739	void attach(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3) volatile)) {
<>	149:156823d33999	2740	this->~Callback();
<>	149:156823d33999	2741	new (this) Callback(f);
<>	149:156823d33999	2742	}
<>	149:156823d33999	2743
<>	149:156823d33999	2744	/** Attach a function object
AnnaBridge	167:e84263d55307	2745	* @param f Function object to attach
<>	149:156823d33999	2746	* @note The function object is limited to a single word of storage
<>	160:d5399cc887bb	2747	* @deprecated
<>	160:d5399cc887bb	2748	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	2749	*/
<>	149:156823d33999	2750	template <typename F>
<>	160:d5399cc887bb	2751	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	2752	"Replaced by simple assignment 'Callback cb = func")
AnnaBridge	167:e84263d55307	2753	void attach(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3) const volatile)) {
<>	149:156823d33999	2754	this->~Callback();
<>	149:156823d33999	2755	new (this) Callback(f);
<>	149:156823d33999	2756	}
<>	149:156823d33999	2757
<>	149:156823d33999	2758	/** Attach a static function with a bound pointer
<>	149:156823d33999	2759	* @param obj Pointer to object to bind to function
<>	149:156823d33999	2760	* @param func Static function to attach
<>	149:156823d33999	2761	* @deprecated
<>	149:156823d33999	2762	* Arguments to callback have been reordered to attach(func, arg)
<>	149:156823d33999	2763	*/
<>	151:5eaa88a5bcc7	2764	template <typename T, typename U>
<>	149:156823d33999	2765	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	2766	"Arguments to callback have been reordered to attach(func, arg)")
<>	151:5eaa88a5bcc7	2767	void attach(U obj, R (func)(T*, A0, A1, A2, A3)) {
<>	149:156823d33999	2768	this->~Callback();
<>	149:156823d33999	2769	new (this) Callback(func, obj);
<>	149:156823d33999	2770	}
<>	149:156823d33999	2771
<>	149:156823d33999	2772	/** Attach a static function with a bound pointer
<>	149:156823d33999	2773	* @param obj Pointer to object to bind to function
<>	149:156823d33999	2774	* @param func Static function to attach
<>	149:156823d33999	2775	* @deprecated
<>	149:156823d33999	2776	* Arguments to callback have been reordered to attach(func, arg)
<>	149:156823d33999	2777	*/
<>	151:5eaa88a5bcc7	2778	template <typename T, typename U>
<>	149:156823d33999	2779	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	2780	"Arguments to callback have been reordered to attach(func, arg)")
<>	151:5eaa88a5bcc7	2781	void attach(const U obj, R (func)(const T*, A0, A1, A2, A3)) {
<>	149:156823d33999	2782	this->~Callback();
<>	149:156823d33999	2783	new (this) Callback(func, obj);
<>	149:156823d33999	2784	}
<>	149:156823d33999	2785
<>	149:156823d33999	2786	/** Attach a static function with a bound pointer
<>	149:156823d33999	2787	* @param obj Pointer to object to bind to function
<>	149:156823d33999	2788	* @param func Static function to attach
<>	149:156823d33999	2789	* @deprecated
<>	149:156823d33999	2790	* Arguments to callback have been reordered to attach(func, arg)
<>	149:156823d33999	2791	*/
<>	151:5eaa88a5bcc7	2792	template <typename T, typename U>
<>	149:156823d33999	2793	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	2794	"Arguments to callback have been reordered to attach(func, arg)")
<>	151:5eaa88a5bcc7	2795	void attach(volatile U obj, R (func)(volatile T*, A0, A1, A2, A3)) {
<>	149:156823d33999	2796	this->~Callback();
<>	149:156823d33999	2797	new (this) Callback(func, obj);
<>	149:156823d33999	2798	}
<>	149:156823d33999	2799
<>	149:156823d33999	2800	/** Attach a static function with a bound pointer
<>	149:156823d33999	2801	* @param obj Pointer to object to bind to function
<>	149:156823d33999	2802	* @param func Static function to attach
<>	149:156823d33999	2803	* @deprecated
<>	149:156823d33999	2804	* Arguments to callback have been reordered to attach(func, arg)
<>	149:156823d33999	2805	*/
<>	151:5eaa88a5bcc7	2806	template <typename T, typename U>
<>	149:156823d33999	2807	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	2808	"Arguments to callback have been reordered to attach(func, arg)")
<>	151:5eaa88a5bcc7	2809	void attach(const volatile U obj, R (func)(const volatile T*, A0, A1, A2, A3)) {
<>	149:156823d33999	2810	this->~Callback();
<>	149:156823d33999	2811	new (this) Callback(func, obj);
<>	149:156823d33999	2812	}
<>	149:156823d33999	2813
<>	149:156823d33999	2814	/** Assign a callback
<>	149:156823d33999	2815	*/
<>	149:156823d33999	2816	Callback &operator=(const Callback &that) {
<>	149:156823d33999	2817	if (this != &that) {
<>	149:156823d33999	2818	this->~Callback();
<>	149:156823d33999	2819	new (this) Callback(that);
<>	149:156823d33999	2820	}
<>	149:156823d33999	2821
<>	149:156823d33999	2822	return *this;
<>	149:156823d33999	2823	}
<>	149:156823d33999	2824
<>	149:156823d33999	2825	/** Call the attached function
<>	149:156823d33999	2826	*/
<>	149:156823d33999	2827	R call(A0 a0, A1 a1, A2 a2, A3 a3) const {
<>	149:156823d33999	2828	MBED_ASSERT(_ops);
<>	149:156823d33999	2829	return _ops->call(this, a0, a1, a2, a3);
<>	149:156823d33999	2830	}
<>	149:156823d33999	2831
<>	149:156823d33999	2832	/** Call the attached function
<>	149:156823d33999	2833	*/
<>	149:156823d33999	2834	R operator()(A0 a0, A1 a1, A2 a2, A3 a3) const {
<>	149:156823d33999	2835	return call(a0, a1, a2, a3);
<>	149:156823d33999	2836	}
<>	149:156823d33999	2837
<>	149:156823d33999	2838	/** Test if function has been attached
<>	149:156823d33999	2839	*/
<>	149:156823d33999	2840	operator bool() const {
<>	149:156823d33999	2841	return _ops;
<>	149:156823d33999	2842	}
<>	149:156823d33999	2843
<>	149:156823d33999	2844	/** Test for equality
<>	149:156823d33999	2845	*/
<>	149:156823d33999	2846	friend bool operator==(const Callback &l, const Callback &r) {
<>	149:156823d33999	2847	return memcmp(&l, &r, sizeof(Callback)) == 0;
<>	149:156823d33999	2848	}
<>	149:156823d33999	2849
<>	149:156823d33999	2850	/** Test for inequality
<>	149:156823d33999	2851	*/
<>	149:156823d33999	2852	friend bool operator!=(const Callback &l, const Callback &r) {
<>	149:156823d33999	2853	return !(l == r);
<>	149:156823d33999	2854	}
<>	149:156823d33999	2855
<>	149:156823d33999	2856	/** Static thunk for passing as C-style function
<>	149:156823d33999	2857	* @param func Callback to call passed as void pointer
AnnaBridge	167:e84263d55307	2858	* @param a0 An argument to be called with function func
AnnaBridge	167:e84263d55307	2859	* @param a1 An argument to be called with function func
AnnaBridge	167:e84263d55307	2860	* @param a2 An argument to be called with function func
AnnaBridge	167:e84263d55307	2861	* @param a3 An argument to be called with function func
AnnaBridge	167:e84263d55307	2862	* @return the value as determined by func which is of
AnnaBridge	167:e84263d55307	2863	* type and determined by the signiture of func
<>	149:156823d33999	2864	*/
<>	149:156823d33999	2865	static R thunk(void *func, A0 a0, A1 a1, A2 a2, A3 a3) {
<>	149:156823d33999	2866	return static_cast<Callback*>(func)->call(a0, a1, a2, a3);
<>	149:156823d33999	2867	}
<>	149:156823d33999	2868
<>	149:156823d33999	2869	private:
<>	149:156823d33999	2870	// Stored as pointer to function and pointer to optional object
<>	149:156823d33999	2871	// Function pointer is stored as union of possible function types
<>	149:156823d33999	2872	// to garuntee proper size and alignment
<>	149:156823d33999	2873	struct _class;
<>	149:156823d33999	2874	union {
<>	149:156823d33999	2875	void (*_staticfunc)(A0, A1, A2, A3);
<>	149:156823d33999	2876	void (_boundfunc)(_class, A0, A1, A2, A3);
<>	149:156823d33999	2877	void (_class::*_methodfunc)(A0, A1, A2, A3);
<>	149:156823d33999	2878	} _func;
<>	149:156823d33999	2879	void *_obj;
<>	149:156823d33999	2880
<>	149:156823d33999	2881	// Dynamically dispatched operations
<>	149:156823d33999	2882	const struct ops {
<>	149:156823d33999	2883	R (call)(const void, A0, A1, A2, A3);
<>	149:156823d33999	2884	void (move)(void, const void*);
<>	149:156823d33999	2885	void (dtor)(void);
<>	149:156823d33999	2886	} *_ops;
<>	149:156823d33999	2887
<>	149:156823d33999	2888	// Generate operations for function object
<>	149:156823d33999	2889	template <typename F>
<>	149:156823d33999	2890	void generate(const F &f) {
<>	149:156823d33999	2891	static const ops ops = {
<>	149:156823d33999	2892	&Callback::function_call<F>,
<>	149:156823d33999	2893	&Callback::function_move<F>,
<>	149:156823d33999	2894	&Callback::function_dtor<F>,
<>	149:156823d33999	2895	};
<>	149:156823d33999	2896
<>	151:5eaa88a5bcc7	2897	MBED_STATIC_ASSERT(sizeof(Callback) - sizeof(_ops) >= sizeof(F),
<>	151:5eaa88a5bcc7	2898	"Type F must not exceed the size of the Callback class");
<>	149:156823d33999	2899	new (this) F(f);
<>	149:156823d33999	2900	_ops = &ops;
<>	149:156823d33999	2901	}
<>	149:156823d33999	2902
<>	149:156823d33999	2903	// Function attributes
<>	149:156823d33999	2904	template <typename F>
<>	149:156823d33999	2905	static R function_call(const void *p, A0 a0, A1 a1, A2 a2, A3 a3) {
<>	149:156823d33999	2906	return ((F)p)(a0, a1, a2, a3);
<>	149:156823d33999	2907	}
<>	149:156823d33999	2908
<>	149:156823d33999	2909	template <typename F>
<>	149:156823d33999	2910	static void function_move(void d, const void p) {
<>	149:156823d33999	2911	new (d) F((F)p);
<>	149:156823d33999	2912	}
<>	149:156823d33999	2913
<>	149:156823d33999	2914	template <typename F>
<>	149:156823d33999	2915	static void function_dtor(void *p) {
<>	149:156823d33999	2916	((F*)p)->~F();
<>	149:156823d33999	2917	}
<>	149:156823d33999	2918
<>	149:156823d33999	2919	// Wrappers for functions with context
<>	149:156823d33999	2920	template <typename O, typename M>
<>	149:156823d33999	2921	struct method_context {
<>	149:156823d33999	2922	M method;
<>	149:156823d33999	2923	O *obj;
<>	149:156823d33999	2924
<>	149:156823d33999	2925	method_context(O *obj, M method)
<>	149:156823d33999	2926	: method(method), obj(obj) {}
<>	149:156823d33999	2927
<>	149:156823d33999	2928	R operator()(A0 a0, A1 a1, A2 a2, A3 a3) const {
<>	149:156823d33999	2929	return (obj->*method)(a0, a1, a2, a3);
<>	149:156823d33999	2930	}
<>	149:156823d33999	2931	};
<>	149:156823d33999	2932
<>	149:156823d33999	2933	template <typename F, typename A>
<>	149:156823d33999	2934	struct function_context {
<>	149:156823d33999	2935	F func;
<>	149:156823d33999	2936	A *arg;
<>	149:156823d33999	2937
<>	149:156823d33999	2938	function_context(F func, A *arg)
<>	149:156823d33999	2939	: func(func), arg(arg) {}
<>	149:156823d33999	2940
<>	149:156823d33999	2941	R operator()(A0 a0, A1 a1, A2 a2, A3 a3) const {
<>	149:156823d33999	2942	return func(arg, a0, a1, a2, a3);
<>	149:156823d33999	2943	}
<>	149:156823d33999	2944	};
<>	149:156823d33999	2945	};
<>	149:156823d33999	2946
<>	149:156823d33999	2947	/** Callback class based on template specialization
<>	149:156823d33999	2948	*
AnnaBridge	167:e84263d55307	2949	* @note Synchronization level: Not protected
AnnaBridge	167:e84263d55307	2950	* @ingroup platform
<>	149:156823d33999	2951	*/
<>	149:156823d33999	2952	template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
<>	149:156823d33999	2953	class Callback<R(A0, A1, A2, A3, A4)> {
<>	149:156823d33999	2954	public:
<>	149:156823d33999	2955	/** Create a Callback with a static function
<>	149:156823d33999	2956	* @param func Static function to attach
<>	149:156823d33999	2957	*/
<>	149:156823d33999	2958	Callback(R (*func)(A0, A1, A2, A3, A4) = 0) {
<>	149:156823d33999	2959	if (!func) {
<>	149:156823d33999	2960	_ops = 0;
<>	149:156823d33999	2961	} else {
<>	149:156823d33999	2962	generate(func);
<>	149:156823d33999	2963	}
<>	149:156823d33999	2964	}
<>	149:156823d33999	2965
<>	149:156823d33999	2966	/** Attach a Callback
<>	149:156823d33999	2967	* @param func The Callback to attach
<>	149:156823d33999	2968	*/
<>	149:156823d33999	2969	Callback(const Callback<R(A0, A1, A2, A3, A4)> &func) {
<>	149:156823d33999	2970	if (func._ops) {
<>	149:156823d33999	2971	func._ops->move(this, &func);
<>	149:156823d33999	2972	}
<>	149:156823d33999	2973	_ops = func._ops;
<>	149:156823d33999	2974	}
<>	149:156823d33999	2975
<>	149:156823d33999	2976	/** Create a Callback with a member function
<>	149:156823d33999	2977	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	2978	* @param method Member function to attach
<>	149:156823d33999	2979	*/
<>	151:5eaa88a5bcc7	2980	template<typename T, typename U>
<>	151:5eaa88a5bcc7	2981	Callback(U obj, R (T::method)(A0, A1, A2, A3, A4)) {
<>	149:156823d33999	2982	generate(method_context<T, R (T::*)(A0, A1, A2, A3, A4)>(obj, method));
<>	149:156823d33999	2983	}
<>	149:156823d33999	2984
<>	149:156823d33999	2985	/** Create a Callback with a member function
<>	149:156823d33999	2986	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	2987	* @param method Member function to attach
<>	149:156823d33999	2988	*/
<>	151:5eaa88a5bcc7	2989	template<typename T, typename U>
<>	151:5eaa88a5bcc7	2990	Callback(const U obj, R (T::method)(A0, A1, A2, A3, A4) const) {
<>	149:156823d33999	2991	generate(method_context<const T, R (T::*)(A0, A1, A2, A3, A4) const>(obj, method));
<>	149:156823d33999	2992	}
<>	149:156823d33999	2993
<>	149:156823d33999	2994	/** Create a Callback with a member function
<>	149:156823d33999	2995	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	2996	* @param method Member function to attach
<>	149:156823d33999	2997	*/
<>	151:5eaa88a5bcc7	2998	template<typename T, typename U>
<>	151:5eaa88a5bcc7	2999	Callback(volatile U obj, R (T::method)(A0, A1, A2, A3, A4) volatile) {
<>	149:156823d33999	3000	generate(method_context<volatile T, R (T::*)(A0, A1, A2, A3, A4) volatile>(obj, method));
<>	149:156823d33999	3001	}
<>	149:156823d33999	3002
<>	149:156823d33999	3003	/** Create a Callback with a member function
<>	149:156823d33999	3004	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	3005	* @param method Member function to attach
<>	149:156823d33999	3006	*/
<>	151:5eaa88a5bcc7	3007	template<typename T, typename U>
<>	151:5eaa88a5bcc7	3008	Callback(const volatile U obj, R (T::method)(A0, A1, A2, A3, A4) const volatile) {
<>	149:156823d33999	3009	generate(method_context<const volatile T, R (T::*)(A0, A1, A2, A3, A4) const volatile>(obj, method));
<>	149:156823d33999	3010	}
<>	149:156823d33999	3011
<>	149:156823d33999	3012	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	3013	* @param func Static function to attach
<>	149:156823d33999	3014	* @param arg Pointer argument to function
<>	149:156823d33999	3015	*/
<>	151:5eaa88a5bcc7	3016	template<typename T, typename U>
<>	151:5eaa88a5bcc7	3017	Callback(R (func)(T, A0, A1, A2, A3, A4), U *arg) {
<>	149:156823d33999	3018	generate(function_context<R ()(T, A0, A1, A2, A3, A4), T>(func, arg));
<>	149:156823d33999	3019	}
<>	149:156823d33999	3020
<>	149:156823d33999	3021	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	3022	* @param func Static function to attach
<>	149:156823d33999	3023	* @param arg Pointer argument to function
<>	149:156823d33999	3024	*/
<>	151:5eaa88a5bcc7	3025	template<typename T, typename U>
<>	151:5eaa88a5bcc7	3026	Callback(R (func)(const T, A0, A1, A2, A3, A4), const U *arg) {
<>	149:156823d33999	3027	generate(function_context<R ()(const T, A0, A1, A2, A3, A4), const T>(func, arg));
<>	149:156823d33999	3028	}
<>	149:156823d33999	3029
<>	149:156823d33999	3030	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	3031	* @param func Static function to attach
<>	149:156823d33999	3032	* @param arg Pointer argument to function
<>	149:156823d33999	3033	*/
<>	151:5eaa88a5bcc7	3034	template<typename T, typename U>
<>	151:5eaa88a5bcc7	3035	Callback(R (func)(volatile T, A0, A1, A2, A3, A4), volatile U *arg) {
<>	149:156823d33999	3036	generate(function_context<R ()(volatile T, A0, A1, A2, A3, A4), volatile T>(func, arg));
<>	149:156823d33999	3037	}
<>	149:156823d33999	3038
<>	149:156823d33999	3039	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	3040	* @param func Static function to attach
<>	149:156823d33999	3041	* @param arg Pointer argument to function
<>	149:156823d33999	3042	*/
<>	151:5eaa88a5bcc7	3043	template<typename T, typename U>
<>	151:5eaa88a5bcc7	3044	Callback(R (func)(const volatile T, A0, A1, A2, A3, A4), const volatile U *arg) {
<>	149:156823d33999	3045	generate(function_context<R ()(const volatile T, A0, A1, A2, A3, A4), const volatile T>(func, arg));
<>	149:156823d33999	3046	}
<>	149:156823d33999	3047
<>	149:156823d33999	3048	/** Create a Callback with a function object
AnnaBridge	167:e84263d55307	3049	* @param f Function object to attach
<>	149:156823d33999	3050	* @note The function object is limited to a single word of storage
<>	149:156823d33999	3051	*/
<>	149:156823d33999	3052	template <typename F>
AnnaBridge	167:e84263d55307	3053	Callback(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3, A4))) {
<>	149:156823d33999	3054	generate(f);
<>	149:156823d33999	3055	}
<>	149:156823d33999	3056
<>	149:156823d33999	3057	/** Create a Callback with a function object
AnnaBridge	167:e84263d55307	3058	* @param f Function object to attach
<>	149:156823d33999	3059	* @note The function object is limited to a single word of storage
<>	149:156823d33999	3060	*/
<>	149:156823d33999	3061	template <typename F>
AnnaBridge	167:e84263d55307	3062	Callback(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3, A4) const)) {
<>	149:156823d33999	3063	generate(f);
<>	149:156823d33999	3064	}
<>	149:156823d33999	3065
<>	149:156823d33999	3066	/** Create a Callback with a function object
AnnaBridge	167:e84263d55307	3067	* @param f Function object to attach
<>	149:156823d33999	3068	* @note The function object is limited to a single word of storage
<>	149:156823d33999	3069	*/
<>	149:156823d33999	3070	template <typename F>
AnnaBridge	167:e84263d55307	3071	Callback(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3, A4) volatile)) {
<>	149:156823d33999	3072	generate(f);
<>	149:156823d33999	3073	}
<>	149:156823d33999	3074
<>	149:156823d33999	3075	/** Create a Callback with a function object
AnnaBridge	167:e84263d55307	3076	* @param f Function object to attach
<>	149:156823d33999	3077	* @note The function object is limited to a single word of storage
<>	149:156823d33999	3078	*/
<>	149:156823d33999	3079	template <typename F>
AnnaBridge	167:e84263d55307	3080	Callback(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3, A4) const volatile)) {
<>	149:156823d33999	3081	generate(f);
<>	149:156823d33999	3082	}
<>	149:156823d33999	3083
<>	149:156823d33999	3084	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	3085	* @param obj Pointer to object to bind to function
<>	149:156823d33999	3086	* @param func Static function to attach
<>	149:156823d33999	3087	* @deprecated
<>	149:156823d33999	3088	* Arguments to callback have been reordered to Callback(func, arg)
<>	149:156823d33999	3089	*/
<>	151:5eaa88a5bcc7	3090	template<typename T, typename U>
<>	149:156823d33999	3091	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	3092	"Arguments to callback have been reordered to Callback(func, arg)")
<>	151:5eaa88a5bcc7	3093	Callback(U obj, R (func)(T*, A0, A1, A2, A3, A4)) {
<>	149:156823d33999	3094	new (this) Callback(func, obj);
<>	149:156823d33999	3095	}
<>	149:156823d33999	3096
<>	149:156823d33999	3097	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	3098	* @param obj Pointer to object to bind to function
<>	149:156823d33999	3099	* @param func Static function to attach
<>	149:156823d33999	3100	* @deprecated
<>	149:156823d33999	3101	* Arguments to callback have been reordered to Callback(func, arg)
<>	149:156823d33999	3102	*/
<>	151:5eaa88a5bcc7	3103	template<typename T, typename U>
<>	149:156823d33999	3104	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	3105	"Arguments to callback have been reordered to Callback(func, arg)")
<>	151:5eaa88a5bcc7	3106	Callback(const U obj, R (func)(const T*, A0, A1, A2, A3, A4)) {
<>	149:156823d33999	3107	new (this) Callback(func, obj);
<>	149:156823d33999	3108	}
<>	149:156823d33999	3109
<>	149:156823d33999	3110	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	3111	* @param obj Pointer to object to bind to function
<>	149:156823d33999	3112	* @param func Static function to attach
<>	149:156823d33999	3113	* @deprecated
<>	149:156823d33999	3114	* Arguments to callback have been reordered to Callback(func, arg)
<>	149:156823d33999	3115	*/
<>	151:5eaa88a5bcc7	3116	template<typename T, typename U>
<>	149:156823d33999	3117	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	3118	"Arguments to callback have been reordered to Callback(func, arg)")
<>	151:5eaa88a5bcc7	3119	Callback(volatile U obj, R (func)(volatile T*, A0, A1, A2, A3, A4)) {
<>	149:156823d33999	3120	new (this) Callback(func, obj);
<>	149:156823d33999	3121	}
<>	149:156823d33999	3122
<>	149:156823d33999	3123	/** Create a Callback with a static function and bound pointer
<>	149:156823d33999	3124	* @param obj Pointer to object to bind to function
<>	149:156823d33999	3125	* @param func Static function to attach
<>	149:156823d33999	3126	* @deprecated
<>	149:156823d33999	3127	* Arguments to callback have been reordered to Callback(func, arg)
<>	149:156823d33999	3128	*/
<>	151:5eaa88a5bcc7	3129	template<typename T, typename U>
<>	149:156823d33999	3130	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	3131	"Arguments to callback have been reordered to Callback(func, arg)")
<>	151:5eaa88a5bcc7	3132	Callback(const volatile U obj, R (func)(const volatile T*, A0, A1, A2, A3, A4)) {
<>	149:156823d33999	3133	new (this) Callback(func, obj);
<>	149:156823d33999	3134	}
<>	149:156823d33999	3135
<>	149:156823d33999	3136	/** Destroy a callback
<>	149:156823d33999	3137	*/
<>	149:156823d33999	3138	~Callback() {
<>	149:156823d33999	3139	if (_ops) {
<>	149:156823d33999	3140	_ops->dtor(this);
<>	149:156823d33999	3141	}
<>	149:156823d33999	3142	}
<>	149:156823d33999	3143
<>	149:156823d33999	3144	/** Attach a static function
<>	149:156823d33999	3145	* @param func Static function to attach
<>	160:d5399cc887bb	3146	* @deprecated
<>	160:d5399cc887bb	3147	* Replaced by simple assignment 'Callback cb = func'
<>	160:d5399cc887bb	3148	*/
<>	160:d5399cc887bb	3149	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	3150	"Replaced by simple assignment 'Callback cb = func")
<>	149:156823d33999	3151	void attach(R (*func)(A0, A1, A2, A3, A4)) {
<>	149:156823d33999	3152	this->~Callback();
<>	149:156823d33999	3153	new (this) Callback(func);
<>	149:156823d33999	3154	}
<>	149:156823d33999	3155
<>	149:156823d33999	3156	/** Attach a Callback
<>	149:156823d33999	3157	* @param func The Callback to attach
<>	160:d5399cc887bb	3158	* @deprecated
<>	160:d5399cc887bb	3159	* Replaced by simple assignment 'Callback cb = func'
<>	160:d5399cc887bb	3160	*/
<>	160:d5399cc887bb	3161	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	3162	"Replaced by simple assignment 'Callback cb = func")
<>	149:156823d33999	3163	void attach(const Callback<R(A0, A1, A2, A3, A4)> &func) {
<>	149:156823d33999	3164	this->~Callback();
<>	149:156823d33999	3165	new (this) Callback(func);
<>	149:156823d33999	3166	}
<>	149:156823d33999	3167
<>	149:156823d33999	3168	/** Attach a member function
<>	149:156823d33999	3169	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	3170	* @param method Member function to attach
<>	160:d5399cc887bb	3171	* @deprecated
<>	160:d5399cc887bb	3172	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	3173	*/
<>	151:5eaa88a5bcc7	3174	template<typename T, typename U>
<>	160:d5399cc887bb	3175	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	3176	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	3177	void attach(U obj, R (T::method)(A0, A1, A2, A3, A4)) {
<>	149:156823d33999	3178	this->~Callback();
<>	149:156823d33999	3179	new (this) Callback(obj, method);
<>	149:156823d33999	3180	}
<>	149:156823d33999	3181
<>	149:156823d33999	3182	/** Attach a member function
<>	149:156823d33999	3183	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	3184	* @param method Member function to attach
<>	160:d5399cc887bb	3185	* @deprecated
<>	160:d5399cc887bb	3186	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	3187	*/
<>	151:5eaa88a5bcc7	3188	template<typename T, typename U>
<>	160:d5399cc887bb	3189	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	3190	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	3191	void attach(const U obj, R (T::method)(A0, A1, A2, A3, A4) const) {
<>	149:156823d33999	3192	this->~Callback();
<>	149:156823d33999	3193	new (this) Callback(obj, method);
<>	149:156823d33999	3194	}
<>	149:156823d33999	3195
<>	149:156823d33999	3196	/** Attach a member function
<>	149:156823d33999	3197	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	3198	* @param method Member function to attach
<>	160:d5399cc887bb	3199	* @deprecated
<>	160:d5399cc887bb	3200	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	3201	*/
<>	151:5eaa88a5bcc7	3202	template<typename T, typename U>
<>	160:d5399cc887bb	3203	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	3204	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	3205	void attach(volatile U obj, R (T::method)(A0, A1, A2, A3, A4) volatile) {
<>	149:156823d33999	3206	this->~Callback();
<>	149:156823d33999	3207	new (this) Callback(obj, method);
<>	149:156823d33999	3208	}
<>	149:156823d33999	3209
<>	149:156823d33999	3210	/** Attach a member function
<>	149:156823d33999	3211	* @param obj Pointer to object to invoke member function on
<>	149:156823d33999	3212	* @param method Member function to attach
<>	160:d5399cc887bb	3213	* @deprecated
<>	160:d5399cc887bb	3214	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	3215	*/
<>	151:5eaa88a5bcc7	3216	template<typename T, typename U>
<>	160:d5399cc887bb	3217	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	3218	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	3219	void attach(const volatile U obj, R (T::method)(A0, A1, A2, A3, A4) const volatile) {
<>	149:156823d33999	3220	this->~Callback();
<>	149:156823d33999	3221	new (this) Callback(obj, method);
<>	149:156823d33999	3222	}
<>	149:156823d33999	3223
<>	149:156823d33999	3224	/** Attach a static function with a bound pointer
<>	149:156823d33999	3225	* @param func Static function to attach
<>	149:156823d33999	3226	* @param arg Pointer argument to function
<>	160:d5399cc887bb	3227	* @deprecated
<>	160:d5399cc887bb	3228	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	3229	*/
<>	151:5eaa88a5bcc7	3230	template <typename T, typename U>
<>	160:d5399cc887bb	3231	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	3232	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	3233	void attach(R (func)(T, A0, A1, A2, A3, A4), U *arg) {
<>	149:156823d33999	3234	this->~Callback();
<>	149:156823d33999	3235	new (this) Callback(func, arg);
<>	149:156823d33999	3236	}
<>	149:156823d33999	3237
<>	149:156823d33999	3238	/** Attach a static function with a bound pointer
<>	149:156823d33999	3239	* @param func Static function to attach
<>	149:156823d33999	3240	* @param arg Pointer argument to function
<>	160:d5399cc887bb	3241	* @deprecated
<>	160:d5399cc887bb	3242	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	3243	*/
<>	151:5eaa88a5bcc7	3244	template <typename T, typename U>
<>	160:d5399cc887bb	3245	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	3246	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	3247	void attach(R (func)(const T, A0, A1, A2, A3, A4), const U *arg) {
<>	149:156823d33999	3248	this->~Callback();
<>	149:156823d33999	3249	new (this) Callback(func, arg);
<>	149:156823d33999	3250	}
<>	149:156823d33999	3251
<>	149:156823d33999	3252	/** Attach a static function with a bound pointer
<>	149:156823d33999	3253	* @param func Static function to attach
<>	149:156823d33999	3254	* @param arg Pointer argument to function
<>	160:d5399cc887bb	3255	* @deprecated
<>	160:d5399cc887bb	3256	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	3257	*/
<>	151:5eaa88a5bcc7	3258	template <typename T, typename U>
<>	160:d5399cc887bb	3259	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	3260	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	3261	void attach(R (func)(volatile T, A0, A1, A2, A3, A4), volatile U *arg) {
<>	149:156823d33999	3262	this->~Callback();
<>	149:156823d33999	3263	new (this) Callback(func, arg);
<>	149:156823d33999	3264	}
<>	149:156823d33999	3265
<>	149:156823d33999	3266	/** Attach a static function with a bound pointer
<>	149:156823d33999	3267	* @param func Static function to attach
<>	149:156823d33999	3268	* @param arg Pointer argument to function
<>	160:d5399cc887bb	3269	* @deprecated
<>	160:d5399cc887bb	3270	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	3271	*/
<>	151:5eaa88a5bcc7	3272	template <typename T, typename U>
<>	160:d5399cc887bb	3273	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	3274	"Replaced by simple assignment 'Callback cb = func")
<>	151:5eaa88a5bcc7	3275	void attach(R (func)(const volatile T, A0, A1, A2, A3, A4), const volatile U *arg) {
<>	149:156823d33999	3276	this->~Callback();
<>	149:156823d33999	3277	new (this) Callback(func, arg);
<>	149:156823d33999	3278	}
<>	149:156823d33999	3279
<>	149:156823d33999	3280	/** Attach a function object
AnnaBridge	167:e84263d55307	3281	* @param f Function object to attach
<>	149:156823d33999	3282	* @note The function object is limited to a single word of storage
<>	160:d5399cc887bb	3283	* @deprecated
<>	160:d5399cc887bb	3284	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	3285	*/
<>	149:156823d33999	3286	template <typename F>
<>	160:d5399cc887bb	3287	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	3288	"Replaced by simple assignment 'Callback cb = func")
AnnaBridge	167:e84263d55307	3289	void attach(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3, A4))) {
<>	149:156823d33999	3290	this->~Callback();
<>	149:156823d33999	3291	new (this) Callback(f);
<>	149:156823d33999	3292	}
<>	149:156823d33999	3293
<>	149:156823d33999	3294	/** Attach a function object
AnnaBridge	167:e84263d55307	3295	* @param f Function object to attach
<>	149:156823d33999	3296	* @note The function object is limited to a single word of storage
<>	160:d5399cc887bb	3297	* @deprecated
<>	160:d5399cc887bb	3298	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	3299	*/
<>	149:156823d33999	3300	template <typename F>
<>	160:d5399cc887bb	3301	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	3302	"Replaced by simple assignment 'Callback cb = func")
AnnaBridge	167:e84263d55307	3303	void attach(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3, A4) const)) {
<>	149:156823d33999	3304	this->~Callback();
<>	149:156823d33999	3305	new (this) Callback(f);
<>	149:156823d33999	3306	}
<>	149:156823d33999	3307
<>	149:156823d33999	3308	/** Attach a function object
AnnaBridge	167:e84263d55307	3309	* @param f Function object to attach
<>	149:156823d33999	3310	* @note The function object is limited to a single word of storage
<>	160:d5399cc887bb	3311	* @deprecated
<>	160:d5399cc887bb	3312	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	3313	*/
<>	149:156823d33999	3314	template <typename F>
<>	160:d5399cc887bb	3315	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	3316	"Replaced by simple assignment 'Callback cb = func")
AnnaBridge	167:e84263d55307	3317	void attach(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3, A4) volatile)) {
<>	149:156823d33999	3318	this->~Callback();
<>	149:156823d33999	3319	new (this) Callback(f);
<>	149:156823d33999	3320	}
<>	149:156823d33999	3321
<>	149:156823d33999	3322	/** Attach a function object
AnnaBridge	167:e84263d55307	3323	* @param f Function object to attach
<>	149:156823d33999	3324	* @note The function object is limited to a single word of storage
<>	160:d5399cc887bb	3325	* @deprecated
<>	160:d5399cc887bb	3326	* Replaced by simple assignment 'Callback cb = func'
<>	149:156823d33999	3327	*/
<>	149:156823d33999	3328	template <typename F>
<>	160:d5399cc887bb	3329	MBED_DEPRECATED_SINCE("mbed-os-5.4",
<>	160:d5399cc887bb	3330	"Replaced by simple assignment 'Callback cb = func")
AnnaBridge	167:e84263d55307	3331	void attach(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3, A4) const volatile)) {
<>	149:156823d33999	3332	this->~Callback();
<>	149:156823d33999	3333	new (this) Callback(f);
<>	149:156823d33999	3334	}
<>	149:156823d33999	3335
<>	149:156823d33999	3336	/** Attach a static function with a bound pointer
<>	149:156823d33999	3337	* @param obj Pointer to object to bind to function
<>	149:156823d33999	3338	* @param func Static function to attach
<>	149:156823d33999	3339	* @deprecated
<>	149:156823d33999	3340	* Arguments to callback have been reordered to attach(func, arg)
<>	149:156823d33999	3341	*/
<>	151:5eaa88a5bcc7	3342	template <typename T, typename U>
<>	149:156823d33999	3343	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	3344	"Arguments to callback have been reordered to attach(func, arg)")
<>	151:5eaa88a5bcc7	3345	void attach(U obj, R (func)(T*, A0, A1, A2, A3, A4)) {
<>	149:156823d33999	3346	this->~Callback();
<>	149:156823d33999	3347	new (this) Callback(func, obj);
<>	149:156823d33999	3348	}
<>	149:156823d33999	3349
<>	149:156823d33999	3350	/** Attach a static function with a bound pointer
<>	149:156823d33999	3351	* @param obj Pointer to object to bind to function
<>	149:156823d33999	3352	* @param func Static function to attach
<>	149:156823d33999	3353	* @deprecated
<>	149:156823d33999	3354	* Arguments to callback have been reordered to attach(func, arg)
<>	149:156823d33999	3355	*/
<>	151:5eaa88a5bcc7	3356	template <typename T, typename U>
<>	149:156823d33999	3357	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	3358	"Arguments to callback have been reordered to attach(func, arg)")
<>	151:5eaa88a5bcc7	3359	void attach(const U obj, R (func)(const T*, A0, A1, A2, A3, A4)) {
<>	149:156823d33999	3360	this->~Callback();
<>	149:156823d33999	3361	new (this) Callback(func, obj);
<>	149:156823d33999	3362	}
<>	149:156823d33999	3363
<>	149:156823d33999	3364	/** Attach a static function with a bound pointer
<>	149:156823d33999	3365	* @param obj Pointer to object to bind to function
<>	149:156823d33999	3366	* @param func Static function to attach
<>	149:156823d33999	3367	* @deprecated
<>	149:156823d33999	3368	* Arguments to callback have been reordered to attach(func, arg)
<>	149:156823d33999	3369	*/
<>	151:5eaa88a5bcc7	3370	template <typename T, typename U>
<>	149:156823d33999	3371	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	3372	"Arguments to callback have been reordered to attach(func, arg)")
<>	151:5eaa88a5bcc7	3373	void attach(volatile U obj, R (func)(volatile T*, A0, A1, A2, A3, A4)) {
<>	149:156823d33999	3374	this->~Callback();
<>	149:156823d33999	3375	new (this) Callback(func, obj);
<>	149:156823d33999	3376	}
<>	149:156823d33999	3377
<>	149:156823d33999	3378	/** Attach a static function with a bound pointer
<>	149:156823d33999	3379	* @param obj Pointer to object to bind to function
<>	149:156823d33999	3380	* @param func Static function to attach
<>	149:156823d33999	3381	* @deprecated
<>	149:156823d33999	3382	* Arguments to callback have been reordered to attach(func, arg)
<>	149:156823d33999	3383	*/
<>	151:5eaa88a5bcc7	3384	template <typename T, typename U>
<>	149:156823d33999	3385	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	3386	"Arguments to callback have been reordered to attach(func, arg)")
<>	151:5eaa88a5bcc7	3387	void attach(const volatile U obj, R (func)(const volatile T*, A0, A1, A2, A3, A4)) {
<>	149:156823d33999	3388	this->~Callback();
<>	149:156823d33999	3389	new (this) Callback(func, obj);
<>	149:156823d33999	3390	}
<>	149:156823d33999	3391
<>	149:156823d33999	3392	/** Assign a callback
<>	149:156823d33999	3393	*/
<>	149:156823d33999	3394	Callback &operator=(const Callback &that) {
<>	149:156823d33999	3395	if (this != &that) {
<>	149:156823d33999	3396	this->~Callback();
<>	149:156823d33999	3397	new (this) Callback(that);
<>	149:156823d33999	3398	}
<>	149:156823d33999	3399
<>	149:156823d33999	3400	return *this;
<>	149:156823d33999	3401	}
<>	149:156823d33999	3402
<>	149:156823d33999	3403	/** Call the attached function
<>	149:156823d33999	3404	*/
<>	149:156823d33999	3405	R call(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const {
<>	149:156823d33999	3406	MBED_ASSERT(_ops);
<>	149:156823d33999	3407	return _ops->call(this, a0, a1, a2, a3, a4);
<>	149:156823d33999	3408	}
<>	149:156823d33999	3409
<>	149:156823d33999	3410	/** Call the attached function
<>	149:156823d33999	3411	*/
<>	149:156823d33999	3412	R operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const {
<>	149:156823d33999	3413	return call(a0, a1, a2, a3, a4);
<>	149:156823d33999	3414	}
<>	149:156823d33999	3415
<>	149:156823d33999	3416	/** Test if function has been attached
<>	149:156823d33999	3417	*/
<>	149:156823d33999	3418	operator bool() const {
<>	149:156823d33999	3419	return _ops;
<>	149:156823d33999	3420	}
<>	149:156823d33999	3421
<>	149:156823d33999	3422	/** Test for equality
<>	149:156823d33999	3423	*/
<>	149:156823d33999	3424	friend bool operator==(const Callback &l, const Callback &r) {
<>	149:156823d33999	3425	return memcmp(&l, &r, sizeof(Callback)) == 0;
<>	149:156823d33999	3426	}
<>	149:156823d33999	3427
<>	149:156823d33999	3428	/** Test for inequality
<>	149:156823d33999	3429	*/
<>	149:156823d33999	3430	friend bool operator!=(const Callback &l, const Callback &r) {
<>	149:156823d33999	3431	return !(l == r);
<>	149:156823d33999	3432	}
<>	149:156823d33999	3433
<>	149:156823d33999	3434	/** Static thunk for passing as C-style function
<>	149:156823d33999	3435	* @param func Callback to call passed as void pointer
AnnaBridge	167:e84263d55307	3436	* @param a0 An argument to be called with function func
AnnaBridge	167:e84263d55307	3437	* @param a1 An argument to be called with function func
AnnaBridge	167:e84263d55307	3438	* @param a2 An argument to be called with function func
AnnaBridge	167:e84263d55307	3439	* @param a3 An argument to be called with function func
AnnaBridge	167:e84263d55307	3440	* @param a4 An argument to be called with function func
AnnaBridge	167:e84263d55307	3441	* @return the value as determined by func which is of
AnnaBridge	167:e84263d55307	3442	* type and determined by the signiture of func
<>	149:156823d33999	3443	*/
<>	149:156823d33999	3444	static R thunk(void *func, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
<>	149:156823d33999	3445	return static_cast<Callback*>(func)->call(a0, a1, a2, a3, a4);
<>	149:156823d33999	3446	}
<>	149:156823d33999	3447
<>	149:156823d33999	3448	private:
<>	149:156823d33999	3449	// Stored as pointer to function and pointer to optional object
<>	149:156823d33999	3450	// Function pointer is stored as union of possible function types
<>	149:156823d33999	3451	// to garuntee proper size and alignment
<>	149:156823d33999	3452	struct _class;
<>	149:156823d33999	3453	union {
<>	149:156823d33999	3454	void (*_staticfunc)(A0, A1, A2, A3, A4);
<>	149:156823d33999	3455	void (_boundfunc)(_class, A0, A1, A2, A3, A4);
<>	149:156823d33999	3456	void (_class::*_methodfunc)(A0, A1, A2, A3, A4);
<>	149:156823d33999	3457	} _func;
<>	149:156823d33999	3458	void *_obj;
<>	149:156823d33999	3459
<>	149:156823d33999	3460	// Dynamically dispatched operations
<>	149:156823d33999	3461	const struct ops {
<>	149:156823d33999	3462	R (call)(const void, A0, A1, A2, A3, A4);
<>	149:156823d33999	3463	void (move)(void, const void*);
<>	149:156823d33999	3464	void (dtor)(void);
<>	149:156823d33999	3465	} *_ops;
<>	149:156823d33999	3466
<>	149:156823d33999	3467	// Generate operations for function object
<>	149:156823d33999	3468	template <typename F>
<>	149:156823d33999	3469	void generate(const F &f) {
<>	149:156823d33999	3470	static const ops ops = {
<>	149:156823d33999	3471	&Callback::function_call<F>,
<>	149:156823d33999	3472	&Callback::function_move<F>,
<>	149:156823d33999	3473	&Callback::function_dtor<F>,
<>	149:156823d33999	3474	};
<>	149:156823d33999	3475
<>	151:5eaa88a5bcc7	3476	MBED_STATIC_ASSERT(sizeof(Callback) - sizeof(_ops) >= sizeof(F),
<>	151:5eaa88a5bcc7	3477	"Type F must not exceed the size of the Callback class");
<>	149:156823d33999	3478	new (this) F(f);
<>	149:156823d33999	3479	_ops = &ops;
<>	149:156823d33999	3480	}
<>	149:156823d33999	3481
<>	149:156823d33999	3482	// Function attributes
<>	149:156823d33999	3483	template <typename F>
<>	149:156823d33999	3484	static R function_call(const void *p, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
<>	149:156823d33999	3485	return ((F)p)(a0, a1, a2, a3, a4);
<>	149:156823d33999	3486	}
<>	149:156823d33999	3487
<>	149:156823d33999	3488	template <typename F>
<>	149:156823d33999	3489	static void function_move(void d, const void p) {
<>	149:156823d33999	3490	new (d) F((F)p);
<>	149:156823d33999	3491	}
<>	149:156823d33999	3492
<>	149:156823d33999	3493	template <typename F>
<>	149:156823d33999	3494	static void function_dtor(void *p) {
<>	149:156823d33999	3495	((F*)p)->~F();
<>	149:156823d33999	3496	}
<>	149:156823d33999	3497
<>	149:156823d33999	3498	// Wrappers for functions with context
<>	149:156823d33999	3499	template <typename O, typename M>
<>	149:156823d33999	3500	struct method_context {
<>	149:156823d33999	3501	M method;
<>	149:156823d33999	3502	O *obj;
<>	149:156823d33999	3503
<>	149:156823d33999	3504	method_context(O *obj, M method)
<>	149:156823d33999	3505	: method(method), obj(obj) {}
<>	149:156823d33999	3506
<>	149:156823d33999	3507	R operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const {
<>	149:156823d33999	3508	return (obj->*method)(a0, a1, a2, a3, a4);
<>	149:156823d33999	3509	}
<>	149:156823d33999	3510	};
<>	149:156823d33999	3511
<>	149:156823d33999	3512	template <typename F, typename A>
<>	149:156823d33999	3513	struct function_context {
<>	149:156823d33999	3514	F func;
<>	149:156823d33999	3515	A *arg;
<>	149:156823d33999	3516
<>	149:156823d33999	3517	function_context(F func, A *arg)
<>	149:156823d33999	3518	: func(func), arg(arg) {}
<>	149:156823d33999	3519
<>	149:156823d33999	3520	R operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const {
<>	149:156823d33999	3521	return func(arg, a0, a1, a2, a3, a4);
<>	149:156823d33999	3522	}
<>	149:156823d33999	3523	};
<>	149:156823d33999	3524	};
<>	149:156823d33999	3525
<>	149:156823d33999	3526	// Internally used event type
<>	149:156823d33999	3527	typedef Callback<void(int)> event_callback_t;
<>	149:156823d33999	3528
<>	149:156823d33999	3529
<>	149:156823d33999	3530	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3531	*
<>	149:156823d33999	3532	* @param func Static function to attach
<>	149:156823d33999	3533	* @return Callback with infered type
<>	149:156823d33999	3534	*/
<>	149:156823d33999	3535	template <typename R>
<>	149:156823d33999	3536	Callback<R()> callback(R (*func)() = 0) {
<>	149:156823d33999	3537	return Callback<R()>(func);
<>	149:156823d33999	3538	}
<>	149:156823d33999	3539
<>	149:156823d33999	3540	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3541	*
<>	149:156823d33999	3542	* @param func Static function to attach
<>	149:156823d33999	3543	* @return Callback with infered type
<>	149:156823d33999	3544	*/
<>	149:156823d33999	3545	template <typename R>
<>	149:156823d33999	3546	Callback<R()> callback(const Callback<R()> &func) {
<>	149:156823d33999	3547	return Callback<R()>(func);
<>	149:156823d33999	3548	}
<>	149:156823d33999	3549
<>	149:156823d33999	3550	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3551	*
<>	149:156823d33999	3552	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	3553	* @param method Member function to attach
<>	149:156823d33999	3554	* @return Callback with infered type
<>	149:156823d33999	3555	*/
<>	151:5eaa88a5bcc7	3556	template<typename T, typename U, typename R>
<>	151:5eaa88a5bcc7	3557	Callback<R()> callback(U obj, R (T::method)()) {
<>	151:5eaa88a5bcc7	3558	return Callback<R()>(obj, method);
<>	149:156823d33999	3559	}
<>	149:156823d33999	3560
<>	149:156823d33999	3561	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3562	*
<>	149:156823d33999	3563	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	3564	* @param method Member function to attach
<>	149:156823d33999	3565	* @return Callback with infered type
<>	149:156823d33999	3566	*/
<>	151:5eaa88a5bcc7	3567	template<typename T, typename U, typename R>
<>	151:5eaa88a5bcc7	3568	Callback<R()> callback(const U obj, R (T::method)() const) {
<>	151:5eaa88a5bcc7	3569	return Callback<R()>(obj, method);
<>	149:156823d33999	3570	}
<>	149:156823d33999	3571
<>	149:156823d33999	3572	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3573	*
<>	149:156823d33999	3574	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	3575	* @param method Member function to attach
<>	149:156823d33999	3576	* @return Callback with infered type
<>	149:156823d33999	3577	*/
<>	151:5eaa88a5bcc7	3578	template<typename T, typename U, typename R>
<>	151:5eaa88a5bcc7	3579	Callback<R()> callback(volatile U obj, R (T::method)() volatile) {
<>	151:5eaa88a5bcc7	3580	return Callback<R()>(obj, method);
<>	149:156823d33999	3581	}
<>	149:156823d33999	3582
<>	149:156823d33999	3583	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3584	*
<>	149:156823d33999	3585	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	3586	* @param method Member function to attach
<>	149:156823d33999	3587	* @return Callback with infered type
<>	149:156823d33999	3588	*/
<>	151:5eaa88a5bcc7	3589	template<typename T, typename U, typename R>
<>	151:5eaa88a5bcc7	3590	Callback<R()> callback(const volatile U obj, R (T::method)() const volatile) {
<>	151:5eaa88a5bcc7	3591	return Callback<R()>(obj, method);
<>	149:156823d33999	3592	}
<>	149:156823d33999	3593
<>	149:156823d33999	3594	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3595	*
<>	149:156823d33999	3596	* @param func Static function to attach
<>	149:156823d33999	3597	* @param arg Pointer argument to function
<>	149:156823d33999	3598	* @return Callback with infered type
<>	149:156823d33999	3599	*/
<>	151:5eaa88a5bcc7	3600	template <typename T, typename U, typename R>
<>	151:5eaa88a5bcc7	3601	Callback<R()> callback(R (func)(T), U *arg) {
<>	149:156823d33999	3602	return Callback<R()>(func, arg);
<>	149:156823d33999	3603	}
<>	149:156823d33999	3604
<>	149:156823d33999	3605	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3606	*
<>	149:156823d33999	3607	* @param func Static function to attach
<>	149:156823d33999	3608	* @param arg Pointer argument to function
<>	149:156823d33999	3609	* @return Callback with infered type
<>	149:156823d33999	3610	*/
<>	151:5eaa88a5bcc7	3611	template <typename T, typename U, typename R>
<>	151:5eaa88a5bcc7	3612	Callback<R()> callback(R (func)(const T), const U *arg) {
<>	149:156823d33999	3613	return Callback<R()>(func, arg);
<>	149:156823d33999	3614	}
<>	149:156823d33999	3615
<>	149:156823d33999	3616	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3617	*
<>	149:156823d33999	3618	* @param func Static function to attach
<>	149:156823d33999	3619	* @param arg Pointer argument to function
<>	149:156823d33999	3620	* @return Callback with infered type
<>	149:156823d33999	3621	*/
<>	151:5eaa88a5bcc7	3622	template <typename T, typename U, typename R>
<>	151:5eaa88a5bcc7	3623	Callback<R()> callback(R (func)(volatile T), volatile U *arg) {
<>	149:156823d33999	3624	return Callback<R()>(func, arg);
<>	149:156823d33999	3625	}
<>	149:156823d33999	3626
<>	149:156823d33999	3627	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3628	*
<>	149:156823d33999	3629	* @param func Static function to attach
<>	149:156823d33999	3630	* @param arg Pointer argument to function
<>	149:156823d33999	3631	* @return Callback with infered type
<>	149:156823d33999	3632	*/
<>	151:5eaa88a5bcc7	3633	template <typename T, typename U, typename R>
<>	151:5eaa88a5bcc7	3634	Callback<R()> callback(R (func)(const volatile T), const volatile U *arg) {
<>	149:156823d33999	3635	return Callback<R()>(func, arg);
<>	149:156823d33999	3636	}
<>	149:156823d33999	3637
<>	149:156823d33999	3638	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3639	*
<>	149:156823d33999	3640	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	3641	* @param func Static function to attach
<>	149:156823d33999	3642	* @return Callback with infered type
<>	149:156823d33999	3643	* @deprecated
<>	149:156823d33999	3644	* Arguments to callback have been reordered to callback(func, arg)
<>	149:156823d33999	3645	*/
<>	151:5eaa88a5bcc7	3646	template <typename T, typename U, typename R>
<>	149:156823d33999	3647	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	3648	"Arguments to callback have been reordered to callback(func, arg)")
<>	151:5eaa88a5bcc7	3649	Callback<R()> callback(U obj, R (func)(T*)) {
<>	149:156823d33999	3650	return Callback<R()>(func, obj);
<>	149:156823d33999	3651	}
<>	149:156823d33999	3652
<>	149:156823d33999	3653	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3654	*
<>	149:156823d33999	3655	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	3656	* @param func Static function to attach
<>	149:156823d33999	3657	* @return Callback with infered type
<>	149:156823d33999	3658	* @deprecated
<>	149:156823d33999	3659	* Arguments to callback have been reordered to callback(func, arg)
<>	149:156823d33999	3660	*/
<>	151:5eaa88a5bcc7	3661	template <typename T, typename U, typename R>
<>	149:156823d33999	3662	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	3663	"Arguments to callback have been reordered to callback(func, arg)")
<>	151:5eaa88a5bcc7	3664	Callback<R()> callback(const U obj, R (func)(const T*)) {
<>	149:156823d33999	3665	return Callback<R()>(func, obj);
<>	149:156823d33999	3666	}
<>	149:156823d33999	3667
<>	149:156823d33999	3668	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3669	*
<>	149:156823d33999	3670	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	3671	* @param func Static function to attach
<>	149:156823d33999	3672	* @return Callback with infered type
<>	149:156823d33999	3673	* @deprecated
<>	149:156823d33999	3674	* Arguments to callback have been reordered to callback(func, arg)
<>	149:156823d33999	3675	*/
<>	151:5eaa88a5bcc7	3676	template <typename T, typename U, typename R>
<>	149:156823d33999	3677	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	3678	"Arguments to callback have been reordered to callback(func, arg)")
<>	151:5eaa88a5bcc7	3679	Callback<R()> callback(volatile U obj, R (func)(volatile T*)) {
<>	149:156823d33999	3680	return Callback<R()>(func, obj);
<>	149:156823d33999	3681	}
<>	149:156823d33999	3682
<>	149:156823d33999	3683	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3684	*
<>	149:156823d33999	3685	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	3686	* @param func Static function to attach
<>	149:156823d33999	3687	* @return Callback with infered type
<>	149:156823d33999	3688	* @deprecated
<>	149:156823d33999	3689	* Arguments to callback have been reordered to callback(func, arg)
<>	149:156823d33999	3690	*/
<>	151:5eaa88a5bcc7	3691	template <typename T, typename U, typename R>
<>	149:156823d33999	3692	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	3693	"Arguments to callback have been reordered to callback(func, arg)")
<>	151:5eaa88a5bcc7	3694	Callback<R()> callback(const volatile U obj, R (func)(const volatile T*)) {
<>	149:156823d33999	3695	return Callback<R()>(func, obj);
<>	149:156823d33999	3696	}
<>	149:156823d33999	3697
<>	149:156823d33999	3698
<>	149:156823d33999	3699	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3700	*
<>	149:156823d33999	3701	* @param func Static function to attach
<>	149:156823d33999	3702	* @return Callback with infered type
<>	149:156823d33999	3703	*/
<>	149:156823d33999	3704	template <typename R, typename A0>
<>	149:156823d33999	3705	Callback<R(A0)> callback(R (*func)(A0) = 0) {
<>	149:156823d33999	3706	return Callback<R(A0)>(func);
<>	149:156823d33999	3707	}
<>	149:156823d33999	3708
<>	149:156823d33999	3709	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3710	*
<>	149:156823d33999	3711	* @param func Static function to attach
<>	149:156823d33999	3712	* @return Callback with infered type
<>	149:156823d33999	3713	*/
<>	149:156823d33999	3714	template <typename R, typename A0>
<>	149:156823d33999	3715	Callback<R(A0)> callback(const Callback<R(A0)> &func) {
<>	149:156823d33999	3716	return Callback<R(A0)>(func);
<>	149:156823d33999	3717	}
<>	149:156823d33999	3718
<>	149:156823d33999	3719	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3720	*
<>	149:156823d33999	3721	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	3722	* @param method Member function to attach
<>	149:156823d33999	3723	* @return Callback with infered type
<>	149:156823d33999	3724	*/
<>	151:5eaa88a5bcc7	3725	template<typename T, typename U, typename R, typename A0>
<>	151:5eaa88a5bcc7	3726	Callback<R(A0)> callback(U obj, R (T::method)(A0)) {
<>	151:5eaa88a5bcc7	3727	return Callback<R(A0)>(obj, method);
<>	149:156823d33999	3728	}
<>	149:156823d33999	3729
<>	149:156823d33999	3730	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3731	*
<>	149:156823d33999	3732	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	3733	* @param method Member function to attach
<>	149:156823d33999	3734	* @return Callback with infered type
<>	149:156823d33999	3735	*/
<>	151:5eaa88a5bcc7	3736	template<typename T, typename U, typename R, typename A0>
<>	151:5eaa88a5bcc7	3737	Callback<R(A0)> callback(const U obj, R (T::method)(A0) const) {
<>	151:5eaa88a5bcc7	3738	return Callback<R(A0)>(obj, method);
<>	149:156823d33999	3739	}
<>	149:156823d33999	3740
<>	149:156823d33999	3741	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3742	*
<>	149:156823d33999	3743	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	3744	* @param method Member function to attach
<>	149:156823d33999	3745	* @return Callback with infered type
<>	149:156823d33999	3746	*/
<>	151:5eaa88a5bcc7	3747	template<typename T, typename U, typename R, typename A0>
<>	151:5eaa88a5bcc7	3748	Callback<R(A0)> callback(volatile U obj, R (T::method)(A0) volatile) {
<>	151:5eaa88a5bcc7	3749	return Callback<R(A0)>(obj, method);
<>	149:156823d33999	3750	}
<>	149:156823d33999	3751
<>	149:156823d33999	3752	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3753	*
<>	149:156823d33999	3754	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	3755	* @param method Member function to attach
<>	149:156823d33999	3756	* @return Callback with infered type
<>	149:156823d33999	3757	*/
<>	151:5eaa88a5bcc7	3758	template<typename T, typename U, typename R, typename A0>
<>	151:5eaa88a5bcc7	3759	Callback<R(A0)> callback(const volatile U obj, R (T::method)(A0) const volatile) {
<>	151:5eaa88a5bcc7	3760	return Callback<R(A0)>(obj, method);
<>	149:156823d33999	3761	}
<>	149:156823d33999	3762
<>	149:156823d33999	3763	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3764	*
<>	149:156823d33999	3765	* @param func Static function to attach
<>	149:156823d33999	3766	* @param arg Pointer argument to function
<>	149:156823d33999	3767	* @return Callback with infered type
<>	149:156823d33999	3768	*/
<>	151:5eaa88a5bcc7	3769	template <typename T, typename U, typename R, typename A0>
<>	151:5eaa88a5bcc7	3770	Callback<R(A0)> callback(R (func)(T, A0), U *arg) {
<>	149:156823d33999	3771	return Callback<R(A0)>(func, arg);
<>	149:156823d33999	3772	}
<>	149:156823d33999	3773
<>	149:156823d33999	3774	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3775	*
<>	149:156823d33999	3776	* @param func Static function to attach
<>	149:156823d33999	3777	* @param arg Pointer argument to function
<>	149:156823d33999	3778	* @return Callback with infered type
<>	149:156823d33999	3779	*/
<>	151:5eaa88a5bcc7	3780	template <typename T, typename U, typename R, typename A0>
<>	151:5eaa88a5bcc7	3781	Callback<R(A0)> callback(R (func)(const T, A0), const U *arg) {
<>	149:156823d33999	3782	return Callback<R(A0)>(func, arg);
<>	149:156823d33999	3783	}
<>	149:156823d33999	3784
<>	149:156823d33999	3785	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3786	*
<>	149:156823d33999	3787	* @param func Static function to attach
<>	149:156823d33999	3788	* @param arg Pointer argument to function
<>	149:156823d33999	3789	* @return Callback with infered type
<>	149:156823d33999	3790	*/
<>	151:5eaa88a5bcc7	3791	template <typename T, typename U, typename R, typename A0>
<>	151:5eaa88a5bcc7	3792	Callback<R(A0)> callback(R (func)(volatile T, A0), volatile U *arg) {
<>	149:156823d33999	3793	return Callback<R(A0)>(func, arg);
<>	149:156823d33999	3794	}
<>	149:156823d33999	3795
<>	149:156823d33999	3796	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3797	*
<>	149:156823d33999	3798	* @param func Static function to attach
<>	149:156823d33999	3799	* @param arg Pointer argument to function
<>	149:156823d33999	3800	* @return Callback with infered type
<>	149:156823d33999	3801	*/
<>	151:5eaa88a5bcc7	3802	template <typename T, typename U, typename R, typename A0>
<>	151:5eaa88a5bcc7	3803	Callback<R(A0)> callback(R (func)(const volatile T, A0), const volatile U *arg) {
<>	149:156823d33999	3804	return Callback<R(A0)>(func, arg);
<>	149:156823d33999	3805	}
<>	149:156823d33999	3806
<>	149:156823d33999	3807	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3808	*
<>	149:156823d33999	3809	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	3810	* @param func Static function to attach
<>	149:156823d33999	3811	* @return Callback with infered type
<>	149:156823d33999	3812	* @deprecated
<>	149:156823d33999	3813	* Arguments to callback have been reordered to callback(func, arg)
<>	149:156823d33999	3814	*/
<>	151:5eaa88a5bcc7	3815	template <typename T, typename U, typename R, typename A0>
<>	149:156823d33999	3816	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	3817	"Arguments to callback have been reordered to callback(func, arg)")
<>	151:5eaa88a5bcc7	3818	Callback<R(A0)> callback(U obj, R (func)(T*, A0)) {
<>	149:156823d33999	3819	return Callback<R(A0)>(func, obj);
<>	149:156823d33999	3820	}
<>	149:156823d33999	3821
<>	149:156823d33999	3822	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3823	*
<>	149:156823d33999	3824	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	3825	* @param func Static function to attach
<>	149:156823d33999	3826	* @return Callback with infered type
<>	149:156823d33999	3827	* @deprecated
<>	149:156823d33999	3828	* Arguments to callback have been reordered to callback(func, arg)
<>	149:156823d33999	3829	*/
<>	151:5eaa88a5bcc7	3830	template <typename T, typename U, typename R, typename A0>
<>	149:156823d33999	3831	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	3832	"Arguments to callback have been reordered to callback(func, arg)")
<>	151:5eaa88a5bcc7	3833	Callback<R(A0)> callback(const U obj, R (func)(const T*, A0)) {
<>	149:156823d33999	3834	return Callback<R(A0)>(func, obj);
<>	149:156823d33999	3835	}
<>	149:156823d33999	3836
<>	149:156823d33999	3837	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3838	*
<>	149:156823d33999	3839	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	3840	* @param func Static function to attach
<>	149:156823d33999	3841	* @return Callback with infered type
<>	149:156823d33999	3842	* @deprecated
<>	149:156823d33999	3843	* Arguments to callback have been reordered to callback(func, arg)
<>	149:156823d33999	3844	*/
<>	151:5eaa88a5bcc7	3845	template <typename T, typename U, typename R, typename A0>
<>	149:156823d33999	3846	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	3847	"Arguments to callback have been reordered to callback(func, arg)")
<>	151:5eaa88a5bcc7	3848	Callback<R(A0)> callback(volatile U obj, R (func)(volatile T*, A0)) {
<>	149:156823d33999	3849	return Callback<R(A0)>(func, obj);
<>	149:156823d33999	3850	}
<>	149:156823d33999	3851
<>	149:156823d33999	3852	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3853	*
<>	149:156823d33999	3854	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	3855	* @param func Static function to attach
<>	149:156823d33999	3856	* @return Callback with infered type
<>	149:156823d33999	3857	* @deprecated
<>	149:156823d33999	3858	* Arguments to callback have been reordered to callback(func, arg)
<>	149:156823d33999	3859	*/
<>	151:5eaa88a5bcc7	3860	template <typename T, typename U, typename R, typename A0>
<>	149:156823d33999	3861	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	3862	"Arguments to callback have been reordered to callback(func, arg)")
<>	151:5eaa88a5bcc7	3863	Callback<R(A0)> callback(const volatile U obj, R (func)(const volatile T*, A0)) {
<>	149:156823d33999	3864	return Callback<R(A0)>(func, obj);
<>	149:156823d33999	3865	}
<>	149:156823d33999	3866
<>	149:156823d33999	3867
<>	149:156823d33999	3868	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3869	*
<>	149:156823d33999	3870	* @param func Static function to attach
<>	149:156823d33999	3871	* @return Callback with infered type
<>	149:156823d33999	3872	*/
<>	149:156823d33999	3873	template <typename R, typename A0, typename A1>
<>	149:156823d33999	3874	Callback<R(A0, A1)> callback(R (*func)(A0, A1) = 0) {
<>	149:156823d33999	3875	return Callback<R(A0, A1)>(func);
<>	149:156823d33999	3876	}
<>	149:156823d33999	3877
<>	149:156823d33999	3878	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3879	*
<>	149:156823d33999	3880	* @param func Static function to attach
<>	149:156823d33999	3881	* @return Callback with infered type
<>	149:156823d33999	3882	*/
<>	149:156823d33999	3883	template <typename R, typename A0, typename A1>
<>	149:156823d33999	3884	Callback<R(A0, A1)> callback(const Callback<R(A0, A1)> &func) {
<>	149:156823d33999	3885	return Callback<R(A0, A1)>(func);
<>	149:156823d33999	3886	}
<>	149:156823d33999	3887
<>	149:156823d33999	3888	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3889	*
<>	149:156823d33999	3890	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	3891	* @param method Member function to attach
<>	149:156823d33999	3892	* @return Callback with infered type
<>	149:156823d33999	3893	*/
<>	151:5eaa88a5bcc7	3894	template<typename T, typename U, typename R, typename A0, typename A1>
<>	151:5eaa88a5bcc7	3895	Callback<R(A0, A1)> callback(U obj, R (T::method)(A0, A1)) {
<>	151:5eaa88a5bcc7	3896	return Callback<R(A0, A1)>(obj, method);
<>	149:156823d33999	3897	}
<>	149:156823d33999	3898
<>	149:156823d33999	3899	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3900	*
<>	149:156823d33999	3901	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	3902	* @param method Member function to attach
<>	149:156823d33999	3903	* @return Callback with infered type
<>	149:156823d33999	3904	*/
<>	151:5eaa88a5bcc7	3905	template<typename T, typename U, typename R, typename A0, typename A1>
<>	151:5eaa88a5bcc7	3906	Callback<R(A0, A1)> callback(const U obj, R (T::method)(A0, A1) const) {
<>	151:5eaa88a5bcc7	3907	return Callback<R(A0, A1)>(obj, method);
<>	149:156823d33999	3908	}
<>	149:156823d33999	3909
<>	149:156823d33999	3910	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3911	*
<>	149:156823d33999	3912	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	3913	* @param method Member function to attach
<>	149:156823d33999	3914	* @return Callback with infered type
<>	149:156823d33999	3915	*/
<>	151:5eaa88a5bcc7	3916	template<typename T, typename U, typename R, typename A0, typename A1>
<>	151:5eaa88a5bcc7	3917	Callback<R(A0, A1)> callback(volatile U obj, R (T::method)(A0, A1) volatile) {
<>	151:5eaa88a5bcc7	3918	return Callback<R(A0, A1)>(obj, method);
<>	149:156823d33999	3919	}
<>	149:156823d33999	3920
<>	149:156823d33999	3921	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3922	*
<>	149:156823d33999	3923	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	3924	* @param method Member function to attach
<>	149:156823d33999	3925	* @return Callback with infered type
<>	149:156823d33999	3926	*/
<>	151:5eaa88a5bcc7	3927	template<typename T, typename U, typename R, typename A0, typename A1>
<>	151:5eaa88a5bcc7	3928	Callback<R(A0, A1)> callback(const volatile U obj, R (T::method)(A0, A1) const volatile) {
<>	151:5eaa88a5bcc7	3929	return Callback<R(A0, A1)>(obj, method);
<>	149:156823d33999	3930	}
<>	149:156823d33999	3931
<>	149:156823d33999	3932	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3933	*
<>	149:156823d33999	3934	* @param func Static function to attach
<>	149:156823d33999	3935	* @param arg Pointer argument to function
<>	149:156823d33999	3936	* @return Callback with infered type
<>	149:156823d33999	3937	*/
<>	151:5eaa88a5bcc7	3938	template <typename T, typename U, typename R, typename A0, typename A1>
<>	151:5eaa88a5bcc7	3939	Callback<R(A0, A1)> callback(R (func)(T, A0, A1), U *arg) {
<>	149:156823d33999	3940	return Callback<R(A0, A1)>(func, arg);
<>	149:156823d33999	3941	}
<>	149:156823d33999	3942
<>	149:156823d33999	3943	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3944	*
<>	149:156823d33999	3945	* @param func Static function to attach
<>	149:156823d33999	3946	* @param arg Pointer argument to function
<>	149:156823d33999	3947	* @return Callback with infered type
<>	149:156823d33999	3948	*/
<>	151:5eaa88a5bcc7	3949	template <typename T, typename U, typename R, typename A0, typename A1>
<>	151:5eaa88a5bcc7	3950	Callback<R(A0, A1)> callback(R (func)(const T, A0, A1), const U *arg) {
<>	149:156823d33999	3951	return Callback<R(A0, A1)>(func, arg);
<>	149:156823d33999	3952	}
<>	149:156823d33999	3953
<>	149:156823d33999	3954	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3955	*
<>	149:156823d33999	3956	* @param func Static function to attach
<>	149:156823d33999	3957	* @param arg Pointer argument to function
<>	149:156823d33999	3958	* @return Callback with infered type
<>	149:156823d33999	3959	*/
<>	151:5eaa88a5bcc7	3960	template <typename T, typename U, typename R, typename A0, typename A1>
<>	151:5eaa88a5bcc7	3961	Callback<R(A0, A1)> callback(R (func)(volatile T, A0, A1), volatile U *arg) {
<>	149:156823d33999	3962	return Callback<R(A0, A1)>(func, arg);
<>	149:156823d33999	3963	}
<>	149:156823d33999	3964
<>	149:156823d33999	3965	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3966	*
<>	149:156823d33999	3967	* @param func Static function to attach
<>	149:156823d33999	3968	* @param arg Pointer argument to function
<>	149:156823d33999	3969	* @return Callback with infered type
<>	149:156823d33999	3970	*/
<>	151:5eaa88a5bcc7	3971	template <typename T, typename U, typename R, typename A0, typename A1>
<>	151:5eaa88a5bcc7	3972	Callback<R(A0, A1)> callback(R (func)(const volatile T, A0, A1), const volatile U *arg) {
<>	149:156823d33999	3973	return Callback<R(A0, A1)>(func, arg);
<>	149:156823d33999	3974	}
<>	149:156823d33999	3975
<>	149:156823d33999	3976	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3977	*
<>	149:156823d33999	3978	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	3979	* @param func Static function to attach
<>	149:156823d33999	3980	* @return Callback with infered type
<>	149:156823d33999	3981	* @deprecated
<>	149:156823d33999	3982	* Arguments to callback have been reordered to callback(func, arg)
<>	149:156823d33999	3983	*/
<>	151:5eaa88a5bcc7	3984	template <typename T, typename U, typename R, typename A0, typename A1>
<>	149:156823d33999	3985	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	3986	"Arguments to callback have been reordered to callback(func, arg)")
<>	151:5eaa88a5bcc7	3987	Callback<R(A0, A1)> callback(U obj, R (func)(T*, A0, A1)) {
<>	149:156823d33999	3988	return Callback<R(A0, A1)>(func, obj);
<>	149:156823d33999	3989	}
<>	149:156823d33999	3990
<>	149:156823d33999	3991	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	3992	*
<>	149:156823d33999	3993	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	3994	* @param func Static function to attach
<>	149:156823d33999	3995	* @return Callback with infered type
<>	149:156823d33999	3996	* @deprecated
<>	149:156823d33999	3997	* Arguments to callback have been reordered to callback(func, arg)
<>	149:156823d33999	3998	*/
<>	151:5eaa88a5bcc7	3999	template <typename T, typename U, typename R, typename A0, typename A1>
<>	149:156823d33999	4000	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	4001	"Arguments to callback have been reordered to callback(func, arg)")
<>	151:5eaa88a5bcc7	4002	Callback<R(A0, A1)> callback(const U obj, R (func)(const T*, A0, A1)) {
<>	149:156823d33999	4003	return Callback<R(A0, A1)>(func, obj);
<>	149:156823d33999	4004	}
<>	149:156823d33999	4005
<>	149:156823d33999	4006	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4007	*
<>	149:156823d33999	4008	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	4009	* @param func Static function to attach
<>	149:156823d33999	4010	* @return Callback with infered type
<>	149:156823d33999	4011	* @deprecated
<>	149:156823d33999	4012	* Arguments to callback have been reordered to callback(func, arg)
<>	149:156823d33999	4013	*/
<>	151:5eaa88a5bcc7	4014	template <typename T, typename U, typename R, typename A0, typename A1>
<>	149:156823d33999	4015	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	4016	"Arguments to callback have been reordered to callback(func, arg)")
<>	151:5eaa88a5bcc7	4017	Callback<R(A0, A1)> callback(volatile U obj, R (func)(volatile T*, A0, A1)) {
<>	149:156823d33999	4018	return Callback<R(A0, A1)>(func, obj);
<>	149:156823d33999	4019	}
<>	149:156823d33999	4020
<>	149:156823d33999	4021	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4022	*
<>	149:156823d33999	4023	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	4024	* @param func Static function to attach
<>	149:156823d33999	4025	* @return Callback with infered type
<>	149:156823d33999	4026	* @deprecated
<>	149:156823d33999	4027	* Arguments to callback have been reordered to callback(func, arg)
<>	149:156823d33999	4028	*/
<>	151:5eaa88a5bcc7	4029	template <typename T, typename U, typename R, typename A0, typename A1>
<>	149:156823d33999	4030	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	4031	"Arguments to callback have been reordered to callback(func, arg)")
<>	151:5eaa88a5bcc7	4032	Callback<R(A0, A1)> callback(const volatile U obj, R (func)(const volatile T*, A0, A1)) {
<>	149:156823d33999	4033	return Callback<R(A0, A1)>(func, obj);
<>	149:156823d33999	4034	}
<>	149:156823d33999	4035
<>	149:156823d33999	4036
<>	149:156823d33999	4037	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4038	*
<>	149:156823d33999	4039	* @param func Static function to attach
<>	149:156823d33999	4040	* @return Callback with infered type
<>	149:156823d33999	4041	*/
<>	149:156823d33999	4042	template <typename R, typename A0, typename A1, typename A2>
<>	149:156823d33999	4043	Callback<R(A0, A1, A2)> callback(R (*func)(A0, A1, A2) = 0) {
<>	149:156823d33999	4044	return Callback<R(A0, A1, A2)>(func);
<>	149:156823d33999	4045	}
<>	149:156823d33999	4046
<>	149:156823d33999	4047	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4048	*
<>	149:156823d33999	4049	* @param func Static function to attach
<>	149:156823d33999	4050	* @return Callback with infered type
<>	149:156823d33999	4051	*/
<>	149:156823d33999	4052	template <typename R, typename A0, typename A1, typename A2>
<>	149:156823d33999	4053	Callback<R(A0, A1, A2)> callback(const Callback<R(A0, A1, A2)> &func) {
<>	149:156823d33999	4054	return Callback<R(A0, A1, A2)>(func);
<>	149:156823d33999	4055	}
<>	149:156823d33999	4056
<>	149:156823d33999	4057	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4058	*
<>	149:156823d33999	4059	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	4060	* @param method Member function to attach
<>	149:156823d33999	4061	* @return Callback with infered type
<>	149:156823d33999	4062	*/
<>	151:5eaa88a5bcc7	4063	template<typename T, typename U, typename R, typename A0, typename A1, typename A2>
<>	151:5eaa88a5bcc7	4064	Callback<R(A0, A1, A2)> callback(U obj, R (T::method)(A0, A1, A2)) {
<>	151:5eaa88a5bcc7	4065	return Callback<R(A0, A1, A2)>(obj, method);
<>	149:156823d33999	4066	}
<>	149:156823d33999	4067
<>	149:156823d33999	4068	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4069	*
<>	149:156823d33999	4070	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	4071	* @param method Member function to attach
<>	149:156823d33999	4072	* @return Callback with infered type
<>	149:156823d33999	4073	*/
<>	151:5eaa88a5bcc7	4074	template<typename T, typename U, typename R, typename A0, typename A1, typename A2>
<>	151:5eaa88a5bcc7	4075	Callback<R(A0, A1, A2)> callback(const U obj, R (T::method)(A0, A1, A2) const) {
<>	151:5eaa88a5bcc7	4076	return Callback<R(A0, A1, A2)>(obj, method);
<>	149:156823d33999	4077	}
<>	149:156823d33999	4078
<>	149:156823d33999	4079	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4080	*
<>	149:156823d33999	4081	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	4082	* @param method Member function to attach
<>	149:156823d33999	4083	* @return Callback with infered type
<>	149:156823d33999	4084	*/
<>	151:5eaa88a5bcc7	4085	template<typename T, typename U, typename R, typename A0, typename A1, typename A2>
<>	151:5eaa88a5bcc7	4086	Callback<R(A0, A1, A2)> callback(volatile U obj, R (T::method)(A0, A1, A2) volatile) {
<>	151:5eaa88a5bcc7	4087	return Callback<R(A0, A1, A2)>(obj, method);
<>	149:156823d33999	4088	}
<>	149:156823d33999	4089
<>	149:156823d33999	4090	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4091	*
<>	149:156823d33999	4092	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	4093	* @param method Member function to attach
<>	149:156823d33999	4094	* @return Callback with infered type
<>	149:156823d33999	4095	*/
<>	151:5eaa88a5bcc7	4096	template<typename T, typename U, typename R, typename A0, typename A1, typename A2>
<>	151:5eaa88a5bcc7	4097	Callback<R(A0, A1, A2)> callback(const volatile U obj, R (T::method)(A0, A1, A2) const volatile) {
<>	151:5eaa88a5bcc7	4098	return Callback<R(A0, A1, A2)>(obj, method);
<>	149:156823d33999	4099	}
<>	149:156823d33999	4100
<>	149:156823d33999	4101	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4102	*
<>	149:156823d33999	4103	* @param func Static function to attach
<>	149:156823d33999	4104	* @param arg Pointer argument to function
<>	149:156823d33999	4105	* @return Callback with infered type
<>	149:156823d33999	4106	*/
<>	151:5eaa88a5bcc7	4107	template <typename T, typename U, typename R, typename A0, typename A1, typename A2>
<>	151:5eaa88a5bcc7	4108	Callback<R(A0, A1, A2)> callback(R (func)(T, A0, A1, A2), U *arg) {
<>	149:156823d33999	4109	return Callback<R(A0, A1, A2)>(func, arg);
<>	149:156823d33999	4110	}
<>	149:156823d33999	4111
<>	149:156823d33999	4112	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4113	*
<>	149:156823d33999	4114	* @param func Static function to attach
<>	149:156823d33999	4115	* @param arg Pointer argument to function
<>	149:156823d33999	4116	* @return Callback with infered type
<>	149:156823d33999	4117	*/
<>	151:5eaa88a5bcc7	4118	template <typename T, typename U, typename R, typename A0, typename A1, typename A2>
<>	151:5eaa88a5bcc7	4119	Callback<R(A0, A1, A2)> callback(R (func)(const T, A0, A1, A2), const U *arg) {
<>	149:156823d33999	4120	return Callback<R(A0, A1, A2)>(func, arg);
<>	149:156823d33999	4121	}
<>	149:156823d33999	4122
<>	149:156823d33999	4123	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4124	*
<>	149:156823d33999	4125	* @param func Static function to attach
<>	149:156823d33999	4126	* @param arg Pointer argument to function
<>	149:156823d33999	4127	* @return Callback with infered type
<>	149:156823d33999	4128	*/
<>	151:5eaa88a5bcc7	4129	template <typename T, typename U, typename R, typename A0, typename A1, typename A2>
<>	151:5eaa88a5bcc7	4130	Callback<R(A0, A1, A2)> callback(R (func)(volatile T, A0, A1, A2), volatile U *arg) {
<>	149:156823d33999	4131	return Callback<R(A0, A1, A2)>(func, arg);
<>	149:156823d33999	4132	}
<>	149:156823d33999	4133
<>	149:156823d33999	4134	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4135	*
<>	149:156823d33999	4136	* @param func Static function to attach
<>	149:156823d33999	4137	* @param arg Pointer argument to function
<>	149:156823d33999	4138	* @return Callback with infered type
<>	149:156823d33999	4139	*/
<>	151:5eaa88a5bcc7	4140	template <typename T, typename U, typename R, typename A0, typename A1, typename A2>
<>	151:5eaa88a5bcc7	4141	Callback<R(A0, A1, A2)> callback(R (func)(const volatile T, A0, A1, A2), const volatile U *arg) {
<>	149:156823d33999	4142	return Callback<R(A0, A1, A2)>(func, arg);
<>	149:156823d33999	4143	}
<>	149:156823d33999	4144
<>	149:156823d33999	4145	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4146	*
<>	149:156823d33999	4147	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	4148	* @param func Static function to attach
<>	149:156823d33999	4149	* @return Callback with infered type
<>	149:156823d33999	4150	* @deprecated
<>	149:156823d33999	4151	* Arguments to callback have been reordered to callback(func, arg)
<>	149:156823d33999	4152	*/
<>	151:5eaa88a5bcc7	4153	template <typename T, typename U, typename R, typename A0, typename A1, typename A2>
<>	149:156823d33999	4154	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	4155	"Arguments to callback have been reordered to callback(func, arg)")
<>	151:5eaa88a5bcc7	4156	Callback<R(A0, A1, A2)> callback(U obj, R (func)(T*, A0, A1, A2)) {
<>	149:156823d33999	4157	return Callback<R(A0, A1, A2)>(func, obj);
<>	149:156823d33999	4158	}
<>	149:156823d33999	4159
<>	149:156823d33999	4160	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4161	*
<>	149:156823d33999	4162	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	4163	* @param func Static function to attach
<>	149:156823d33999	4164	* @return Callback with infered type
<>	149:156823d33999	4165	* @deprecated
<>	149:156823d33999	4166	* Arguments to callback have been reordered to callback(func, arg)
<>	149:156823d33999	4167	*/
<>	151:5eaa88a5bcc7	4168	template <typename T, typename U, typename R, typename A0, typename A1, typename A2>
<>	149:156823d33999	4169	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	4170	"Arguments to callback have been reordered to callback(func, arg)")
<>	151:5eaa88a5bcc7	4171	Callback<R(A0, A1, A2)> callback(const U obj, R (func)(const T*, A0, A1, A2)) {
<>	149:156823d33999	4172	return Callback<R(A0, A1, A2)>(func, obj);
<>	149:156823d33999	4173	}
<>	149:156823d33999	4174
<>	149:156823d33999	4175	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4176	*
<>	149:156823d33999	4177	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	4178	* @param func Static function to attach
<>	149:156823d33999	4179	* @return Callback with infered type
<>	149:156823d33999	4180	* @deprecated
<>	149:156823d33999	4181	* Arguments to callback have been reordered to callback(func, arg)
<>	149:156823d33999	4182	*/
<>	151:5eaa88a5bcc7	4183	template <typename T, typename U, typename R, typename A0, typename A1, typename A2>
<>	149:156823d33999	4184	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	4185	"Arguments to callback have been reordered to callback(func, arg)")
<>	151:5eaa88a5bcc7	4186	Callback<R(A0, A1, A2)> callback(volatile U obj, R (func)(volatile T*, A0, A1, A2)) {
<>	149:156823d33999	4187	return Callback<R(A0, A1, A2)>(func, obj);
<>	149:156823d33999	4188	}
<>	149:156823d33999	4189
<>	149:156823d33999	4190	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4191	*
<>	149:156823d33999	4192	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	4193	* @param func Static function to attach
<>	149:156823d33999	4194	* @return Callback with infered type
<>	149:156823d33999	4195	* @deprecated
<>	149:156823d33999	4196	* Arguments to callback have been reordered to callback(func, arg)
<>	149:156823d33999	4197	*/
<>	151:5eaa88a5bcc7	4198	template <typename T, typename U, typename R, typename A0, typename A1, typename A2>
<>	149:156823d33999	4199	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	4200	"Arguments to callback have been reordered to callback(func, arg)")
<>	151:5eaa88a5bcc7	4201	Callback<R(A0, A1, A2)> callback(const volatile U obj, R (func)(const volatile T*, A0, A1, A2)) {
<>	149:156823d33999	4202	return Callback<R(A0, A1, A2)>(func, obj);
<>	149:156823d33999	4203	}
<>	149:156823d33999	4204
<>	149:156823d33999	4205
<>	149:156823d33999	4206	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4207	*
<>	149:156823d33999	4208	* @param func Static function to attach
<>	149:156823d33999	4209	* @return Callback with infered type
<>	149:156823d33999	4210	*/
<>	149:156823d33999	4211	template <typename R, typename A0, typename A1, typename A2, typename A3>
<>	149:156823d33999	4212	Callback<R(A0, A1, A2, A3)> callback(R (*func)(A0, A1, A2, A3) = 0) {
<>	149:156823d33999	4213	return Callback<R(A0, A1, A2, A3)>(func);
<>	149:156823d33999	4214	}
<>	149:156823d33999	4215
<>	149:156823d33999	4216	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4217	*
<>	149:156823d33999	4218	* @param func Static function to attach
<>	149:156823d33999	4219	* @return Callback with infered type
<>	149:156823d33999	4220	*/
<>	149:156823d33999	4221	template <typename R, typename A0, typename A1, typename A2, typename A3>
<>	149:156823d33999	4222	Callback<R(A0, A1, A2, A3)> callback(const Callback<R(A0, A1, A2, A3)> &func) {
<>	149:156823d33999	4223	return Callback<R(A0, A1, A2, A3)>(func);
<>	149:156823d33999	4224	}
<>	149:156823d33999	4225
<>	149:156823d33999	4226	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4227	*
<>	149:156823d33999	4228	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	4229	* @param method Member function to attach
<>	149:156823d33999	4230	* @return Callback with infered type
<>	149:156823d33999	4231	*/
<>	151:5eaa88a5bcc7	4232	template<typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3>
<>	151:5eaa88a5bcc7	4233	Callback<R(A0, A1, A2, A3)> callback(U obj, R (T::method)(A0, A1, A2, A3)) {
<>	151:5eaa88a5bcc7	4234	return Callback<R(A0, A1, A2, A3)>(obj, method);
<>	149:156823d33999	4235	}
<>	149:156823d33999	4236
<>	149:156823d33999	4237	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4238	*
<>	149:156823d33999	4239	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	4240	* @param method Member function to attach
<>	149:156823d33999	4241	* @return Callback with infered type
<>	149:156823d33999	4242	*/
<>	151:5eaa88a5bcc7	4243	template<typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3>
<>	151:5eaa88a5bcc7	4244	Callback<R(A0, A1, A2, A3)> callback(const U obj, R (T::method)(A0, A1, A2, A3) const) {
<>	151:5eaa88a5bcc7	4245	return Callback<R(A0, A1, A2, A3)>(obj, method);
<>	149:156823d33999	4246	}
<>	149:156823d33999	4247
<>	149:156823d33999	4248	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4249	*
<>	149:156823d33999	4250	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	4251	* @param method Member function to attach
<>	149:156823d33999	4252	* @return Callback with infered type
<>	149:156823d33999	4253	*/
<>	151:5eaa88a5bcc7	4254	template<typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3>
<>	151:5eaa88a5bcc7	4255	Callback<R(A0, A1, A2, A3)> callback(volatile U obj, R (T::method)(A0, A1, A2, A3) volatile) {
<>	151:5eaa88a5bcc7	4256	return Callback<R(A0, A1, A2, A3)>(obj, method);
<>	149:156823d33999	4257	}
<>	149:156823d33999	4258
<>	149:156823d33999	4259	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4260	*
<>	149:156823d33999	4261	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	4262	* @param method Member function to attach
<>	149:156823d33999	4263	* @return Callback with infered type
<>	149:156823d33999	4264	*/
<>	151:5eaa88a5bcc7	4265	template<typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3>
<>	151:5eaa88a5bcc7	4266	Callback<R(A0, A1, A2, A3)> callback(const volatile U obj, R (T::method)(A0, A1, A2, A3) const volatile) {
<>	151:5eaa88a5bcc7	4267	return Callback<R(A0, A1, A2, A3)>(obj, method);
<>	149:156823d33999	4268	}
<>	149:156823d33999	4269
<>	149:156823d33999	4270	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4271	*
<>	149:156823d33999	4272	* @param func Static function to attach
<>	149:156823d33999	4273	* @param arg Pointer argument to function
<>	149:156823d33999	4274	* @return Callback with infered type
<>	149:156823d33999	4275	*/
<>	151:5eaa88a5bcc7	4276	template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3>
<>	151:5eaa88a5bcc7	4277	Callback<R(A0, A1, A2, A3)> callback(R (func)(T, A0, A1, A2, A3), U *arg) {
<>	149:156823d33999	4278	return Callback<R(A0, A1, A2, A3)>(func, arg);
<>	149:156823d33999	4279	}
<>	149:156823d33999	4280
<>	149:156823d33999	4281	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4282	*
<>	149:156823d33999	4283	* @param func Static function to attach
<>	149:156823d33999	4284	* @param arg Pointer argument to function
<>	149:156823d33999	4285	* @return Callback with infered type
<>	149:156823d33999	4286	*/
<>	151:5eaa88a5bcc7	4287	template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3>
<>	151:5eaa88a5bcc7	4288	Callback<R(A0, A1, A2, A3)> callback(R (func)(const T, A0, A1, A2, A3), const U *arg) {
<>	149:156823d33999	4289	return Callback<R(A0, A1, A2, A3)>(func, arg);
<>	149:156823d33999	4290	}
<>	149:156823d33999	4291
<>	149:156823d33999	4292	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4293	*
<>	149:156823d33999	4294	* @param func Static function to attach
<>	149:156823d33999	4295	* @param arg Pointer argument to function
<>	149:156823d33999	4296	* @return Callback with infered type
<>	149:156823d33999	4297	*/
<>	151:5eaa88a5bcc7	4298	template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3>
<>	151:5eaa88a5bcc7	4299	Callback<R(A0, A1, A2, A3)> callback(R (func)(volatile T, A0, A1, A2, A3), volatile U *arg) {
<>	149:156823d33999	4300	return Callback<R(A0, A1, A2, A3)>(func, arg);
<>	149:156823d33999	4301	}
<>	149:156823d33999	4302
<>	149:156823d33999	4303	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4304	*
<>	149:156823d33999	4305	* @param func Static function to attach
<>	149:156823d33999	4306	* @param arg Pointer argument to function
<>	149:156823d33999	4307	* @return Callback with infered type
<>	149:156823d33999	4308	*/
<>	151:5eaa88a5bcc7	4309	template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3>
<>	151:5eaa88a5bcc7	4310	Callback<R(A0, A1, A2, A3)> callback(R (func)(const volatile T, A0, A1, A2, A3), const volatile U *arg) {
<>	149:156823d33999	4311	return Callback<R(A0, A1, A2, A3)>(func, arg);
<>	149:156823d33999	4312	}
<>	149:156823d33999	4313
<>	149:156823d33999	4314	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4315	*
<>	149:156823d33999	4316	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	4317	* @param func Static function to attach
<>	149:156823d33999	4318	* @return Callback with infered type
<>	149:156823d33999	4319	* @deprecated
<>	149:156823d33999	4320	* Arguments to callback have been reordered to callback(func, arg)
<>	149:156823d33999	4321	*/
<>	151:5eaa88a5bcc7	4322	template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3>
<>	149:156823d33999	4323	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	4324	"Arguments to callback have been reordered to callback(func, arg)")
<>	151:5eaa88a5bcc7	4325	Callback<R(A0, A1, A2, A3)> callback(U obj, R (func)(T*, A0, A1, A2, A3)) {
<>	149:156823d33999	4326	return Callback<R(A0, A1, A2, A3)>(func, obj);
<>	149:156823d33999	4327	}
<>	149:156823d33999	4328
<>	149:156823d33999	4329	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4330	*
<>	149:156823d33999	4331	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	4332	* @param func Static function to attach
<>	149:156823d33999	4333	* @return Callback with infered type
<>	149:156823d33999	4334	* @deprecated
<>	149:156823d33999	4335	* Arguments to callback have been reordered to callback(func, arg)
<>	149:156823d33999	4336	*/
<>	151:5eaa88a5bcc7	4337	template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3>
<>	149:156823d33999	4338	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	4339	"Arguments to callback have been reordered to callback(func, arg)")
<>	151:5eaa88a5bcc7	4340	Callback<R(A0, A1, A2, A3)> callback(const U obj, R (func)(const T*, A0, A1, A2, A3)) {
<>	149:156823d33999	4341	return Callback<R(A0, A1, A2, A3)>(func, obj);
<>	149:156823d33999	4342	}
<>	149:156823d33999	4343
<>	149:156823d33999	4344	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4345	*
<>	149:156823d33999	4346	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	4347	* @param func Static function to attach
<>	149:156823d33999	4348	* @return Callback with infered type
<>	149:156823d33999	4349	* @deprecated
<>	149:156823d33999	4350	* Arguments to callback have been reordered to callback(func, arg)
<>	149:156823d33999	4351	*/
<>	151:5eaa88a5bcc7	4352	template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3>
<>	149:156823d33999	4353	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	4354	"Arguments to callback have been reordered to callback(func, arg)")
<>	151:5eaa88a5bcc7	4355	Callback<R(A0, A1, A2, A3)> callback(volatile U obj, R (func)(volatile T*, A0, A1, A2, A3)) {
<>	149:156823d33999	4356	return Callback<R(A0, A1, A2, A3)>(func, obj);
<>	149:156823d33999	4357	}
<>	149:156823d33999	4358
<>	149:156823d33999	4359	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4360	*
<>	149:156823d33999	4361	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	4362	* @param func Static function to attach
<>	149:156823d33999	4363	* @return Callback with infered type
<>	149:156823d33999	4364	* @deprecated
<>	149:156823d33999	4365	* Arguments to callback have been reordered to callback(func, arg)
<>	149:156823d33999	4366	*/
<>	151:5eaa88a5bcc7	4367	template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3>
<>	149:156823d33999	4368	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	4369	"Arguments to callback have been reordered to callback(func, arg)")
<>	151:5eaa88a5bcc7	4370	Callback<R(A0, A1, A2, A3)> callback(const volatile U obj, R (func)(const volatile T*, A0, A1, A2, A3)) {
<>	149:156823d33999	4371	return Callback<R(A0, A1, A2, A3)>(func, obj);
<>	149:156823d33999	4372	}
<>	149:156823d33999	4373
<>	149:156823d33999	4374
<>	149:156823d33999	4375	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4376	*
<>	149:156823d33999	4377	* @param func Static function to attach
<>	149:156823d33999	4378	* @return Callback with infered type
<>	149:156823d33999	4379	*/
<>	149:156823d33999	4380	template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
<>	149:156823d33999	4381	Callback<R(A0, A1, A2, A3, A4)> callback(R (*func)(A0, A1, A2, A3, A4) = 0) {
<>	149:156823d33999	4382	return Callback<R(A0, A1, A2, A3, A4)>(func);
<>	149:156823d33999	4383	}
<>	149:156823d33999	4384
<>	149:156823d33999	4385	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4386	*
<>	149:156823d33999	4387	* @param func Static function to attach
<>	149:156823d33999	4388	* @return Callback with infered type
<>	149:156823d33999	4389	*/
<>	149:156823d33999	4390	template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
<>	149:156823d33999	4391	Callback<R(A0, A1, A2, A3, A4)> callback(const Callback<R(A0, A1, A2, A3, A4)> &func) {
<>	149:156823d33999	4392	return Callback<R(A0, A1, A2, A3, A4)>(func);
<>	149:156823d33999	4393	}
<>	149:156823d33999	4394
<>	149:156823d33999	4395	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4396	*
<>	149:156823d33999	4397	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	4398	* @param method Member function to attach
<>	149:156823d33999	4399	* @return Callback with infered type
<>	149:156823d33999	4400	*/
<>	151:5eaa88a5bcc7	4401	template<typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
<>	151:5eaa88a5bcc7	4402	Callback<R(A0, A1, A2, A3, A4)> callback(U obj, R (T::method)(A0, A1, A2, A3, A4)) {
<>	151:5eaa88a5bcc7	4403	return Callback<R(A0, A1, A2, A3, A4)>(obj, method);
<>	149:156823d33999	4404	}
<>	149:156823d33999	4405
<>	149:156823d33999	4406	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4407	*
<>	149:156823d33999	4408	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	4409	* @param method Member function to attach
<>	149:156823d33999	4410	* @return Callback with infered type
<>	149:156823d33999	4411	*/
<>	151:5eaa88a5bcc7	4412	template<typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
<>	151:5eaa88a5bcc7	4413	Callback<R(A0, A1, A2, A3, A4)> callback(const U obj, R (T::method)(A0, A1, A2, A3, A4) const) {
<>	151:5eaa88a5bcc7	4414	return Callback<R(A0, A1, A2, A3, A4)>(obj, method);
<>	149:156823d33999	4415	}
<>	149:156823d33999	4416
<>	149:156823d33999	4417	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4418	*
<>	149:156823d33999	4419	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	4420	* @param method Member function to attach
<>	149:156823d33999	4421	* @return Callback with infered type
<>	149:156823d33999	4422	*/
<>	151:5eaa88a5bcc7	4423	template<typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
<>	151:5eaa88a5bcc7	4424	Callback<R(A0, A1, A2, A3, A4)> callback(volatile U obj, R (T::method)(A0, A1, A2, A3, A4) volatile) {
<>	151:5eaa88a5bcc7	4425	return Callback<R(A0, A1, A2, A3, A4)>(obj, method);
<>	149:156823d33999	4426	}
<>	149:156823d33999	4427
<>	149:156823d33999	4428	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4429	*
<>	149:156823d33999	4430	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	4431	* @param method Member function to attach
<>	149:156823d33999	4432	* @return Callback with infered type
<>	149:156823d33999	4433	*/
<>	151:5eaa88a5bcc7	4434	template<typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
<>	151:5eaa88a5bcc7	4435	Callback<R(A0, A1, A2, A3, A4)> callback(const volatile U obj, R (T::method)(A0, A1, A2, A3, A4) const volatile) {
<>	151:5eaa88a5bcc7	4436	return Callback<R(A0, A1, A2, A3, A4)>(obj, method);
<>	149:156823d33999	4437	}
<>	149:156823d33999	4438
<>	149:156823d33999	4439	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4440	*
<>	149:156823d33999	4441	* @param func Static function to attach
<>	149:156823d33999	4442	* @param arg Pointer argument to function
<>	149:156823d33999	4443	* @return Callback with infered type
<>	149:156823d33999	4444	*/
<>	151:5eaa88a5bcc7	4445	template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
<>	151:5eaa88a5bcc7	4446	Callback<R(A0, A1, A2, A3, A4)> callback(R (func)(T, A0, A1, A2, A3, A4), U *arg) {
<>	149:156823d33999	4447	return Callback<R(A0, A1, A2, A3, A4)>(func, arg);
<>	149:156823d33999	4448	}
<>	149:156823d33999	4449
<>	149:156823d33999	4450	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4451	*
<>	149:156823d33999	4452	* @param func Static function to attach
<>	149:156823d33999	4453	* @param arg Pointer argument to function
<>	149:156823d33999	4454	* @return Callback with infered type
<>	149:156823d33999	4455	*/
<>	151:5eaa88a5bcc7	4456	template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
<>	151:5eaa88a5bcc7	4457	Callback<R(A0, A1, A2, A3, A4)> callback(R (func)(const T, A0, A1, A2, A3, A4), const U *arg) {
<>	149:156823d33999	4458	return Callback<R(A0, A1, A2, A3, A4)>(func, arg);
<>	149:156823d33999	4459	}
<>	149:156823d33999	4460
<>	149:156823d33999	4461	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4462	*
<>	149:156823d33999	4463	* @param func Static function to attach
<>	149:156823d33999	4464	* @param arg Pointer argument to function
<>	149:156823d33999	4465	* @return Callback with infered type
<>	149:156823d33999	4466	*/
<>	151:5eaa88a5bcc7	4467	template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
<>	151:5eaa88a5bcc7	4468	Callback<R(A0, A1, A2, A3, A4)> callback(R (func)(volatile T, A0, A1, A2, A3, A4), volatile U *arg) {
<>	149:156823d33999	4469	return Callback<R(A0, A1, A2, A3, A4)>(func, arg);
<>	149:156823d33999	4470	}
<>	149:156823d33999	4471
<>	149:156823d33999	4472	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4473	*
<>	149:156823d33999	4474	* @param func Static function to attach
<>	149:156823d33999	4475	* @param arg Pointer argument to function
<>	149:156823d33999	4476	* @return Callback with infered type
<>	149:156823d33999	4477	*/
<>	151:5eaa88a5bcc7	4478	template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
<>	151:5eaa88a5bcc7	4479	Callback<R(A0, A1, A2, A3, A4)> callback(R (func)(const volatile T, A0, A1, A2, A3, A4), const volatile U *arg) {
<>	149:156823d33999	4480	return Callback<R(A0, A1, A2, A3, A4)>(func, arg);
<>	149:156823d33999	4481	}
<>	149:156823d33999	4482
<>	149:156823d33999	4483	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4484	*
<>	149:156823d33999	4485	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	4486	* @param func Static function to attach
<>	149:156823d33999	4487	* @return Callback with infered type
<>	149:156823d33999	4488	* @deprecated
<>	149:156823d33999	4489	* Arguments to callback have been reordered to callback(func, arg)
<>	149:156823d33999	4490	*/
<>	151:5eaa88a5bcc7	4491	template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
<>	149:156823d33999	4492	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	4493	"Arguments to callback have been reordered to callback(func, arg)")
<>	151:5eaa88a5bcc7	4494	Callback<R(A0, A1, A2, A3, A4)> callback(U obj, R (func)(T*, A0, A1, A2, A3, A4)) {
<>	149:156823d33999	4495	return Callback<R(A0, A1, A2, A3, A4)>(func, obj);
<>	149:156823d33999	4496	}
<>	149:156823d33999	4497
<>	149:156823d33999	4498	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4499	*
<>	149:156823d33999	4500	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	4501	* @param func Static function to attach
<>	149:156823d33999	4502	* @return Callback with infered type
<>	149:156823d33999	4503	* @deprecated
<>	149:156823d33999	4504	* Arguments to callback have been reordered to callback(func, arg)
<>	149:156823d33999	4505	*/
<>	151:5eaa88a5bcc7	4506	template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
<>	149:156823d33999	4507	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	4508	"Arguments to callback have been reordered to callback(func, arg)")
<>	151:5eaa88a5bcc7	4509	Callback<R(A0, A1, A2, A3, A4)> callback(const U obj, R (func)(const T*, A0, A1, A2, A3, A4)) {
<>	149:156823d33999	4510	return Callback<R(A0, A1, A2, A3, A4)>(func, obj);
<>	149:156823d33999	4511	}
<>	149:156823d33999	4512
<>	149:156823d33999	4513	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4514	*
<>	149:156823d33999	4515	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	4516	* @param func Static function to attach
<>	149:156823d33999	4517	* @return Callback with infered type
<>	149:156823d33999	4518	* @deprecated
<>	149:156823d33999	4519	* Arguments to callback have been reordered to callback(func, arg)
<>	149:156823d33999	4520	*/
<>	151:5eaa88a5bcc7	4521	template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
<>	149:156823d33999	4522	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	4523	"Arguments to callback have been reordered to callback(func, arg)")
<>	151:5eaa88a5bcc7	4524	Callback<R(A0, A1, A2, A3, A4)> callback(volatile U obj, R (func)(volatile T*, A0, A1, A2, A3, A4)) {
<>	149:156823d33999	4525	return Callback<R(A0, A1, A2, A3, A4)>(func, obj);
<>	149:156823d33999	4526	}
<>	149:156823d33999	4527
<>	149:156823d33999	4528	/** Create a callback class with type infered from the arguments
<>	149:156823d33999	4529	*
<>	149:156823d33999	4530	* @param obj Optional pointer to object to bind to function
<>	149:156823d33999	4531	* @param func Static function to attach
<>	149:156823d33999	4532	* @return Callback with infered type
<>	149:156823d33999	4533	* @deprecated
<>	149:156823d33999	4534	* Arguments to callback have been reordered to callback(func, arg)
<>	149:156823d33999	4535	*/
<>	151:5eaa88a5bcc7	4536	template <typename T, typename U, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
<>	149:156823d33999	4537	MBED_DEPRECATED_SINCE("mbed-os-5.1",
<>	149:156823d33999	4538	"Arguments to callback have been reordered to callback(func, arg)")
<>	151:5eaa88a5bcc7	4539	Callback<R(A0, A1, A2, A3, A4)> callback(const volatile U obj, R (func)(const volatile T*, A0, A1, A2, A3, A4)) {
<>	149:156823d33999	4540	return Callback<R(A0, A1, A2, A3, A4)>(func, obj);
<>	149:156823d33999	4541	}
<>	149:156823d33999	4542
<>	149:156823d33999	4543
<>	149:156823d33999	4544	} // namespace mbed
<>	149:156823d33999	4545
<>	149:156823d33999	4546	#endif

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	19 Dec 2017
Imports:	0
Forks:	0
Commits:	175
Dependents:	0
Dependencies:	0
Followers:	1

platform/Callback.h@167:e84263d55307, 2017-06-21 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning