mbed-dev - mbed library sources. Supersedes mbed-src.

Users » mbed_official » Code » mbed-dev

mbed library sources. Supersedes mbed-src.

Dependents: Nucleo_Hello_Encoder BLE_iBeaconScan AM1805_DEMO DISCO-F429ZI_ExportTemplate1 ... more

platform/Callback.h@188:bcfe06ba3d64, 2018-11-08 (annotated)

Committer:: AnnaBridge
Date:: Thu Nov 08 11:46:34 2018 +0000
Revision:: 188:bcfe06ba3d64
Parent:: 187:0387e8f68319
Child:: 189:f392fc9709a3

mbed-dev library. Release version 164

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