EL4121 Embedded System / mbed-os

mbed-os

Dependents:   cobaLCDJoyMotor_Thread odometry_omni_3roda_v3 odometry_omni_3roda_v1 odometry_omni_3roda_v2 ... more

platform/Callback.h@0:b74591d5ab33, 2017-12-11 (annotated)

Committer:
be_bryan
Date:
Mon Dec 11 17:54:04 2017 +0000
Revision:
0:b74591d5ab33
motor ++

Who changed what in which revision?

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