Kyle Wengryn / platform

update

Callback.h@0:bfff72fb3650, 2021-04-08 (annotated)

Committer:
kwengryn3
Date:
Thu Apr 08 16:43:07 2021 +0000
Revision:
0:bfff72fb3650
update;

Who changed what in which revision?

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