mbed-STM32F103C8 - Modification of Mbed-dev library for LQFP48 packa…

Users » mega64 » Code » mbed-STM32F103C8

Modification of Mbed-dev library for LQFP48 package microcontrollers: STM32F103C8 (STM32F103C8T6) and STM32F103CB (STM32F103CBT6) (Bluepill boards, Maple mini etc. )

Fork of mbed-STM32F103C8_org by Nothing Special

Library for STM32F103C8 (Bluepill boards etc.).
Use this instead of mbed library.
This library allows the size of the code in the FLASH up to 128kB. Therefore, code also runs on microcontrollers STM32F103CB (eg. Maple mini).
But in the case of STM32F103C8, check the size of the resulting code would not exceed 64kB.

To compile a program with this library, use NUCLEO-F103RB as the target name. !

Changes:

Corrected initialization of the HSE + crystal clock (mbed permanent bug), allowing the use of on-board xtal (8MHz).⁽¹⁾
Additionally, it also set USB clock (48Mhz).⁽²⁾
Definitions of pins and peripherals adjusted to LQFP48 case.
Board led LED1 is now PC_13 ⁽³⁾
USER_BUTTON is now PC_14 ⁽⁴⁾

Now the library is complete rebuilt based on mbed-dev v160 (and not yet fully tested).

notes
⁽¹⁾ - In case 8MHz xtal on board, CPU frequency is 72MHz. Without xtal is 64MHz.
⁽²⁾ - Using the USB interface is only possible if STM32 is clocking by on-board 8MHz xtal or external clock signal 8MHz on the OSC_IN pin.
⁽³⁾ - On Bluepill board led operation is reversed, i.e. 0 - led on, 1 - led off.
⁽⁴⁾ - Bluepill board has no real user button

Information

After export to SW4STM (AC6):

add line #include "mbed_config.h" in files Serial.h and RawSerial.h
in project properties change Optimisation Level to Optimise for size (-Os)

platform/Callback.h@148:8b0b02bf146f, 2017-04-27 (annotated)

Committer:: mega64
Date:: Thu Apr 27 23:56:38 2017 +0000
Revision:: 148:8b0b02bf146f
Parent:: 146:03e976389d16

Remove unnecessary folders

Who changed what in which revision?

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

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	16 Mar 2017
Imports:	228
Forks:	0
Commits:	149
Dependents:	0
Dependencies:	0
Followers:	18
Issues:	0

The code in this repository is MIT licensed.

The code in this repository is Apache licensed.

Information

platform/Callback.h@148:8b0b02bf146f, 2017-04-27 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning