1

Committer:
valeyev
Date:
Tue Mar 13 07:17:50 2018 +0000
Revision:
0:e056ac8fecf8
looking for...

Who changed what in which revision?

UserRevisionLine numberNew contents of line
valeyev 0:e056ac8fecf8 1 /* events
valeyev 0:e056ac8fecf8 2 * Copyright (c) 2016 ARM Limited
valeyev 0:e056ac8fecf8 3 *
valeyev 0:e056ac8fecf8 4 * Licensed under the Apache License, Version 2.0 (the "License");
valeyev 0:e056ac8fecf8 5 * you may not use this file except in compliance with the License.
valeyev 0:e056ac8fecf8 6 * You may obtain a copy of the License at
valeyev 0:e056ac8fecf8 7 *
valeyev 0:e056ac8fecf8 8 * http://www.apache.org/licenses/LICENSE-2.0
valeyev 0:e056ac8fecf8 9 *
valeyev 0:e056ac8fecf8 10 * Unless required by applicable law or agreed to in writing, software
valeyev 0:e056ac8fecf8 11 * distributed under the License is distributed on an "AS IS" BASIS,
valeyev 0:e056ac8fecf8 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
valeyev 0:e056ac8fecf8 13 * See the License for the specific language governing permissions and
valeyev 0:e056ac8fecf8 14 * limitations under the License.
valeyev 0:e056ac8fecf8 15 */
valeyev 0:e056ac8fecf8 16
valeyev 0:e056ac8fecf8 17 #ifndef EVENT_QUEUE_H
valeyev 0:e056ac8fecf8 18 #define EVENT_QUEUE_H
valeyev 0:e056ac8fecf8 19
valeyev 0:e056ac8fecf8 20 #include "equeue/equeue.h"
valeyev 0:e056ac8fecf8 21 #include "platform/Callback.h"
valeyev 0:e056ac8fecf8 22 #include "platform/NonCopyable.h"
valeyev 0:e056ac8fecf8 23 #include <cstddef>
valeyev 0:e056ac8fecf8 24 #include <new>
valeyev 0:e056ac8fecf8 25
valeyev 0:e056ac8fecf8 26 namespace events {
valeyev 0:e056ac8fecf8 27 /** \addtogroup events */
valeyev 0:e056ac8fecf8 28
valeyev 0:e056ac8fecf8 29 /** EVENTS_EVENT_SIZE
valeyev 0:e056ac8fecf8 30 * Minimum size of an event
valeyev 0:e056ac8fecf8 31 * This size fits a Callback<void()> at minimum
valeyev 0:e056ac8fecf8 32 */
valeyev 0:e056ac8fecf8 33 #define EVENTS_EVENT_SIZE \
valeyev 0:e056ac8fecf8 34 (EQUEUE_EVENT_SIZE - 2*sizeof(void*) + sizeof(mbed::Callback<void()>))
valeyev 0:e056ac8fecf8 35
valeyev 0:e056ac8fecf8 36 /** EVENTS_QUEUE_SIZE
valeyev 0:e056ac8fecf8 37 * Default size of buffer for events
valeyev 0:e056ac8fecf8 38 */
valeyev 0:e056ac8fecf8 39 #define EVENTS_QUEUE_SIZE (32*EVENTS_EVENT_SIZE)
valeyev 0:e056ac8fecf8 40
valeyev 0:e056ac8fecf8 41 // Predeclared classes
valeyev 0:e056ac8fecf8 42 template <typename F>
valeyev 0:e056ac8fecf8 43 class Event;
valeyev 0:e056ac8fecf8 44
valeyev 0:e056ac8fecf8 45
valeyev 0:e056ac8fecf8 46 /** EventQueue
valeyev 0:e056ac8fecf8 47 *
valeyev 0:e056ac8fecf8 48 * Flexible event queue for dispatching events
valeyev 0:e056ac8fecf8 49 * @ingroup events
valeyev 0:e056ac8fecf8 50 */
valeyev 0:e056ac8fecf8 51 class EventQueue : private mbed::NonCopyable<EventQueue> {
valeyev 0:e056ac8fecf8 52 public:
valeyev 0:e056ac8fecf8 53 /** Create an EventQueue
valeyev 0:e056ac8fecf8 54 *
valeyev 0:e056ac8fecf8 55 * Create an event queue. The event queue either allocates a buffer of
valeyev 0:e056ac8fecf8 56 * the specified size with malloc or uses the user provided buffer.
valeyev 0:e056ac8fecf8 57 *
valeyev 0:e056ac8fecf8 58 * @param size Size of buffer to use for events in bytes
valeyev 0:e056ac8fecf8 59 * (default to EVENTS_QUEUE_SIZE)
valeyev 0:e056ac8fecf8 60 * @param buffer Pointer to buffer to use for events
valeyev 0:e056ac8fecf8 61 * (default to NULL)
valeyev 0:e056ac8fecf8 62 */
valeyev 0:e056ac8fecf8 63 EventQueue(unsigned size=EVENTS_QUEUE_SIZE, unsigned char *buffer=NULL);
valeyev 0:e056ac8fecf8 64
valeyev 0:e056ac8fecf8 65 /** Destroy an EventQueue
valeyev 0:e056ac8fecf8 66 */
valeyev 0:e056ac8fecf8 67 ~EventQueue();
valeyev 0:e056ac8fecf8 68
valeyev 0:e056ac8fecf8 69 /** Dispatch events
valeyev 0:e056ac8fecf8 70 *
valeyev 0:e056ac8fecf8 71 * Executes events until the specified milliseconds have passed.
valeyev 0:e056ac8fecf8 72 * If ms is negative, the dispatch function will dispatch events
valeyev 0:e056ac8fecf8 73 * indefinitely or until break_dispatch is called on this queue.
valeyev 0:e056ac8fecf8 74 *
valeyev 0:e056ac8fecf8 75 * When called with a finite timeout, the dispatch function is guaranteed
valeyev 0:e056ac8fecf8 76 * to terminate. When called with a timeout of 0, the dispatch function
valeyev 0:e056ac8fecf8 77 * does not wait and is irq safe.
valeyev 0:e056ac8fecf8 78 *
valeyev 0:e056ac8fecf8 79 * @param ms Time to wait for events in milliseconds, a negative
valeyev 0:e056ac8fecf8 80 * value will dispatch events indefinitely
valeyev 0:e056ac8fecf8 81 * (default to -1)
valeyev 0:e056ac8fecf8 82 */
valeyev 0:e056ac8fecf8 83 void dispatch(int ms=-1);
valeyev 0:e056ac8fecf8 84
valeyev 0:e056ac8fecf8 85 /** Dispatch events without a timeout
valeyev 0:e056ac8fecf8 86 *
valeyev 0:e056ac8fecf8 87 * This is equivalent to EventQueue::dispatch with no arguments, but
valeyev 0:e056ac8fecf8 88 * avoids overload ambiguities when passed as a callback.
valeyev 0:e056ac8fecf8 89 *
valeyev 0:e056ac8fecf8 90 * @see EventQueue::dispatch
valeyev 0:e056ac8fecf8 91 */
valeyev 0:e056ac8fecf8 92 void dispatch_forever() { dispatch(); }
valeyev 0:e056ac8fecf8 93
valeyev 0:e056ac8fecf8 94 /** Break out of a running event loop
valeyev 0:e056ac8fecf8 95 *
valeyev 0:e056ac8fecf8 96 * Forces the specified event queue's dispatch loop to terminate. Pending
valeyev 0:e056ac8fecf8 97 * events may finish executing, but no new events will be executed.
valeyev 0:e056ac8fecf8 98 */
valeyev 0:e056ac8fecf8 99 void break_dispatch();
valeyev 0:e056ac8fecf8 100
valeyev 0:e056ac8fecf8 101 /** Millisecond counter
valeyev 0:e056ac8fecf8 102 *
valeyev 0:e056ac8fecf8 103 * Returns the underlying tick of the event queue represented as the
valeyev 0:e056ac8fecf8 104 * number of milliseconds that have passed since an arbitrary point in
valeyev 0:e056ac8fecf8 105 * time. Intentionally overflows to 0 after 2^32-1.
valeyev 0:e056ac8fecf8 106 *
valeyev 0:e056ac8fecf8 107 * @return The underlying tick of the event queue in milliseconds
valeyev 0:e056ac8fecf8 108 */
valeyev 0:e056ac8fecf8 109 unsigned tick();
valeyev 0:e056ac8fecf8 110
valeyev 0:e056ac8fecf8 111 /** Cancel an in-flight event
valeyev 0:e056ac8fecf8 112 *
valeyev 0:e056ac8fecf8 113 * Attempts to cancel an event referenced by the unique id returned from
valeyev 0:e056ac8fecf8 114 * one of the call functions. It is safe to call cancel after an event
valeyev 0:e056ac8fecf8 115 * has already been dispatched.
valeyev 0:e056ac8fecf8 116 *
valeyev 0:e056ac8fecf8 117 * The cancel function is irq safe.
valeyev 0:e056ac8fecf8 118 *
valeyev 0:e056ac8fecf8 119 * If called while the event queue's dispatch loop is active, the cancel
valeyev 0:e056ac8fecf8 120 * function does not garuntee that the event will not execute after it
valeyev 0:e056ac8fecf8 121 * returns, as the event may have already begun executing.
valeyev 0:e056ac8fecf8 122 *
valeyev 0:e056ac8fecf8 123 * @param id Unique id of the event
valeyev 0:e056ac8fecf8 124 */
valeyev 0:e056ac8fecf8 125 void cancel(int id);
valeyev 0:e056ac8fecf8 126
valeyev 0:e056ac8fecf8 127 /** Background an event queue onto a single-shot timer-interrupt
valeyev 0:e056ac8fecf8 128 *
valeyev 0:e056ac8fecf8 129 * When updated, the event queue will call the provided update function
valeyev 0:e056ac8fecf8 130 * with a timeout indicating when the queue should be dispatched. A
valeyev 0:e056ac8fecf8 131 * negative timeout will be passed to the update function when the
valeyev 0:e056ac8fecf8 132 * timer-interrupt is no longer needed.
valeyev 0:e056ac8fecf8 133 *
valeyev 0:e056ac8fecf8 134 * Passing a null function disables the existing update function.
valeyev 0:e056ac8fecf8 135 *
valeyev 0:e056ac8fecf8 136 * The background function allows an event queue to take advantage of
valeyev 0:e056ac8fecf8 137 * hardware timers or other event loops, allowing an event queue to be
valeyev 0:e056ac8fecf8 138 * ran in the background without consuming the foreground thread.
valeyev 0:e056ac8fecf8 139 *
valeyev 0:e056ac8fecf8 140 * @param update Function called to indicate when the queue should be
valeyev 0:e056ac8fecf8 141 * dispatched
valeyev 0:e056ac8fecf8 142 */
valeyev 0:e056ac8fecf8 143 void background(mbed::Callback<void(int)> update);
valeyev 0:e056ac8fecf8 144
valeyev 0:e056ac8fecf8 145 /** Chain an event queue onto another event queue
valeyev 0:e056ac8fecf8 146 *
valeyev 0:e056ac8fecf8 147 * After chaining a queue to a target, calling dispatch on the target
valeyev 0:e056ac8fecf8 148 * queue will also dispatch events from this queue. The queues use
valeyev 0:e056ac8fecf8 149 * their own buffers and events must be handled independently.
valeyev 0:e056ac8fecf8 150 *
valeyev 0:e056ac8fecf8 151 * A null queue as the target will unchain the existing queue.
valeyev 0:e056ac8fecf8 152 *
valeyev 0:e056ac8fecf8 153 * The chain function allows multiple event queues to be composed,
valeyev 0:e056ac8fecf8 154 * sharing the context of a dispatch loop while still being managed
valeyev 0:e056ac8fecf8 155 * independently
valeyev 0:e056ac8fecf8 156 *
valeyev 0:e056ac8fecf8 157 * @param target Queue that will dispatch this queue's events as a
valeyev 0:e056ac8fecf8 158 * part of its dispatch loop
valeyev 0:e056ac8fecf8 159 */
valeyev 0:e056ac8fecf8 160 void chain(EventQueue *target);
valeyev 0:e056ac8fecf8 161
valeyev 0:e056ac8fecf8 162 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 163 *
valeyev 0:e056ac8fecf8 164 * The specified callback will be executed in the context of the event
valeyev 0:e056ac8fecf8 165 * queue's dispatch loop.
valeyev 0:e056ac8fecf8 166 *
valeyev 0:e056ac8fecf8 167 * The call function is irq safe and can act as a mechanism for moving
valeyev 0:e056ac8fecf8 168 * events out of irq contexts.
valeyev 0:e056ac8fecf8 169 *
valeyev 0:e056ac8fecf8 170 * @param f Function to execute in the context of the dispatch loop
valeyev 0:e056ac8fecf8 171 * @return A unique id that represents the posted event and can
valeyev 0:e056ac8fecf8 172 * be passed to cancel, or an id of 0 if there is not
valeyev 0:e056ac8fecf8 173 * enough memory to allocate the event.
valeyev 0:e056ac8fecf8 174 */
valeyev 0:e056ac8fecf8 175 template <typename F>
valeyev 0:e056ac8fecf8 176 int call(F f) {
valeyev 0:e056ac8fecf8 177 void *p = equeue_alloc(&_equeue, sizeof(F));
valeyev 0:e056ac8fecf8 178 if (!p) {
valeyev 0:e056ac8fecf8 179 return 0;
valeyev 0:e056ac8fecf8 180 }
valeyev 0:e056ac8fecf8 181
valeyev 0:e056ac8fecf8 182 F *e = new (p) F(f);
valeyev 0:e056ac8fecf8 183 equeue_event_dtor(e, &EventQueue::function_dtor<F>);
valeyev 0:e056ac8fecf8 184 return equeue_post(&_equeue, &EventQueue::function_call<F>, e);
valeyev 0:e056ac8fecf8 185 }
valeyev 0:e056ac8fecf8 186
valeyev 0:e056ac8fecf8 187 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 188 * @see EventQueue::call
valeyev 0:e056ac8fecf8 189 * @param f Function to execute in the context of the dispatch loop
valeyev 0:e056ac8fecf8 190 * @param a0 Argument to pass to the callback
valeyev 0:e056ac8fecf8 191 */
valeyev 0:e056ac8fecf8 192 template <typename F, typename A0>
valeyev 0:e056ac8fecf8 193 int call(F f, A0 a0) {
valeyev 0:e056ac8fecf8 194 return call(context10<F, A0>(f, a0));
valeyev 0:e056ac8fecf8 195 }
valeyev 0:e056ac8fecf8 196
valeyev 0:e056ac8fecf8 197 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 198 * @see EventQueue::call
valeyev 0:e056ac8fecf8 199 * @param f Function to execute in the context of the dispatch loop
valeyev 0:e056ac8fecf8 200 * @param a0,a1 Arguments to pass to the callback
valeyev 0:e056ac8fecf8 201 */
valeyev 0:e056ac8fecf8 202 template <typename F, typename A0, typename A1>
valeyev 0:e056ac8fecf8 203 int call(F f, A0 a0, A1 a1) {
valeyev 0:e056ac8fecf8 204 return call(context20<F, A0, A1>(f, a0, a1));
valeyev 0:e056ac8fecf8 205 }
valeyev 0:e056ac8fecf8 206
valeyev 0:e056ac8fecf8 207 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 208 * @see EventQueue::call
valeyev 0:e056ac8fecf8 209 * @param f Function to execute in the context of the dispatch loop
valeyev 0:e056ac8fecf8 210 * @param a0,a1,a2 Arguments to pass to the callback
valeyev 0:e056ac8fecf8 211 */
valeyev 0:e056ac8fecf8 212 template <typename F, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 213 int call(F f, A0 a0, A1 a1, A2 a2) {
valeyev 0:e056ac8fecf8 214 return call(context30<F, A0, A1, A2>(f, a0, a1, a2));
valeyev 0:e056ac8fecf8 215 }
valeyev 0:e056ac8fecf8 216
valeyev 0:e056ac8fecf8 217 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 218 * @see EventQueue::call
valeyev 0:e056ac8fecf8 219 * @param f Function to execute in the context of the dispatch loop
valeyev 0:e056ac8fecf8 220 * @param a0,a1,a2,a3 Arguments to pass to the callback
valeyev 0:e056ac8fecf8 221 */
valeyev 0:e056ac8fecf8 222 template <typename F, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 223 int call(F f, A0 a0, A1 a1, A2 a2, A3 a3) {
valeyev 0:e056ac8fecf8 224 return call(context40<F, A0, A1, A2, A3>(f, a0, a1, a2, a3));
valeyev 0:e056ac8fecf8 225 }
valeyev 0:e056ac8fecf8 226
valeyev 0:e056ac8fecf8 227 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 228 * @see EventQueue::call
valeyev 0:e056ac8fecf8 229 * @param f Function to execute in the context of the dispatch loop
valeyev 0:e056ac8fecf8 230 * @param a0,a1,a2,a3,a4 Arguments to pass to the callback
valeyev 0:e056ac8fecf8 231 */
valeyev 0:e056ac8fecf8 232 template <typename F, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 233 int call(F f, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
valeyev 0:e056ac8fecf8 234 return call(context50<F, A0, A1, A2, A3, A4>(f, a0, a1, a2, a3, a4));
valeyev 0:e056ac8fecf8 235 }
valeyev 0:e056ac8fecf8 236
valeyev 0:e056ac8fecf8 237 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 238 * @see EventQueue::call
valeyev 0:e056ac8fecf8 239 */
valeyev 0:e056ac8fecf8 240 template <typename T, typename R>
valeyev 0:e056ac8fecf8 241 int call(T *obj, R (T::*method)()) {
valeyev 0:e056ac8fecf8 242 return call(mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 243 }
valeyev 0:e056ac8fecf8 244
valeyev 0:e056ac8fecf8 245 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 246 * @see EventQueue::call
valeyev 0:e056ac8fecf8 247 */
valeyev 0:e056ac8fecf8 248 template <typename T, typename R>
valeyev 0:e056ac8fecf8 249 int call(const T *obj, R (T::*method)() const) {
valeyev 0:e056ac8fecf8 250 return call(mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 251 }
valeyev 0:e056ac8fecf8 252
valeyev 0:e056ac8fecf8 253 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 254 * @see EventQueue::call
valeyev 0:e056ac8fecf8 255 */
valeyev 0:e056ac8fecf8 256 template <typename T, typename R>
valeyev 0:e056ac8fecf8 257 int call(volatile T *obj, R (T::*method)() volatile) {
valeyev 0:e056ac8fecf8 258 return call(mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 259 }
valeyev 0:e056ac8fecf8 260
valeyev 0:e056ac8fecf8 261 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 262 * @see EventQueue::call
valeyev 0:e056ac8fecf8 263 */
valeyev 0:e056ac8fecf8 264 template <typename T, typename R>
valeyev 0:e056ac8fecf8 265 int call(const volatile T *obj, R (T::*method)() const volatile) {
valeyev 0:e056ac8fecf8 266 return call(mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 267 }
valeyev 0:e056ac8fecf8 268
valeyev 0:e056ac8fecf8 269 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 270 * @see EventQueue::call
valeyev 0:e056ac8fecf8 271 */
valeyev 0:e056ac8fecf8 272 template <typename T, typename R, typename A0>
valeyev 0:e056ac8fecf8 273 int call(T *obj, R (T::*method)(A0), A0 a0) {
valeyev 0:e056ac8fecf8 274 return call(mbed::callback(obj, method), a0);
valeyev 0:e056ac8fecf8 275 }
valeyev 0:e056ac8fecf8 276
valeyev 0:e056ac8fecf8 277 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 278 * @see EventQueue::call
valeyev 0:e056ac8fecf8 279 */
valeyev 0:e056ac8fecf8 280 template <typename T, typename R, typename A0>
valeyev 0:e056ac8fecf8 281 int call(const T *obj, R (T::*method)(A0) const, A0 a0) {
valeyev 0:e056ac8fecf8 282 return call(mbed::callback(obj, method), a0);
valeyev 0:e056ac8fecf8 283 }
valeyev 0:e056ac8fecf8 284
valeyev 0:e056ac8fecf8 285 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 286 * @see EventQueue::call
valeyev 0:e056ac8fecf8 287 */
valeyev 0:e056ac8fecf8 288 template <typename T, typename R, typename A0>
valeyev 0:e056ac8fecf8 289 int call(volatile T *obj, R (T::*method)(A0) volatile, A0 a0) {
valeyev 0:e056ac8fecf8 290 return call(mbed::callback(obj, method), a0);
valeyev 0:e056ac8fecf8 291 }
valeyev 0:e056ac8fecf8 292
valeyev 0:e056ac8fecf8 293 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 294 * @see EventQueue::call
valeyev 0:e056ac8fecf8 295 */
valeyev 0:e056ac8fecf8 296 template <typename T, typename R, typename A0>
valeyev 0:e056ac8fecf8 297 int call(const volatile T *obj, R (T::*method)(A0) const volatile, A0 a0) {
valeyev 0:e056ac8fecf8 298 return call(mbed::callback(obj, method), a0);
valeyev 0:e056ac8fecf8 299 }
valeyev 0:e056ac8fecf8 300
valeyev 0:e056ac8fecf8 301 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 302 * @see EventQueue::call
valeyev 0:e056ac8fecf8 303 */
valeyev 0:e056ac8fecf8 304 template <typename T, typename R, typename A0, typename A1>
valeyev 0:e056ac8fecf8 305 int call(T *obj, R (T::*method)(A0, A1), A0 a0, A1 a1) {
valeyev 0:e056ac8fecf8 306 return call(mbed::callback(obj, method), a0, a1);
valeyev 0:e056ac8fecf8 307 }
valeyev 0:e056ac8fecf8 308
valeyev 0:e056ac8fecf8 309 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 310 * @see EventQueue::call
valeyev 0:e056ac8fecf8 311 */
valeyev 0:e056ac8fecf8 312 template <typename T, typename R, typename A0, typename A1>
valeyev 0:e056ac8fecf8 313 int call(const T *obj, R (T::*method)(A0, A1) const, A0 a0, A1 a1) {
valeyev 0:e056ac8fecf8 314 return call(mbed::callback(obj, method), a0, a1);
valeyev 0:e056ac8fecf8 315 }
valeyev 0:e056ac8fecf8 316
valeyev 0:e056ac8fecf8 317 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 318 * @see EventQueue::call
valeyev 0:e056ac8fecf8 319 */
valeyev 0:e056ac8fecf8 320 template <typename T, typename R, typename A0, typename A1>
valeyev 0:e056ac8fecf8 321 int call(volatile T *obj, R (T::*method)(A0, A1) volatile, A0 a0, A1 a1) {
valeyev 0:e056ac8fecf8 322 return call(mbed::callback(obj, method), a0, a1);
valeyev 0:e056ac8fecf8 323 }
valeyev 0:e056ac8fecf8 324
valeyev 0:e056ac8fecf8 325 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 326 * @see EventQueue::call
valeyev 0:e056ac8fecf8 327 */
valeyev 0:e056ac8fecf8 328 template <typename T, typename R, typename A0, typename A1>
valeyev 0:e056ac8fecf8 329 int call(const volatile T *obj, R (T::*method)(A0, A1) const volatile, A0 a0, A1 a1) {
valeyev 0:e056ac8fecf8 330 return call(mbed::callback(obj, method), a0, a1);
valeyev 0:e056ac8fecf8 331 }
valeyev 0:e056ac8fecf8 332
valeyev 0:e056ac8fecf8 333 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 334 * @see EventQueue::call
valeyev 0:e056ac8fecf8 335 */
valeyev 0:e056ac8fecf8 336 template <typename T, typename R, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 337 int call(T *obj, R (T::*method)(A0, A1, A2), A0 a0, A1 a1, A2 a2) {
valeyev 0:e056ac8fecf8 338 return call(mbed::callback(obj, method), a0, a1, a2);
valeyev 0:e056ac8fecf8 339 }
valeyev 0:e056ac8fecf8 340
valeyev 0:e056ac8fecf8 341 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 342 * @see EventQueue::call
valeyev 0:e056ac8fecf8 343 */
valeyev 0:e056ac8fecf8 344 template <typename T, typename R, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 345 int call(const T *obj, R (T::*method)(A0, A1, A2) const, A0 a0, A1 a1, A2 a2) {
valeyev 0:e056ac8fecf8 346 return call(mbed::callback(obj, method), a0, a1, a2);
valeyev 0:e056ac8fecf8 347 }
valeyev 0:e056ac8fecf8 348
valeyev 0:e056ac8fecf8 349 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 350 * @see EventQueue::call
valeyev 0:e056ac8fecf8 351 */
valeyev 0:e056ac8fecf8 352 template <typename T, typename R, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 353 int call(volatile T *obj, R (T::*method)(A0, A1, A2) volatile, A0 a0, A1 a1, A2 a2) {
valeyev 0:e056ac8fecf8 354 return call(mbed::callback(obj, method), a0, a1, a2);
valeyev 0:e056ac8fecf8 355 }
valeyev 0:e056ac8fecf8 356
valeyev 0:e056ac8fecf8 357 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 358 * @see EventQueue::call
valeyev 0:e056ac8fecf8 359 */
valeyev 0:e056ac8fecf8 360 template <typename T, typename R, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 361 int call(const volatile T *obj, R (T::*method)(A0, A1, A2) const volatile, A0 a0, A1 a1, A2 a2) {
valeyev 0:e056ac8fecf8 362 return call(mbed::callback(obj, method), a0, a1, a2);
valeyev 0:e056ac8fecf8 363 }
valeyev 0:e056ac8fecf8 364
valeyev 0:e056ac8fecf8 365 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 366 * @see EventQueue::call
valeyev 0:e056ac8fecf8 367 */
valeyev 0:e056ac8fecf8 368 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 369 int call(T *obj, R (T::*method)(A0, A1, A2, A3), A0 a0, A1 a1, A2 a2, A3 a3) {
valeyev 0:e056ac8fecf8 370 return call(mbed::callback(obj, method), a0, a1, a2, a3);
valeyev 0:e056ac8fecf8 371 }
valeyev 0:e056ac8fecf8 372
valeyev 0:e056ac8fecf8 373 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 374 * @see EventQueue::call
valeyev 0:e056ac8fecf8 375 */
valeyev 0:e056ac8fecf8 376 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 377 int call(const T *obj, R (T::*method)(A0, A1, A2, A3) const, A0 a0, A1 a1, A2 a2, A3 a3) {
valeyev 0:e056ac8fecf8 378 return call(mbed::callback(obj, method), a0, a1, a2, a3);
valeyev 0:e056ac8fecf8 379 }
valeyev 0:e056ac8fecf8 380
valeyev 0:e056ac8fecf8 381 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 382 * @see EventQueue::call
valeyev 0:e056ac8fecf8 383 */
valeyev 0:e056ac8fecf8 384 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 385 int call(volatile T *obj, R (T::*method)(A0, A1, A2, A3) volatile, A0 a0, A1 a1, A2 a2, A3 a3) {
valeyev 0:e056ac8fecf8 386 return call(mbed::callback(obj, method), a0, a1, a2, a3);
valeyev 0:e056ac8fecf8 387 }
valeyev 0:e056ac8fecf8 388
valeyev 0:e056ac8fecf8 389 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 390 * @see EventQueue::call
valeyev 0:e056ac8fecf8 391 */
valeyev 0:e056ac8fecf8 392 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 393 int call(const volatile T *obj, R (T::*method)(A0, A1, A2, A3) const volatile, A0 a0, A1 a1, A2 a2, A3 a3) {
valeyev 0:e056ac8fecf8 394 return call(mbed::callback(obj, method), a0, a1, a2, a3);
valeyev 0:e056ac8fecf8 395 }
valeyev 0:e056ac8fecf8 396
valeyev 0:e056ac8fecf8 397 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 398 * @see EventQueue::call
valeyev 0:e056ac8fecf8 399 */
valeyev 0:e056ac8fecf8 400 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 401 int call(T *obj, R (T::*method)(A0, A1, A2, A3, A4), A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
valeyev 0:e056ac8fecf8 402 return call(mbed::callback(obj, method), a0, a1, a2, a3, a4);
valeyev 0:e056ac8fecf8 403 }
valeyev 0:e056ac8fecf8 404
valeyev 0:e056ac8fecf8 405 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 406 * @see EventQueue::call
valeyev 0:e056ac8fecf8 407 */
valeyev 0:e056ac8fecf8 408 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 409 int call(const T *obj, R (T::*method)(A0, A1, A2, A3, A4) const, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
valeyev 0:e056ac8fecf8 410 return call(mbed::callback(obj, method), a0, a1, a2, a3, a4);
valeyev 0:e056ac8fecf8 411 }
valeyev 0:e056ac8fecf8 412
valeyev 0:e056ac8fecf8 413 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 414 * @see EventQueue::call
valeyev 0:e056ac8fecf8 415 */
valeyev 0:e056ac8fecf8 416 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 417 int call(volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) volatile, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
valeyev 0:e056ac8fecf8 418 return call(mbed::callback(obj, method), a0, a1, a2, a3, a4);
valeyev 0:e056ac8fecf8 419 }
valeyev 0:e056ac8fecf8 420
valeyev 0:e056ac8fecf8 421 /** Calls an event on the queue
valeyev 0:e056ac8fecf8 422 * @see EventQueue::call
valeyev 0:e056ac8fecf8 423 */
valeyev 0:e056ac8fecf8 424 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 425 int call(const volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) const volatile, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
valeyev 0:e056ac8fecf8 426 return call(mbed::callback(obj, method), a0, a1, a2, a3, a4);
valeyev 0:e056ac8fecf8 427 }
valeyev 0:e056ac8fecf8 428
valeyev 0:e056ac8fecf8 429 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 430 *
valeyev 0:e056ac8fecf8 431 * The specified callback will be executed in the context of the event
valeyev 0:e056ac8fecf8 432 * queue's dispatch loop.
valeyev 0:e056ac8fecf8 433 *
valeyev 0:e056ac8fecf8 434 * The call_in function is irq safe and can act as a mechanism for moving
valeyev 0:e056ac8fecf8 435 * events out of irq contexts.
valeyev 0:e056ac8fecf8 436 *
valeyev 0:e056ac8fecf8 437 * @param f Function to execute in the context of the dispatch loop
valeyev 0:e056ac8fecf8 438 * @param ms Time to delay in milliseconds
valeyev 0:e056ac8fecf8 439 * @return A unique id that represents the posted event and can
valeyev 0:e056ac8fecf8 440 * be passed to cancel, or an id of 0 if there is not
valeyev 0:e056ac8fecf8 441 * enough memory to allocate the event.
valeyev 0:e056ac8fecf8 442 */
valeyev 0:e056ac8fecf8 443 template <typename F>
valeyev 0:e056ac8fecf8 444 int call_in(int ms, F f) {
valeyev 0:e056ac8fecf8 445 void *p = equeue_alloc(&_equeue, sizeof(F));
valeyev 0:e056ac8fecf8 446 if (!p) {
valeyev 0:e056ac8fecf8 447 return 0;
valeyev 0:e056ac8fecf8 448 }
valeyev 0:e056ac8fecf8 449
valeyev 0:e056ac8fecf8 450 F *e = new (p) F(f);
valeyev 0:e056ac8fecf8 451 equeue_event_delay(e, ms);
valeyev 0:e056ac8fecf8 452 equeue_event_dtor(e, &EventQueue::function_dtor<F>);
valeyev 0:e056ac8fecf8 453 return equeue_post(&_equeue, &EventQueue::function_call<F>, e);
valeyev 0:e056ac8fecf8 454 }
valeyev 0:e056ac8fecf8 455
valeyev 0:e056ac8fecf8 456 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 457 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 458 * @param ms Time to delay in milliseconds
valeyev 0:e056ac8fecf8 459 * @param f Function to execute in the context of the dispatch loop
valeyev 0:e056ac8fecf8 460 * @param a0 Argument to pass to the callback
valeyev 0:e056ac8fecf8 461 */
valeyev 0:e056ac8fecf8 462 template <typename F, typename A0>
valeyev 0:e056ac8fecf8 463 int call_in(int ms, F f, A0 a0) {
valeyev 0:e056ac8fecf8 464 return call_in(ms, context10<F, A0>(f, a0));
valeyev 0:e056ac8fecf8 465 }
valeyev 0:e056ac8fecf8 466
valeyev 0:e056ac8fecf8 467 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 468 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 469 * @param ms Time to delay in milliseconds
valeyev 0:e056ac8fecf8 470 * @param f Function to execute in the context of the dispatch loop
valeyev 0:e056ac8fecf8 471 * @param a0,a1 Arguments to pass to the callback
valeyev 0:e056ac8fecf8 472 */
valeyev 0:e056ac8fecf8 473 template <typename F, typename A0, typename A1>
valeyev 0:e056ac8fecf8 474 int call_in(int ms, F f, A0 a0, A1 a1) {
valeyev 0:e056ac8fecf8 475 return call_in(ms, context20<F, A0, A1>(f, a0, a1));
valeyev 0:e056ac8fecf8 476 }
valeyev 0:e056ac8fecf8 477
valeyev 0:e056ac8fecf8 478 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 479 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 480 * @param ms Time to delay in milliseconds
valeyev 0:e056ac8fecf8 481 * @param f Function to execute in the context of the dispatch loop
valeyev 0:e056ac8fecf8 482 * @param a0,a1,a2 Arguments to pass to the callback
valeyev 0:e056ac8fecf8 483 */
valeyev 0:e056ac8fecf8 484 template <typename F, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 485 int call_in(int ms, F f, A0 a0, A1 a1, A2 a2) {
valeyev 0:e056ac8fecf8 486 return call_in(ms, context30<F, A0, A1, A2>(f, a0, a1, a2));
valeyev 0:e056ac8fecf8 487 }
valeyev 0:e056ac8fecf8 488
valeyev 0:e056ac8fecf8 489 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 490 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 491 * @param ms Time to delay in milliseconds
valeyev 0:e056ac8fecf8 492 * @param f Function to execute in the context of the dispatch loop
valeyev 0:e056ac8fecf8 493 * @param a0,a1,a2,a3 Arguments to pass to the callback
valeyev 0:e056ac8fecf8 494 */
valeyev 0:e056ac8fecf8 495 template <typename F, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 496 int call_in(int ms, F f, A0 a0, A1 a1, A2 a2, A3 a3) {
valeyev 0:e056ac8fecf8 497 return call_in(ms, context40<F, A0, A1, A2, A3>(f, a0, a1, a2, a3));
valeyev 0:e056ac8fecf8 498 }
valeyev 0:e056ac8fecf8 499
valeyev 0:e056ac8fecf8 500 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 501 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 502 * @param ms Time to delay in milliseconds
valeyev 0:e056ac8fecf8 503 * @param f Function to execute in the context of the dispatch loop
valeyev 0:e056ac8fecf8 504 * @param a0,a1,a2,a3,a4 Arguments to pass to the callback
valeyev 0:e056ac8fecf8 505 */
valeyev 0:e056ac8fecf8 506 template <typename F, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 507 int call_in(int ms, F f, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
valeyev 0:e056ac8fecf8 508 return call_in(ms, context50<F, A0, A1, A2, A3, A4>(f, a0, a1, a2, a3, a4));
valeyev 0:e056ac8fecf8 509 }
valeyev 0:e056ac8fecf8 510
valeyev 0:e056ac8fecf8 511 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 512 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 513 */
valeyev 0:e056ac8fecf8 514 template <typename T, typename R>
valeyev 0:e056ac8fecf8 515 int call_in(int ms, T *obj, R (T::*method)()) {
valeyev 0:e056ac8fecf8 516 return call_in(ms, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 517 }
valeyev 0:e056ac8fecf8 518
valeyev 0:e056ac8fecf8 519 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 520 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 521 */
valeyev 0:e056ac8fecf8 522 template <typename T, typename R>
valeyev 0:e056ac8fecf8 523 int call_in(int ms, const T *obj, R (T::*method)() const) {
valeyev 0:e056ac8fecf8 524 return call_in(ms, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 525 }
valeyev 0:e056ac8fecf8 526
valeyev 0:e056ac8fecf8 527 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 528 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 529 */
valeyev 0:e056ac8fecf8 530 template <typename T, typename R>
valeyev 0:e056ac8fecf8 531 int call_in(int ms, volatile T *obj, R (T::*method)() volatile) {
valeyev 0:e056ac8fecf8 532 return call_in(ms, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 533 }
valeyev 0:e056ac8fecf8 534
valeyev 0:e056ac8fecf8 535 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 536 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 537 */
valeyev 0:e056ac8fecf8 538 template <typename T, typename R>
valeyev 0:e056ac8fecf8 539 int call_in(int ms, const volatile T *obj, R (T::*method)() const volatile) {
valeyev 0:e056ac8fecf8 540 return call_in(ms, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 541 }
valeyev 0:e056ac8fecf8 542
valeyev 0:e056ac8fecf8 543 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 544 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 545 */
valeyev 0:e056ac8fecf8 546 template <typename T, typename R, typename A0>
valeyev 0:e056ac8fecf8 547 int call_in(int ms, T *obj, R (T::*method)(A0), A0 a0) {
valeyev 0:e056ac8fecf8 548 return call_in(ms, mbed::callback(obj, method), a0);
valeyev 0:e056ac8fecf8 549 }
valeyev 0:e056ac8fecf8 550
valeyev 0:e056ac8fecf8 551 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 552 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 553 */
valeyev 0:e056ac8fecf8 554 template <typename T, typename R, typename A0>
valeyev 0:e056ac8fecf8 555 int call_in(int ms, const T *obj, R (T::*method)(A0) const, A0 a0) {
valeyev 0:e056ac8fecf8 556 return call_in(ms, mbed::callback(obj, method), a0);
valeyev 0:e056ac8fecf8 557 }
valeyev 0:e056ac8fecf8 558
valeyev 0:e056ac8fecf8 559 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 560 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 561 */
valeyev 0:e056ac8fecf8 562 template <typename T, typename R, typename A0>
valeyev 0:e056ac8fecf8 563 int call_in(int ms, volatile T *obj, R (T::*method)(A0) volatile, A0 a0) {
valeyev 0:e056ac8fecf8 564 return call_in(ms, mbed::callback(obj, method), a0);
valeyev 0:e056ac8fecf8 565 }
valeyev 0:e056ac8fecf8 566
valeyev 0:e056ac8fecf8 567 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 568 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 569 */
valeyev 0:e056ac8fecf8 570 template <typename T, typename R, typename A0>
valeyev 0:e056ac8fecf8 571 int call_in(int ms, const volatile T *obj, R (T::*method)(A0) const volatile, A0 a0) {
valeyev 0:e056ac8fecf8 572 return call_in(ms, mbed::callback(obj, method), a0);
valeyev 0:e056ac8fecf8 573 }
valeyev 0:e056ac8fecf8 574
valeyev 0:e056ac8fecf8 575 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 576 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 577 */
valeyev 0:e056ac8fecf8 578 template <typename T, typename R, typename A0, typename A1>
valeyev 0:e056ac8fecf8 579 int call_in(int ms, T *obj, R (T::*method)(A0, A1), A0 a0, A1 a1) {
valeyev 0:e056ac8fecf8 580 return call_in(ms, mbed::callback(obj, method), a0, a1);
valeyev 0:e056ac8fecf8 581 }
valeyev 0:e056ac8fecf8 582
valeyev 0:e056ac8fecf8 583 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 584 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 585 */
valeyev 0:e056ac8fecf8 586 template <typename T, typename R, typename A0, typename A1>
valeyev 0:e056ac8fecf8 587 int call_in(int ms, const T *obj, R (T::*method)(A0, A1) const, A0 a0, A1 a1) {
valeyev 0:e056ac8fecf8 588 return call_in(ms, mbed::callback(obj, method), a0, a1);
valeyev 0:e056ac8fecf8 589 }
valeyev 0:e056ac8fecf8 590
valeyev 0:e056ac8fecf8 591 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 592 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 593 */
valeyev 0:e056ac8fecf8 594 template <typename T, typename R, typename A0, typename A1>
valeyev 0:e056ac8fecf8 595 int call_in(int ms, volatile T *obj, R (T::*method)(A0, A1) volatile, A0 a0, A1 a1) {
valeyev 0:e056ac8fecf8 596 return call_in(ms, mbed::callback(obj, method), a0, a1);
valeyev 0:e056ac8fecf8 597 }
valeyev 0:e056ac8fecf8 598
valeyev 0:e056ac8fecf8 599 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 600 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 601 */
valeyev 0:e056ac8fecf8 602 template <typename T, typename R, typename A0, typename A1>
valeyev 0:e056ac8fecf8 603 int call_in(int ms, const volatile T *obj, R (T::*method)(A0, A1) const volatile, A0 a0, A1 a1) {
valeyev 0:e056ac8fecf8 604 return call_in(ms, mbed::callback(obj, method), a0, a1);
valeyev 0:e056ac8fecf8 605 }
valeyev 0:e056ac8fecf8 606
valeyev 0:e056ac8fecf8 607 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 608 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 609 */
valeyev 0:e056ac8fecf8 610 template <typename T, typename R, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 611 int call_in(int ms, T *obj, R (T::*method)(A0, A1, A2), A0 a0, A1 a1, A2 a2) {
valeyev 0:e056ac8fecf8 612 return call_in(ms, mbed::callback(obj, method), a0, a1, a2);
valeyev 0:e056ac8fecf8 613 }
valeyev 0:e056ac8fecf8 614
valeyev 0:e056ac8fecf8 615 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 616 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 617 */
valeyev 0:e056ac8fecf8 618 template <typename T, typename R, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 619 int call_in(int ms, const T *obj, R (T::*method)(A0, A1, A2) const, A0 a0, A1 a1, A2 a2) {
valeyev 0:e056ac8fecf8 620 return call_in(ms, mbed::callback(obj, method), a0, a1, a2);
valeyev 0:e056ac8fecf8 621 }
valeyev 0:e056ac8fecf8 622
valeyev 0:e056ac8fecf8 623 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 624 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 625 */
valeyev 0:e056ac8fecf8 626 template <typename T, typename R, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 627 int call_in(int ms, volatile T *obj, R (T::*method)(A0, A1, A2) volatile, A0 a0, A1 a1, A2 a2) {
valeyev 0:e056ac8fecf8 628 return call_in(ms, mbed::callback(obj, method), a0, a1, a2);
valeyev 0:e056ac8fecf8 629 }
valeyev 0:e056ac8fecf8 630
valeyev 0:e056ac8fecf8 631 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 632 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 633 */
valeyev 0:e056ac8fecf8 634 template <typename T, typename R, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 635 int call_in(int ms, const volatile T *obj, R (T::*method)(A0, A1, A2) const volatile, A0 a0, A1 a1, A2 a2) {
valeyev 0:e056ac8fecf8 636 return call_in(ms, mbed::callback(obj, method), a0, a1, a2);
valeyev 0:e056ac8fecf8 637 }
valeyev 0:e056ac8fecf8 638
valeyev 0:e056ac8fecf8 639 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 640 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 641 */
valeyev 0:e056ac8fecf8 642 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 643 int call_in(int ms, T *obj, R (T::*method)(A0, A1, A2, A3), A0 a0, A1 a1, A2 a2, A3 a3) {
valeyev 0:e056ac8fecf8 644 return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3);
valeyev 0:e056ac8fecf8 645 }
valeyev 0:e056ac8fecf8 646
valeyev 0:e056ac8fecf8 647 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 648 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 649 */
valeyev 0:e056ac8fecf8 650 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 651 int call_in(int ms, const T *obj, R (T::*method)(A0, A1, A2, A3) const, A0 a0, A1 a1, A2 a2, A3 a3) {
valeyev 0:e056ac8fecf8 652 return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3);
valeyev 0:e056ac8fecf8 653 }
valeyev 0:e056ac8fecf8 654
valeyev 0:e056ac8fecf8 655 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 656 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 657 */
valeyev 0:e056ac8fecf8 658 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 659 int call_in(int ms, volatile T *obj, R (T::*method)(A0, A1, A2, A3) volatile, A0 a0, A1 a1, A2 a2, A3 a3) {
valeyev 0:e056ac8fecf8 660 return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3);
valeyev 0:e056ac8fecf8 661 }
valeyev 0:e056ac8fecf8 662
valeyev 0:e056ac8fecf8 663 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 664 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 665 */
valeyev 0:e056ac8fecf8 666 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 667 int call_in(int ms, const volatile T *obj, R (T::*method)(A0, A1, A2, A3) const volatile, A0 a0, A1 a1, A2 a2, A3 a3) {
valeyev 0:e056ac8fecf8 668 return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3);
valeyev 0:e056ac8fecf8 669 }
valeyev 0:e056ac8fecf8 670
valeyev 0:e056ac8fecf8 671 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 672 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 673 */
valeyev 0:e056ac8fecf8 674 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 675 int call_in(int ms, T *obj, R (T::*method)(A0, A1, A2, A3, A4), A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
valeyev 0:e056ac8fecf8 676 return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4);
valeyev 0:e056ac8fecf8 677 }
valeyev 0:e056ac8fecf8 678
valeyev 0:e056ac8fecf8 679 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 680 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 681 */
valeyev 0:e056ac8fecf8 682 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 683 int call_in(int ms, const T *obj, R (T::*method)(A0, A1, A2, A3, A4) const, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
valeyev 0:e056ac8fecf8 684 return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4);
valeyev 0:e056ac8fecf8 685 }
valeyev 0:e056ac8fecf8 686
valeyev 0:e056ac8fecf8 687 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 688 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 689 */
valeyev 0:e056ac8fecf8 690 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 691 int call_in(int ms, volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) volatile, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
valeyev 0:e056ac8fecf8 692 return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4);
valeyev 0:e056ac8fecf8 693 }
valeyev 0:e056ac8fecf8 694
valeyev 0:e056ac8fecf8 695 /** Calls an event on the queue after a specified delay
valeyev 0:e056ac8fecf8 696 * @see EventQueue::call_in
valeyev 0:e056ac8fecf8 697 */
valeyev 0:e056ac8fecf8 698 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 699 int call_in(int ms, const volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) const volatile, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
valeyev 0:e056ac8fecf8 700 return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4);
valeyev 0:e056ac8fecf8 701 }
valeyev 0:e056ac8fecf8 702
valeyev 0:e056ac8fecf8 703 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 704 *
valeyev 0:e056ac8fecf8 705 * The specified callback will be executed in the context of the event
valeyev 0:e056ac8fecf8 706 * queue's dispatch loop.
valeyev 0:e056ac8fecf8 707 *
valeyev 0:e056ac8fecf8 708 * The call_every function is irq safe and can act as a mechanism for
valeyev 0:e056ac8fecf8 709 * moving events out of irq contexts.
valeyev 0:e056ac8fecf8 710 *
valeyev 0:e056ac8fecf8 711 * @param f Function to execute in the context of the dispatch loop
valeyev 0:e056ac8fecf8 712 * @param ms Period of the event in milliseconds
valeyev 0:e056ac8fecf8 713 * @return A unique id that represents the posted event and can
valeyev 0:e056ac8fecf8 714 * be passed to cancel, or an id of 0 if there is not
valeyev 0:e056ac8fecf8 715 * enough memory to allocate the event.
valeyev 0:e056ac8fecf8 716 */
valeyev 0:e056ac8fecf8 717 template <typename F>
valeyev 0:e056ac8fecf8 718 int call_every(int ms, F f) {
valeyev 0:e056ac8fecf8 719 void *p = equeue_alloc(&_equeue, sizeof(F));
valeyev 0:e056ac8fecf8 720 if (!p) {
valeyev 0:e056ac8fecf8 721 return 0;
valeyev 0:e056ac8fecf8 722 }
valeyev 0:e056ac8fecf8 723
valeyev 0:e056ac8fecf8 724 F *e = new (p) F(f);
valeyev 0:e056ac8fecf8 725 equeue_event_delay(e, ms);
valeyev 0:e056ac8fecf8 726 equeue_event_period(e, ms);
valeyev 0:e056ac8fecf8 727 equeue_event_dtor(e, &EventQueue::function_dtor<F>);
valeyev 0:e056ac8fecf8 728 return equeue_post(&_equeue, &EventQueue::function_call<F>, e);
valeyev 0:e056ac8fecf8 729 }
valeyev 0:e056ac8fecf8 730
valeyev 0:e056ac8fecf8 731 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 732 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 733 * @param f Function to execute in the context of the dispatch loop
valeyev 0:e056ac8fecf8 734 * @param a0 Argument to pass to the callback
valeyev 0:e056ac8fecf8 735 * @param ms Period of the event in milliseconds
valeyev 0:e056ac8fecf8 736 */
valeyev 0:e056ac8fecf8 737 template <typename F, typename A0>
valeyev 0:e056ac8fecf8 738 int call_every(int ms, F f, A0 a0) {
valeyev 0:e056ac8fecf8 739 return call_every(ms, context10<F, A0>(f, a0));
valeyev 0:e056ac8fecf8 740 }
valeyev 0:e056ac8fecf8 741
valeyev 0:e056ac8fecf8 742 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 743 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 744 * @param f Function to execute in the context of the dispatch loop
valeyev 0:e056ac8fecf8 745 * @param a0,a1 Arguments to pass to the callback
valeyev 0:e056ac8fecf8 746 * @param ms Period of the event in milliseconds
valeyev 0:e056ac8fecf8 747 */
valeyev 0:e056ac8fecf8 748 template <typename F, typename A0, typename A1>
valeyev 0:e056ac8fecf8 749 int call_every(int ms, F f, A0 a0, A1 a1) {
valeyev 0:e056ac8fecf8 750 return call_every(ms, context20<F, A0, A1>(f, a0, a1));
valeyev 0:e056ac8fecf8 751 }
valeyev 0:e056ac8fecf8 752
valeyev 0:e056ac8fecf8 753 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 754 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 755 * @param f Function to execute in the context of the dispatch loop
valeyev 0:e056ac8fecf8 756 * @param a0,a1,a2 Arguments to pass to the callback
valeyev 0:e056ac8fecf8 757 * @param ms Period of the event in milliseconds
valeyev 0:e056ac8fecf8 758 */
valeyev 0:e056ac8fecf8 759 template <typename F, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 760 int call_every(int ms, F f, A0 a0, A1 a1, A2 a2) {
valeyev 0:e056ac8fecf8 761 return call_every(ms, context30<F, A0, A1, A2>(f, a0, a1, a2));
valeyev 0:e056ac8fecf8 762 }
valeyev 0:e056ac8fecf8 763
valeyev 0:e056ac8fecf8 764 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 765 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 766 * @param f Function to execute in the context of the dispatch loop
valeyev 0:e056ac8fecf8 767 * @param a0,a1,a2,a3 Arguments to pass to the callback
valeyev 0:e056ac8fecf8 768 * @param ms Period of the event in milliseconds
valeyev 0:e056ac8fecf8 769 */
valeyev 0:e056ac8fecf8 770 template <typename F, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 771 int call_every(int ms, F f, A0 a0, A1 a1, A2 a2, A3 a3) {
valeyev 0:e056ac8fecf8 772 return call_every(ms, context40<F, A0, A1, A2, A3>(f, a0, a1, a2, a3));
valeyev 0:e056ac8fecf8 773 }
valeyev 0:e056ac8fecf8 774
valeyev 0:e056ac8fecf8 775 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 776 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 777 * @param f Function to execute in the context of the dispatch loop
valeyev 0:e056ac8fecf8 778 * @param a0,a1,a2,a3,a4 Arguments to pass to the callback
valeyev 0:e056ac8fecf8 779 * @param ms Period of the event in milliseconds
valeyev 0:e056ac8fecf8 780 */
valeyev 0:e056ac8fecf8 781 template <typename F, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 782 int call_every(int ms, F f, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
valeyev 0:e056ac8fecf8 783 return call_every(ms, context50<F, A0, A1, A2, A3, A4>(f, a0, a1, a2, a3, a4));
valeyev 0:e056ac8fecf8 784 }
valeyev 0:e056ac8fecf8 785
valeyev 0:e056ac8fecf8 786 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 787 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 788 */
valeyev 0:e056ac8fecf8 789 template <typename T, typename R>
valeyev 0:e056ac8fecf8 790 int call_every(int ms, T *obj, R (T::*method)()) {
valeyev 0:e056ac8fecf8 791 return call_every(ms, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 792 }
valeyev 0:e056ac8fecf8 793
valeyev 0:e056ac8fecf8 794 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 795 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 796 */
valeyev 0:e056ac8fecf8 797 template <typename T, typename R>
valeyev 0:e056ac8fecf8 798 int call_every(int ms, const T *obj, R (T::*method)() const) {
valeyev 0:e056ac8fecf8 799 return call_every(ms, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 800 }
valeyev 0:e056ac8fecf8 801
valeyev 0:e056ac8fecf8 802 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 803 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 804 */
valeyev 0:e056ac8fecf8 805 template <typename T, typename R>
valeyev 0:e056ac8fecf8 806 int call_every(int ms, volatile T *obj, R (T::*method)() volatile) {
valeyev 0:e056ac8fecf8 807 return call_every(ms, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 808 }
valeyev 0:e056ac8fecf8 809
valeyev 0:e056ac8fecf8 810 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 811 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 812 */
valeyev 0:e056ac8fecf8 813 template <typename T, typename R>
valeyev 0:e056ac8fecf8 814 int call_every(int ms, const volatile T *obj, R (T::*method)() const volatile) {
valeyev 0:e056ac8fecf8 815 return call_every(ms, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 816 }
valeyev 0:e056ac8fecf8 817
valeyev 0:e056ac8fecf8 818 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 819 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 820 */
valeyev 0:e056ac8fecf8 821 template <typename T, typename R, typename A0>
valeyev 0:e056ac8fecf8 822 int call_every(int ms, T *obj, R (T::*method)(A0), A0 a0) {
valeyev 0:e056ac8fecf8 823 return call_every(ms, mbed::callback(obj, method), a0);
valeyev 0:e056ac8fecf8 824 }
valeyev 0:e056ac8fecf8 825
valeyev 0:e056ac8fecf8 826 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 827 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 828 */
valeyev 0:e056ac8fecf8 829 template <typename T, typename R, typename A0>
valeyev 0:e056ac8fecf8 830 int call_every(int ms, const T *obj, R (T::*method)(A0) const, A0 a0) {
valeyev 0:e056ac8fecf8 831 return call_every(ms, mbed::callback(obj, method), a0);
valeyev 0:e056ac8fecf8 832 }
valeyev 0:e056ac8fecf8 833
valeyev 0:e056ac8fecf8 834 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 835 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 836 */
valeyev 0:e056ac8fecf8 837 template <typename T, typename R, typename A0>
valeyev 0:e056ac8fecf8 838 int call_every(int ms, volatile T *obj, R (T::*method)(A0) volatile, A0 a0) {
valeyev 0:e056ac8fecf8 839 return call_every(ms, mbed::callback(obj, method), a0);
valeyev 0:e056ac8fecf8 840 }
valeyev 0:e056ac8fecf8 841
valeyev 0:e056ac8fecf8 842 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 843 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 844 */
valeyev 0:e056ac8fecf8 845 template <typename T, typename R, typename A0>
valeyev 0:e056ac8fecf8 846 int call_every(int ms, const volatile T *obj, R (T::*method)(A0) const volatile, A0 a0) {
valeyev 0:e056ac8fecf8 847 return call_every(ms, mbed::callback(obj, method), a0);
valeyev 0:e056ac8fecf8 848 }
valeyev 0:e056ac8fecf8 849
valeyev 0:e056ac8fecf8 850 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 851 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 852 */
valeyev 0:e056ac8fecf8 853 template <typename T, typename R, typename A0, typename A1>
valeyev 0:e056ac8fecf8 854 int call_every(int ms, T *obj, R (T::*method)(A0, A1), A0 a0, A1 a1) {
valeyev 0:e056ac8fecf8 855 return call_every(ms, mbed::callback(obj, method), a0, a1);
valeyev 0:e056ac8fecf8 856 }
valeyev 0:e056ac8fecf8 857
valeyev 0:e056ac8fecf8 858 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 859 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 860 */
valeyev 0:e056ac8fecf8 861 template <typename T, typename R, typename A0, typename A1>
valeyev 0:e056ac8fecf8 862 int call_every(int ms, const T *obj, R (T::*method)(A0, A1) const, A0 a0, A1 a1) {
valeyev 0:e056ac8fecf8 863 return call_every(ms, mbed::callback(obj, method), a0, a1);
valeyev 0:e056ac8fecf8 864 }
valeyev 0:e056ac8fecf8 865
valeyev 0:e056ac8fecf8 866 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 867 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 868 */
valeyev 0:e056ac8fecf8 869 template <typename T, typename R, typename A0, typename A1>
valeyev 0:e056ac8fecf8 870 int call_every(int ms, volatile T *obj, R (T::*method)(A0, A1) volatile, A0 a0, A1 a1) {
valeyev 0:e056ac8fecf8 871 return call_every(ms, mbed::callback(obj, method), a0, a1);
valeyev 0:e056ac8fecf8 872 }
valeyev 0:e056ac8fecf8 873
valeyev 0:e056ac8fecf8 874 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 875 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 876 */
valeyev 0:e056ac8fecf8 877 template <typename T, typename R, typename A0, typename A1>
valeyev 0:e056ac8fecf8 878 int call_every(int ms, const volatile T *obj, R (T::*method)(A0, A1) const volatile, A0 a0, A1 a1) {
valeyev 0:e056ac8fecf8 879 return call_every(ms, mbed::callback(obj, method), a0, a1);
valeyev 0:e056ac8fecf8 880 }
valeyev 0:e056ac8fecf8 881
valeyev 0:e056ac8fecf8 882 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 883 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 884 */
valeyev 0:e056ac8fecf8 885 template <typename T, typename R, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 886 int call_every(int ms, T *obj, R (T::*method)(A0, A1, A2), A0 a0, A1 a1, A2 a2) {
valeyev 0:e056ac8fecf8 887 return call_every(ms, mbed::callback(obj, method), a0, a1, a2);
valeyev 0:e056ac8fecf8 888 }
valeyev 0:e056ac8fecf8 889
valeyev 0:e056ac8fecf8 890 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 891 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 892 */
valeyev 0:e056ac8fecf8 893 template <typename T, typename R, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 894 int call_every(int ms, const T *obj, R (T::*method)(A0, A1, A2) const, A0 a0, A1 a1, A2 a2) {
valeyev 0:e056ac8fecf8 895 return call_every(ms, mbed::callback(obj, method), a0, a1, a2);
valeyev 0:e056ac8fecf8 896 }
valeyev 0:e056ac8fecf8 897
valeyev 0:e056ac8fecf8 898 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 899 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 900 */
valeyev 0:e056ac8fecf8 901 template <typename T, typename R, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 902 int call_every(int ms, volatile T *obj, R (T::*method)(A0, A1, A2) volatile, A0 a0, A1 a1, A2 a2) {
valeyev 0:e056ac8fecf8 903 return call_every(ms, mbed::callback(obj, method), a0, a1, a2);
valeyev 0:e056ac8fecf8 904 }
valeyev 0:e056ac8fecf8 905
valeyev 0:e056ac8fecf8 906 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 907 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 908 */
valeyev 0:e056ac8fecf8 909 template <typename T, typename R, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 910 int call_every(int ms, const volatile T *obj, R (T::*method)(A0, A1, A2) const volatile, A0 a0, A1 a1, A2 a2) {
valeyev 0:e056ac8fecf8 911 return call_every(ms, mbed::callback(obj, method), a0, a1, a2);
valeyev 0:e056ac8fecf8 912 }
valeyev 0:e056ac8fecf8 913
valeyev 0:e056ac8fecf8 914 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 915 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 916 */
valeyev 0:e056ac8fecf8 917 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 918 int call_every(int ms, T *obj, R (T::*method)(A0, A1, A2, A3), A0 a0, A1 a1, A2 a2, A3 a3) {
valeyev 0:e056ac8fecf8 919 return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3);
valeyev 0:e056ac8fecf8 920 }
valeyev 0:e056ac8fecf8 921
valeyev 0:e056ac8fecf8 922 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 923 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 924 */
valeyev 0:e056ac8fecf8 925 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 926 int call_every(int ms, const T *obj, R (T::*method)(A0, A1, A2, A3) const, A0 a0, A1 a1, A2 a2, A3 a3) {
valeyev 0:e056ac8fecf8 927 return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3);
valeyev 0:e056ac8fecf8 928 }
valeyev 0:e056ac8fecf8 929
valeyev 0:e056ac8fecf8 930 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 931 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 932 */
valeyev 0:e056ac8fecf8 933 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 934 int call_every(int ms, volatile T *obj, R (T::*method)(A0, A1, A2, A3) volatile, A0 a0, A1 a1, A2 a2, A3 a3) {
valeyev 0:e056ac8fecf8 935 return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3);
valeyev 0:e056ac8fecf8 936 }
valeyev 0:e056ac8fecf8 937
valeyev 0:e056ac8fecf8 938 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 939 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 940 */
valeyev 0:e056ac8fecf8 941 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 942 int call_every(int ms, const volatile T *obj, R (T::*method)(A0, A1, A2, A3) const volatile, A0 a0, A1 a1, A2 a2, A3 a3) {
valeyev 0:e056ac8fecf8 943 return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3);
valeyev 0:e056ac8fecf8 944 }
valeyev 0:e056ac8fecf8 945
valeyev 0:e056ac8fecf8 946 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 947 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 948 */
valeyev 0:e056ac8fecf8 949 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 950 int call_every(int ms, T *obj, R (T::*method)(A0, A1, A2, A3, A4), A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
valeyev 0:e056ac8fecf8 951 return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4);
valeyev 0:e056ac8fecf8 952 }
valeyev 0:e056ac8fecf8 953
valeyev 0:e056ac8fecf8 954 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 955 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 956 */
valeyev 0:e056ac8fecf8 957 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 958 int call_every(int ms, const T *obj, R (T::*method)(A0, A1, A2, A3, A4) const, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
valeyev 0:e056ac8fecf8 959 return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4);
valeyev 0:e056ac8fecf8 960 }
valeyev 0:e056ac8fecf8 961
valeyev 0:e056ac8fecf8 962 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 963 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 964 */
valeyev 0:e056ac8fecf8 965 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 966 int call_every(int ms, volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) volatile, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
valeyev 0:e056ac8fecf8 967 return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4);
valeyev 0:e056ac8fecf8 968 }
valeyev 0:e056ac8fecf8 969
valeyev 0:e056ac8fecf8 970 /** Calls an event on the queue periodically
valeyev 0:e056ac8fecf8 971 * @see EventQueue::call_every
valeyev 0:e056ac8fecf8 972 */
valeyev 0:e056ac8fecf8 973 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 974 int call_every(int ms, const volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) const volatile, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
valeyev 0:e056ac8fecf8 975 return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4);
valeyev 0:e056ac8fecf8 976 }
valeyev 0:e056ac8fecf8 977
valeyev 0:e056ac8fecf8 978 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 979 *
valeyev 0:e056ac8fecf8 980 * Constructs an event bound to the specified event queue. The specified
valeyev 0:e056ac8fecf8 981 * callback acts as the target for the event and is executed in the
valeyev 0:e056ac8fecf8 982 * context of the event queue's dispatch loop once posted.
valeyev 0:e056ac8fecf8 983 *
valeyev 0:e056ac8fecf8 984 * @param func Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 985 * @return Event that will dispatch on the specific queue
valeyev 0:e056ac8fecf8 986 */
valeyev 0:e056ac8fecf8 987 template <typename R>
valeyev 0:e056ac8fecf8 988 Event<void()> event(R (*func)());
valeyev 0:e056ac8fecf8 989
valeyev 0:e056ac8fecf8 990 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 991 * @see EventQueue::event
valeyev 0:e056ac8fecf8 992 */
valeyev 0:e056ac8fecf8 993 template <typename T, typename R>
valeyev 0:e056ac8fecf8 994 Event<void()> event(T *obj, R (T::*method)());
valeyev 0:e056ac8fecf8 995
valeyev 0:e056ac8fecf8 996 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 997 * @see EventQueue::event
valeyev 0:e056ac8fecf8 998 */
valeyev 0:e056ac8fecf8 999 template <typename T, typename R>
valeyev 0:e056ac8fecf8 1000 Event<void()> event(const T *obj, R (T::*method)() const);
valeyev 0:e056ac8fecf8 1001
valeyev 0:e056ac8fecf8 1002 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1003 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1004 */
valeyev 0:e056ac8fecf8 1005 template <typename T, typename R>
valeyev 0:e056ac8fecf8 1006 Event<void()> event(volatile T *obj, R (T::*method)() volatile);
valeyev 0:e056ac8fecf8 1007
valeyev 0:e056ac8fecf8 1008 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1009 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1010 */
valeyev 0:e056ac8fecf8 1011 template <typename T, typename R>
valeyev 0:e056ac8fecf8 1012 Event<void()> event(const volatile T *obj, R (T::*method)() const volatile);
valeyev 0:e056ac8fecf8 1013
valeyev 0:e056ac8fecf8 1014 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1015 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1016 */
valeyev 0:e056ac8fecf8 1017 template <typename R>
valeyev 0:e056ac8fecf8 1018 Event<void()> event(mbed::Callback<R()> cb);
valeyev 0:e056ac8fecf8 1019
valeyev 0:e056ac8fecf8 1020 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1021 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1022 */
valeyev 0:e056ac8fecf8 1023 template <typename R, typename B0, typename C0>
valeyev 0:e056ac8fecf8 1024 Event<void()> event(R (*func)(B0), C0 c0);
valeyev 0:e056ac8fecf8 1025
valeyev 0:e056ac8fecf8 1026 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1027 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1028 */
valeyev 0:e056ac8fecf8 1029 template <typename T, typename R, typename B0, typename C0>
valeyev 0:e056ac8fecf8 1030 Event<void()> event(T *obj, R (T::*method)(B0), C0 c0);
valeyev 0:e056ac8fecf8 1031
valeyev 0:e056ac8fecf8 1032 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1033 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1034 */
valeyev 0:e056ac8fecf8 1035 template <typename T, typename R, typename B0, typename C0>
valeyev 0:e056ac8fecf8 1036 Event<void()> event(const T *obj, R (T::*method)(B0) const, C0 c0);
valeyev 0:e056ac8fecf8 1037
valeyev 0:e056ac8fecf8 1038 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1039 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1040 */
valeyev 0:e056ac8fecf8 1041 template <typename T, typename R, typename B0, typename C0>
valeyev 0:e056ac8fecf8 1042 Event<void()> event(volatile T *obj, R (T::*method)(B0) volatile, C0 c0);
valeyev 0:e056ac8fecf8 1043
valeyev 0:e056ac8fecf8 1044 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1045 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1046 */
valeyev 0:e056ac8fecf8 1047 template <typename T, typename R, typename B0, typename C0>
valeyev 0:e056ac8fecf8 1048 Event<void()> event(const volatile T *obj, R (T::*method)(B0) const volatile, C0 c0);
valeyev 0:e056ac8fecf8 1049
valeyev 0:e056ac8fecf8 1050 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1051 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1052 */
valeyev 0:e056ac8fecf8 1053 template <typename R, typename B0, typename C0>
valeyev 0:e056ac8fecf8 1054 Event<void()> event(mbed::Callback<R(B0)> cb, C0 c0);
valeyev 0:e056ac8fecf8 1055
valeyev 0:e056ac8fecf8 1056 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1057 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1058 */
valeyev 0:e056ac8fecf8 1059 template <typename R, typename B0, typename B1, typename C0, typename C1>
valeyev 0:e056ac8fecf8 1060 Event<void()> event(R (*func)(B0, B1), C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1061
valeyev 0:e056ac8fecf8 1062 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1063 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1064 */
valeyev 0:e056ac8fecf8 1065 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1>
valeyev 0:e056ac8fecf8 1066 Event<void()> event(T *obj, R (T::*method)(B0, B1), C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1067
valeyev 0:e056ac8fecf8 1068 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1069 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1070 */
valeyev 0:e056ac8fecf8 1071 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1>
valeyev 0:e056ac8fecf8 1072 Event<void()> event(const T *obj, R (T::*method)(B0, B1) const, C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1073
valeyev 0:e056ac8fecf8 1074 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1075 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1076 */
valeyev 0:e056ac8fecf8 1077 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1>
valeyev 0:e056ac8fecf8 1078 Event<void()> event(volatile T *obj, R (T::*method)(B0, B1) volatile, C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1079
valeyev 0:e056ac8fecf8 1080 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1081 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1082 */
valeyev 0:e056ac8fecf8 1083 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1>
valeyev 0:e056ac8fecf8 1084 Event<void()> event(const volatile T *obj, R (T::*method)(B0, B1) const volatile, C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1085
valeyev 0:e056ac8fecf8 1086 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1087 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1088 */
valeyev 0:e056ac8fecf8 1089 template <typename R, typename B0, typename B1, typename C0, typename C1>
valeyev 0:e056ac8fecf8 1090 Event<void()> event(mbed::Callback<R(B0, B1)> cb, C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1091
valeyev 0:e056ac8fecf8 1092 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1093 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1094 */
valeyev 0:e056ac8fecf8 1095 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
valeyev 0:e056ac8fecf8 1096 Event<void()> event(R (*func)(B0, B1, B2), C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1097
valeyev 0:e056ac8fecf8 1098 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1099 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1100 */
valeyev 0:e056ac8fecf8 1101 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
valeyev 0:e056ac8fecf8 1102 Event<void()> event(T *obj, R (T::*method)(B0, B1, B2), C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1103
valeyev 0:e056ac8fecf8 1104 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1105 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1106 */
valeyev 0:e056ac8fecf8 1107 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
valeyev 0:e056ac8fecf8 1108 Event<void()> event(const T *obj, R (T::*method)(B0, B1, B2) const, C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1109
valeyev 0:e056ac8fecf8 1110 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1111 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1112 */
valeyev 0:e056ac8fecf8 1113 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
valeyev 0:e056ac8fecf8 1114 Event<void()> event(volatile T *obj, R (T::*method)(B0, B1, B2) volatile, C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1115
valeyev 0:e056ac8fecf8 1116 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1117 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1118 */
valeyev 0:e056ac8fecf8 1119 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
valeyev 0:e056ac8fecf8 1120 Event<void()> event(const volatile T *obj, R (T::*method)(B0, B1, B2) const volatile, C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1121
valeyev 0:e056ac8fecf8 1122 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1123 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1124 */
valeyev 0:e056ac8fecf8 1125 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
valeyev 0:e056ac8fecf8 1126 Event<void()> event(mbed::Callback<R(B0, B1, B2)> cb, C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1127
valeyev 0:e056ac8fecf8 1128 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1129 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1130 */
valeyev 0:e056ac8fecf8 1131 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
valeyev 0:e056ac8fecf8 1132 Event<void()> event(R (*func)(B0, B1, B2, B3), C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 1133
valeyev 0:e056ac8fecf8 1134 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1135 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1136 */
valeyev 0:e056ac8fecf8 1137 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
valeyev 0:e056ac8fecf8 1138 Event<void()> event(T *obj, R (T::*method)(B0, B1, B2, B3), C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 1139
valeyev 0:e056ac8fecf8 1140 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1141 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1142 */
valeyev 0:e056ac8fecf8 1143 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
valeyev 0:e056ac8fecf8 1144 Event<void()> event(const T *obj, R (T::*method)(B0, B1, B2, B3) const, C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 1145
valeyev 0:e056ac8fecf8 1146 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1147 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1148 */
valeyev 0:e056ac8fecf8 1149 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
valeyev 0:e056ac8fecf8 1150 Event<void()> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3) volatile, C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 1151
valeyev 0:e056ac8fecf8 1152 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1153 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1154 */
valeyev 0:e056ac8fecf8 1155 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
valeyev 0:e056ac8fecf8 1156 Event<void()> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3) const volatile, C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 1157
valeyev 0:e056ac8fecf8 1158 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1159 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1160 */
valeyev 0:e056ac8fecf8 1161 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
valeyev 0:e056ac8fecf8 1162 Event<void()> event(mbed::Callback<R(B0, B1, B2, B3)> cb, C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 1163
valeyev 0:e056ac8fecf8 1164 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1165 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1166 */
valeyev 0:e056ac8fecf8 1167 template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4>
valeyev 0:e056ac8fecf8 1168 Event<void()> event(R (*func)(B0, B1, B2, B3, B4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 1169
valeyev 0:e056ac8fecf8 1170 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1171 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1172 */
valeyev 0:e056ac8fecf8 1173 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4>
valeyev 0:e056ac8fecf8 1174 Event<void()> event(T *obj, R (T::*method)(B0, B1, B2, B3, B4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 1175
valeyev 0:e056ac8fecf8 1176 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1177 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1178 */
valeyev 0:e056ac8fecf8 1179 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4>
valeyev 0:e056ac8fecf8 1180 Event<void()> event(const T *obj, R (T::*method)(B0, B1, B2, B3, B4) const, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 1181
valeyev 0:e056ac8fecf8 1182 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1183 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1184 */
valeyev 0:e056ac8fecf8 1185 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4>
valeyev 0:e056ac8fecf8 1186 Event<void()> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4) volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 1187
valeyev 0:e056ac8fecf8 1188 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1189 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1190 */
valeyev 0:e056ac8fecf8 1191 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4>
valeyev 0:e056ac8fecf8 1192 Event<void()> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4) const volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 1193
valeyev 0:e056ac8fecf8 1194 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1195 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1196 */
valeyev 0:e056ac8fecf8 1197 template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4>
valeyev 0:e056ac8fecf8 1198 Event<void()> event(mbed::Callback<R(B0, B1, B2, B3, B4)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 1199
valeyev 0:e056ac8fecf8 1200 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1201 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1202 */
valeyev 0:e056ac8fecf8 1203 template <typename R, typename A0>
valeyev 0:e056ac8fecf8 1204 Event<void(A0)> event(R (*func)(A0));
valeyev 0:e056ac8fecf8 1205
valeyev 0:e056ac8fecf8 1206 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1207 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1208 */
valeyev 0:e056ac8fecf8 1209 template <typename T, typename R, typename A0>
valeyev 0:e056ac8fecf8 1210 Event<void(A0)> event(T *obj, R (T::*method)(A0));
valeyev 0:e056ac8fecf8 1211
valeyev 0:e056ac8fecf8 1212 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1213 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1214 */
valeyev 0:e056ac8fecf8 1215 template <typename T, typename R, typename A0>
valeyev 0:e056ac8fecf8 1216 Event<void(A0)> event(const T *obj, R (T::*method)(A0) const);
valeyev 0:e056ac8fecf8 1217
valeyev 0:e056ac8fecf8 1218 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1219 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1220 */
valeyev 0:e056ac8fecf8 1221 template <typename T, typename R, typename A0>
valeyev 0:e056ac8fecf8 1222 Event<void(A0)> event(volatile T *obj, R (T::*method)(A0) volatile);
valeyev 0:e056ac8fecf8 1223
valeyev 0:e056ac8fecf8 1224 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1225 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1226 */
valeyev 0:e056ac8fecf8 1227 template <typename T, typename R, typename A0>
valeyev 0:e056ac8fecf8 1228 Event<void(A0)> event(const volatile T *obj, R (T::*method)(A0) const volatile);
valeyev 0:e056ac8fecf8 1229
valeyev 0:e056ac8fecf8 1230 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1231 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1232 */
valeyev 0:e056ac8fecf8 1233 template <typename R, typename A0>
valeyev 0:e056ac8fecf8 1234 Event<void(A0)> event(mbed::Callback<R(A0)> cb);
valeyev 0:e056ac8fecf8 1235
valeyev 0:e056ac8fecf8 1236 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1237 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1238 */
valeyev 0:e056ac8fecf8 1239 template <typename R, typename B0, typename C0, typename A0>
valeyev 0:e056ac8fecf8 1240 Event<void(A0)> event(R (*func)(B0, A0), C0 c0);
valeyev 0:e056ac8fecf8 1241
valeyev 0:e056ac8fecf8 1242 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1243 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1244 */
valeyev 0:e056ac8fecf8 1245 template <typename T, typename R, typename B0, typename C0, typename A0>
valeyev 0:e056ac8fecf8 1246 Event<void(A0)> event(T *obj, R (T::*method)(B0, A0), C0 c0);
valeyev 0:e056ac8fecf8 1247
valeyev 0:e056ac8fecf8 1248 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1249 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1250 */
valeyev 0:e056ac8fecf8 1251 template <typename T, typename R, typename B0, typename C0, typename A0>
valeyev 0:e056ac8fecf8 1252 Event<void(A0)> event(const T *obj, R (T::*method)(B0, A0) const, C0 c0);
valeyev 0:e056ac8fecf8 1253
valeyev 0:e056ac8fecf8 1254 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1255 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1256 */
valeyev 0:e056ac8fecf8 1257 template <typename T, typename R, typename B0, typename C0, typename A0>
valeyev 0:e056ac8fecf8 1258 Event<void(A0)> event(volatile T *obj, R (T::*method)(B0, A0) volatile, C0 c0);
valeyev 0:e056ac8fecf8 1259
valeyev 0:e056ac8fecf8 1260 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1261 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1262 */
valeyev 0:e056ac8fecf8 1263 template <typename T, typename R, typename B0, typename C0, typename A0>
valeyev 0:e056ac8fecf8 1264 Event<void(A0)> event(const volatile T *obj, R (T::*method)(B0, A0) const volatile, C0 c0);
valeyev 0:e056ac8fecf8 1265
valeyev 0:e056ac8fecf8 1266 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1267 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1268 */
valeyev 0:e056ac8fecf8 1269 template <typename R, typename B0, typename C0, typename A0>
valeyev 0:e056ac8fecf8 1270 Event<void(A0)> event(mbed::Callback<R(B0, A0)> cb, C0 c0);
valeyev 0:e056ac8fecf8 1271
valeyev 0:e056ac8fecf8 1272 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1273 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1274 */
valeyev 0:e056ac8fecf8 1275 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
valeyev 0:e056ac8fecf8 1276 Event<void(A0)> event(R (*func)(B0, B1, A0), C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1277
valeyev 0:e056ac8fecf8 1278 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1279 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1280 */
valeyev 0:e056ac8fecf8 1281 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
valeyev 0:e056ac8fecf8 1282 Event<void(A0)> event(T *obj, R (T::*method)(B0, B1, A0), C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1283
valeyev 0:e056ac8fecf8 1284 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1285 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1286 */
valeyev 0:e056ac8fecf8 1287 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
valeyev 0:e056ac8fecf8 1288 Event<void(A0)> event(const T *obj, R (T::*method)(B0, B1, A0) const, C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1289
valeyev 0:e056ac8fecf8 1290 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1291 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1292 */
valeyev 0:e056ac8fecf8 1293 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
valeyev 0:e056ac8fecf8 1294 Event<void(A0)> event(volatile T *obj, R (T::*method)(B0, B1, A0) volatile, C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1295
valeyev 0:e056ac8fecf8 1296 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1297 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1298 */
valeyev 0:e056ac8fecf8 1299 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
valeyev 0:e056ac8fecf8 1300 Event<void(A0)> event(const volatile T *obj, R (T::*method)(B0, B1, A0) const volatile, C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1301
valeyev 0:e056ac8fecf8 1302 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1303 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1304 */
valeyev 0:e056ac8fecf8 1305 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
valeyev 0:e056ac8fecf8 1306 Event<void(A0)> event(mbed::Callback<R(B0, B1, A0)> cb, C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1307
valeyev 0:e056ac8fecf8 1308 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1309 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1310 */
valeyev 0:e056ac8fecf8 1311 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
valeyev 0:e056ac8fecf8 1312 Event<void(A0)> event(R (*func)(B0, B1, B2, A0), C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1313
valeyev 0:e056ac8fecf8 1314 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1315 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1316 */
valeyev 0:e056ac8fecf8 1317 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
valeyev 0:e056ac8fecf8 1318 Event<void(A0)> event(T *obj, R (T::*method)(B0, B1, B2, A0), C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1319
valeyev 0:e056ac8fecf8 1320 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1321 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1322 */
valeyev 0:e056ac8fecf8 1323 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
valeyev 0:e056ac8fecf8 1324 Event<void(A0)> event(const T *obj, R (T::*method)(B0, B1, B2, A0) const, C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1325
valeyev 0:e056ac8fecf8 1326 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1327 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1328 */
valeyev 0:e056ac8fecf8 1329 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
valeyev 0:e056ac8fecf8 1330 Event<void(A0)> event(volatile T *obj, R (T::*method)(B0, B1, B2, A0) volatile, C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1331
valeyev 0:e056ac8fecf8 1332 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1333 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1334 */
valeyev 0:e056ac8fecf8 1335 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
valeyev 0:e056ac8fecf8 1336 Event<void(A0)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, A0) const volatile, C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1337
valeyev 0:e056ac8fecf8 1338 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1339 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1340 */
valeyev 0:e056ac8fecf8 1341 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
valeyev 0:e056ac8fecf8 1342 Event<void(A0)> event(mbed::Callback<R(B0, B1, B2, A0)> cb, C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1343
valeyev 0:e056ac8fecf8 1344 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1345 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1346 */
valeyev 0:e056ac8fecf8 1347 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
valeyev 0:e056ac8fecf8 1348 Event<void(A0)> event(R (*func)(B0, B1, B2, B3, A0), C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 1349
valeyev 0:e056ac8fecf8 1350 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1351 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1352 */
valeyev 0:e056ac8fecf8 1353 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
valeyev 0:e056ac8fecf8 1354 Event<void(A0)> event(T *obj, R (T::*method)(B0, B1, B2, B3, A0), C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 1355
valeyev 0:e056ac8fecf8 1356 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1357 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1358 */
valeyev 0:e056ac8fecf8 1359 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
valeyev 0:e056ac8fecf8 1360 Event<void(A0)> event(const T *obj, R (T::*method)(B0, B1, B2, B3, A0) const, C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 1361
valeyev 0:e056ac8fecf8 1362 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1363 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1364 */
valeyev 0:e056ac8fecf8 1365 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
valeyev 0:e056ac8fecf8 1366 Event<void(A0)> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0) volatile, C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 1367
valeyev 0:e056ac8fecf8 1368 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1369 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1370 */
valeyev 0:e056ac8fecf8 1371 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
valeyev 0:e056ac8fecf8 1372 Event<void(A0)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0) const volatile, C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 1373
valeyev 0:e056ac8fecf8 1374 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1375 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1376 */
valeyev 0:e056ac8fecf8 1377 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
valeyev 0:e056ac8fecf8 1378 Event<void(A0)> event(mbed::Callback<R(B0, B1, B2, B3, A0)> cb, C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 1379
valeyev 0:e056ac8fecf8 1380 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1381 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1382 */
valeyev 0:e056ac8fecf8 1383 template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0>
valeyev 0:e056ac8fecf8 1384 Event<void(A0)> event(R (*func)(B0, B1, B2, B3, B4, A0), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 1385
valeyev 0:e056ac8fecf8 1386 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1387 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1388 */
valeyev 0:e056ac8fecf8 1389 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0>
valeyev 0:e056ac8fecf8 1390 Event<void(A0)> event(T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 1391
valeyev 0:e056ac8fecf8 1392 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1393 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1394 */
valeyev 0:e056ac8fecf8 1395 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0>
valeyev 0:e056ac8fecf8 1396 Event<void(A0)> event(const T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0) const, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 1397
valeyev 0:e056ac8fecf8 1398 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1399 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1400 */
valeyev 0:e056ac8fecf8 1401 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0>
valeyev 0:e056ac8fecf8 1402 Event<void(A0)> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0) volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 1403
valeyev 0:e056ac8fecf8 1404 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1405 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1406 */
valeyev 0:e056ac8fecf8 1407 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0>
valeyev 0:e056ac8fecf8 1408 Event<void(A0)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0) const volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 1409
valeyev 0:e056ac8fecf8 1410 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1411 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1412 */
valeyev 0:e056ac8fecf8 1413 template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0>
valeyev 0:e056ac8fecf8 1414 Event<void(A0)> event(mbed::Callback<R(B0, B1, B2, B3, B4, A0)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 1415
valeyev 0:e056ac8fecf8 1416 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1417 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1418 */
valeyev 0:e056ac8fecf8 1419 template <typename R, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1420 Event<void(A0, A1)> event(R (*func)(A0, A1));
valeyev 0:e056ac8fecf8 1421
valeyev 0:e056ac8fecf8 1422 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1423 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1424 */
valeyev 0:e056ac8fecf8 1425 template <typename T, typename R, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1426 Event<void(A0, A1)> event(T *obj, R (T::*method)(A0, A1));
valeyev 0:e056ac8fecf8 1427
valeyev 0:e056ac8fecf8 1428 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1429 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1430 */
valeyev 0:e056ac8fecf8 1431 template <typename T, typename R, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1432 Event<void(A0, A1)> event(const T *obj, R (T::*method)(A0, A1) const);
valeyev 0:e056ac8fecf8 1433
valeyev 0:e056ac8fecf8 1434 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1435 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1436 */
valeyev 0:e056ac8fecf8 1437 template <typename T, typename R, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1438 Event<void(A0, A1)> event(volatile T *obj, R (T::*method)(A0, A1) volatile);
valeyev 0:e056ac8fecf8 1439
valeyev 0:e056ac8fecf8 1440 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1441 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1442 */
valeyev 0:e056ac8fecf8 1443 template <typename T, typename R, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1444 Event<void(A0, A1)> event(const volatile T *obj, R (T::*method)(A0, A1) const volatile);
valeyev 0:e056ac8fecf8 1445
valeyev 0:e056ac8fecf8 1446 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1447 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1448 */
valeyev 0:e056ac8fecf8 1449 template <typename R, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1450 Event<void(A0, A1)> event(mbed::Callback<R(A0, A1)> cb);
valeyev 0:e056ac8fecf8 1451
valeyev 0:e056ac8fecf8 1452 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1453 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1454 */
valeyev 0:e056ac8fecf8 1455 template <typename R, typename B0, typename C0, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1456 Event<void(A0, A1)> event(R (*func)(B0, A0, A1), C0 c0);
valeyev 0:e056ac8fecf8 1457
valeyev 0:e056ac8fecf8 1458 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1459 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1460 */
valeyev 0:e056ac8fecf8 1461 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1462 Event<void(A0, A1)> event(T *obj, R (T::*method)(B0, A0, A1), C0 c0);
valeyev 0:e056ac8fecf8 1463
valeyev 0:e056ac8fecf8 1464 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1465 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1466 */
valeyev 0:e056ac8fecf8 1467 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1468 Event<void(A0, A1)> event(const T *obj, R (T::*method)(B0, A0, A1) const, C0 c0);
valeyev 0:e056ac8fecf8 1469
valeyev 0:e056ac8fecf8 1470 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1471 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1472 */
valeyev 0:e056ac8fecf8 1473 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1474 Event<void(A0, A1)> event(volatile T *obj, R (T::*method)(B0, A0, A1) volatile, C0 c0);
valeyev 0:e056ac8fecf8 1475
valeyev 0:e056ac8fecf8 1476 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1477 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1478 */
valeyev 0:e056ac8fecf8 1479 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1480 Event<void(A0, A1)> event(const volatile T *obj, R (T::*method)(B0, A0, A1) const volatile, C0 c0);
valeyev 0:e056ac8fecf8 1481
valeyev 0:e056ac8fecf8 1482 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1483 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1484 */
valeyev 0:e056ac8fecf8 1485 template <typename R, typename B0, typename C0, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1486 Event<void(A0, A1)> event(mbed::Callback<R(B0, A0, A1)> cb, C0 c0);
valeyev 0:e056ac8fecf8 1487
valeyev 0:e056ac8fecf8 1488 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1489 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1490 */
valeyev 0:e056ac8fecf8 1491 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1492 Event<void(A0, A1)> event(R (*func)(B0, B1, A0, A1), C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1493
valeyev 0:e056ac8fecf8 1494 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1495 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1496 */
valeyev 0:e056ac8fecf8 1497 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1498 Event<void(A0, A1)> event(T *obj, R (T::*method)(B0, B1, A0, A1), C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1499
valeyev 0:e056ac8fecf8 1500 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1501 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1502 */
valeyev 0:e056ac8fecf8 1503 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1504 Event<void(A0, A1)> event(const T *obj, R (T::*method)(B0, B1, A0, A1) const, C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1505
valeyev 0:e056ac8fecf8 1506 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1507 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1508 */
valeyev 0:e056ac8fecf8 1509 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1510 Event<void(A0, A1)> event(volatile T *obj, R (T::*method)(B0, B1, A0, A1) volatile, C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1511
valeyev 0:e056ac8fecf8 1512 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1513 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1514 */
valeyev 0:e056ac8fecf8 1515 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1516 Event<void(A0, A1)> event(const volatile T *obj, R (T::*method)(B0, B1, A0, A1) const volatile, C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1517
valeyev 0:e056ac8fecf8 1518 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1519 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1520 */
valeyev 0:e056ac8fecf8 1521 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1522 Event<void(A0, A1)> event(mbed::Callback<R(B0, B1, A0, A1)> cb, C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1523
valeyev 0:e056ac8fecf8 1524 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1525 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1526 */
valeyev 0:e056ac8fecf8 1527 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1528 Event<void(A0, A1)> event(R (*func)(B0, B1, B2, A0, A1), C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1529
valeyev 0:e056ac8fecf8 1530 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1531 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1532 */
valeyev 0:e056ac8fecf8 1533 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1534 Event<void(A0, A1)> event(T *obj, R (T::*method)(B0, B1, B2, A0, A1), C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1535
valeyev 0:e056ac8fecf8 1536 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1537 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1538 */
valeyev 0:e056ac8fecf8 1539 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1540 Event<void(A0, A1)> event(const T *obj, R (T::*method)(B0, B1, B2, A0, A1) const, C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1541
valeyev 0:e056ac8fecf8 1542 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1543 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1544 */
valeyev 0:e056ac8fecf8 1545 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1546 Event<void(A0, A1)> event(volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1) volatile, C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1547
valeyev 0:e056ac8fecf8 1548 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1549 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1550 */
valeyev 0:e056ac8fecf8 1551 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1552 Event<void(A0, A1)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1) const volatile, C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1553
valeyev 0:e056ac8fecf8 1554 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1555 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1556 */
valeyev 0:e056ac8fecf8 1557 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1558 Event<void(A0, A1)> event(mbed::Callback<R(B0, B1, B2, A0, A1)> cb, C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1559
valeyev 0:e056ac8fecf8 1560 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1561 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1562 */
valeyev 0:e056ac8fecf8 1563 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1564 Event<void(A0, A1)> event(R (*func)(B0, B1, B2, B3, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 1565
valeyev 0:e056ac8fecf8 1566 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1567 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1568 */
valeyev 0:e056ac8fecf8 1569 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1570 Event<void(A0, A1)> event(T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 1571
valeyev 0:e056ac8fecf8 1572 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1573 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1574 */
valeyev 0:e056ac8fecf8 1575 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1576 Event<void(A0, A1)> event(const T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1) const, C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 1577
valeyev 0:e056ac8fecf8 1578 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1579 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1580 */
valeyev 0:e056ac8fecf8 1581 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1582 Event<void(A0, A1)> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1) volatile, C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 1583
valeyev 0:e056ac8fecf8 1584 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1585 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1586 */
valeyev 0:e056ac8fecf8 1587 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1588 Event<void(A0, A1)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1) const volatile, C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 1589
valeyev 0:e056ac8fecf8 1590 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1591 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1592 */
valeyev 0:e056ac8fecf8 1593 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1594 Event<void(A0, A1)> event(mbed::Callback<R(B0, B1, B2, B3, A0, A1)> cb, C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 1595
valeyev 0:e056ac8fecf8 1596 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1597 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1598 */
valeyev 0:e056ac8fecf8 1599 template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1600 Event<void(A0, A1)> event(R (*func)(B0, B1, B2, B3, B4, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 1601
valeyev 0:e056ac8fecf8 1602 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1603 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1604 */
valeyev 0:e056ac8fecf8 1605 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1606 Event<void(A0, A1)> event(T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 1607
valeyev 0:e056ac8fecf8 1608 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1609 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1610 */
valeyev 0:e056ac8fecf8 1611 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1612 Event<void(A0, A1)> event(const T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1) const, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 1613
valeyev 0:e056ac8fecf8 1614 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1615 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1616 */
valeyev 0:e056ac8fecf8 1617 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1618 Event<void(A0, A1)> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1) volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 1619
valeyev 0:e056ac8fecf8 1620 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1621 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1622 */
valeyev 0:e056ac8fecf8 1623 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1624 Event<void(A0, A1)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1) const volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 1625
valeyev 0:e056ac8fecf8 1626 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1627 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1628 */
valeyev 0:e056ac8fecf8 1629 template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1>
valeyev 0:e056ac8fecf8 1630 Event<void(A0, A1)> event(mbed::Callback<R(B0, B1, B2, B3, B4, A0, A1)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 1631
valeyev 0:e056ac8fecf8 1632 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1633 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1634 */
valeyev 0:e056ac8fecf8 1635 template <typename R, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1636 Event<void(A0, A1, A2)> event(R (*func)(A0, A1, A2));
valeyev 0:e056ac8fecf8 1637
valeyev 0:e056ac8fecf8 1638 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1639 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1640 */
valeyev 0:e056ac8fecf8 1641 template <typename T, typename R, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1642 Event<void(A0, A1, A2)> event(T *obj, R (T::*method)(A0, A1, A2));
valeyev 0:e056ac8fecf8 1643
valeyev 0:e056ac8fecf8 1644 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1645 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1646 */
valeyev 0:e056ac8fecf8 1647 template <typename T, typename R, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1648 Event<void(A0, A1, A2)> event(const T *obj, R (T::*method)(A0, A1, A2) const);
valeyev 0:e056ac8fecf8 1649
valeyev 0:e056ac8fecf8 1650 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1651 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1652 */
valeyev 0:e056ac8fecf8 1653 template <typename T, typename R, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1654 Event<void(A0, A1, A2)> event(volatile T *obj, R (T::*method)(A0, A1, A2) volatile);
valeyev 0:e056ac8fecf8 1655
valeyev 0:e056ac8fecf8 1656 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1657 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1658 */
valeyev 0:e056ac8fecf8 1659 template <typename T, typename R, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1660 Event<void(A0, A1, A2)> event(const volatile T *obj, R (T::*method)(A0, A1, A2) const volatile);
valeyev 0:e056ac8fecf8 1661
valeyev 0:e056ac8fecf8 1662 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1663 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1664 */
valeyev 0:e056ac8fecf8 1665 template <typename R, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1666 Event<void(A0, A1, A2)> event(mbed::Callback<R(A0, A1, A2)> cb);
valeyev 0:e056ac8fecf8 1667
valeyev 0:e056ac8fecf8 1668 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1669 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1670 */
valeyev 0:e056ac8fecf8 1671 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1672 Event<void(A0, A1, A2)> event(R (*func)(B0, A0, A1, A2), C0 c0);
valeyev 0:e056ac8fecf8 1673
valeyev 0:e056ac8fecf8 1674 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1675 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1676 */
valeyev 0:e056ac8fecf8 1677 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1678 Event<void(A0, A1, A2)> event(T *obj, R (T::*method)(B0, A0, A1, A2), C0 c0);
valeyev 0:e056ac8fecf8 1679
valeyev 0:e056ac8fecf8 1680 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1681 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1682 */
valeyev 0:e056ac8fecf8 1683 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1684 Event<void(A0, A1, A2)> event(const T *obj, R (T::*method)(B0, A0, A1, A2) const, C0 c0);
valeyev 0:e056ac8fecf8 1685
valeyev 0:e056ac8fecf8 1686 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1687 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1688 */
valeyev 0:e056ac8fecf8 1689 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1690 Event<void(A0, A1, A2)> event(volatile T *obj, R (T::*method)(B0, A0, A1, A2) volatile, C0 c0);
valeyev 0:e056ac8fecf8 1691
valeyev 0:e056ac8fecf8 1692 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1693 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1694 */
valeyev 0:e056ac8fecf8 1695 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1696 Event<void(A0, A1, A2)> event(const volatile T *obj, R (T::*method)(B0, A0, A1, A2) const volatile, C0 c0);
valeyev 0:e056ac8fecf8 1697
valeyev 0:e056ac8fecf8 1698 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1699 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1700 */
valeyev 0:e056ac8fecf8 1701 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1702 Event<void(A0, A1, A2)> event(mbed::Callback<R(B0, A0, A1, A2)> cb, C0 c0);
valeyev 0:e056ac8fecf8 1703
valeyev 0:e056ac8fecf8 1704 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1705 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1706 */
valeyev 0:e056ac8fecf8 1707 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1708 Event<void(A0, A1, A2)> event(R (*func)(B0, B1, A0, A1, A2), C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1709
valeyev 0:e056ac8fecf8 1710 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1711 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1712 */
valeyev 0:e056ac8fecf8 1713 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1714 Event<void(A0, A1, A2)> event(T *obj, R (T::*method)(B0, B1, A0, A1, A2), C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1715
valeyev 0:e056ac8fecf8 1716 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1717 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1718 */
valeyev 0:e056ac8fecf8 1719 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1720 Event<void(A0, A1, A2)> event(const T *obj, R (T::*method)(B0, B1, A0, A1, A2) const, C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1721
valeyev 0:e056ac8fecf8 1722 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1723 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1724 */
valeyev 0:e056ac8fecf8 1725 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1726 Event<void(A0, A1, A2)> event(volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2) volatile, C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1727
valeyev 0:e056ac8fecf8 1728 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1729 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1730 */
valeyev 0:e056ac8fecf8 1731 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1732 Event<void(A0, A1, A2)> event(const volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2) const volatile, C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1733
valeyev 0:e056ac8fecf8 1734 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1735 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1736 */
valeyev 0:e056ac8fecf8 1737 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1738 Event<void(A0, A1, A2)> event(mbed::Callback<R(B0, B1, A0, A1, A2)> cb, C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1739
valeyev 0:e056ac8fecf8 1740 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1741 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1742 */
valeyev 0:e056ac8fecf8 1743 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1744 Event<void(A0, A1, A2)> event(R (*func)(B0, B1, B2, A0, A1, A2), C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1745
valeyev 0:e056ac8fecf8 1746 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1747 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1748 */
valeyev 0:e056ac8fecf8 1749 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1750 Event<void(A0, A1, A2)> event(T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2), C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1751
valeyev 0:e056ac8fecf8 1752 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1753 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1754 */
valeyev 0:e056ac8fecf8 1755 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1756 Event<void(A0, A1, A2)> event(const T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2) const, C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1757
valeyev 0:e056ac8fecf8 1758 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1759 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1760 */
valeyev 0:e056ac8fecf8 1761 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1762 Event<void(A0, A1, A2)> event(volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2) volatile, C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1763
valeyev 0:e056ac8fecf8 1764 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1765 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1766 */
valeyev 0:e056ac8fecf8 1767 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1768 Event<void(A0, A1, A2)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2) const volatile, C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1769
valeyev 0:e056ac8fecf8 1770 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1771 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1772 */
valeyev 0:e056ac8fecf8 1773 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1774 Event<void(A0, A1, A2)> event(mbed::Callback<R(B0, B1, B2, A0, A1, A2)> cb, C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1775
valeyev 0:e056ac8fecf8 1776 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1777 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1778 */
valeyev 0:e056ac8fecf8 1779 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1780 Event<void(A0, A1, A2)> event(R (*func)(B0, B1, B2, B3, A0, A1, A2), C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 1781
valeyev 0:e056ac8fecf8 1782 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1783 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1784 */
valeyev 0:e056ac8fecf8 1785 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1786 Event<void(A0, A1, A2)> event(T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2), C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 1787
valeyev 0:e056ac8fecf8 1788 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1789 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1790 */
valeyev 0:e056ac8fecf8 1791 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1792 Event<void(A0, A1, A2)> event(const T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2) const, C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 1793
valeyev 0:e056ac8fecf8 1794 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1795 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1796 */
valeyev 0:e056ac8fecf8 1797 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1798 Event<void(A0, A1, A2)> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2) volatile, C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 1799
valeyev 0:e056ac8fecf8 1800 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1801 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1802 */
valeyev 0:e056ac8fecf8 1803 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1804 Event<void(A0, A1, A2)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2) const volatile, C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 1805
valeyev 0:e056ac8fecf8 1806 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1807 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1808 */
valeyev 0:e056ac8fecf8 1809 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1810 Event<void(A0, A1, A2)> event(mbed::Callback<R(B0, B1, B2, B3, A0, A1, A2)> cb, C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 1811
valeyev 0:e056ac8fecf8 1812 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1813 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1814 */
valeyev 0:e056ac8fecf8 1815 template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1816 Event<void(A0, A1, A2)> event(R (*func)(B0, B1, B2, B3, B4, A0, A1, A2), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 1817
valeyev 0:e056ac8fecf8 1818 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1819 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1820 */
valeyev 0:e056ac8fecf8 1821 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1822 Event<void(A0, A1, A2)> event(T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 1823
valeyev 0:e056ac8fecf8 1824 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1825 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1826 */
valeyev 0:e056ac8fecf8 1827 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1828 Event<void(A0, A1, A2)> event(const T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2) const, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 1829
valeyev 0:e056ac8fecf8 1830 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1831 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1832 */
valeyev 0:e056ac8fecf8 1833 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1834 Event<void(A0, A1, A2)> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2) volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 1835
valeyev 0:e056ac8fecf8 1836 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1837 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1838 */
valeyev 0:e056ac8fecf8 1839 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1840 Event<void(A0, A1, A2)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2) const volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 1841
valeyev 0:e056ac8fecf8 1842 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1843 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1844 */
valeyev 0:e056ac8fecf8 1845 template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1846 Event<void(A0, A1, A2)> event(mbed::Callback<R(B0, B1, B2, B3, B4, A0, A1, A2)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 1847
valeyev 0:e056ac8fecf8 1848 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1849 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1850 */
valeyev 0:e056ac8fecf8 1851 template <typename R, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 1852 Event<void(A0, A1, A2, A3)> event(R (*func)(A0, A1, A2, A3));
valeyev 0:e056ac8fecf8 1853
valeyev 0:e056ac8fecf8 1854 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1855 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1856 */
valeyev 0:e056ac8fecf8 1857 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 1858 Event<void(A0, A1, A2, A3)> event(T *obj, R (T::*method)(A0, A1, A2, A3));
valeyev 0:e056ac8fecf8 1859
valeyev 0:e056ac8fecf8 1860 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1861 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1862 */
valeyev 0:e056ac8fecf8 1863 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 1864 Event<void(A0, A1, A2, A3)> event(const T *obj, R (T::*method)(A0, A1, A2, A3) const);
valeyev 0:e056ac8fecf8 1865
valeyev 0:e056ac8fecf8 1866 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1867 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1868 */
valeyev 0:e056ac8fecf8 1869 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 1870 Event<void(A0, A1, A2, A3)> event(volatile T *obj, R (T::*method)(A0, A1, A2, A3) volatile);
valeyev 0:e056ac8fecf8 1871
valeyev 0:e056ac8fecf8 1872 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1873 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1874 */
valeyev 0:e056ac8fecf8 1875 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 1876 Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R (T::*method)(A0, A1, A2, A3) const volatile);
valeyev 0:e056ac8fecf8 1877
valeyev 0:e056ac8fecf8 1878 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1879 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1880 */
valeyev 0:e056ac8fecf8 1881 template <typename R, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 1882 Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(A0, A1, A2, A3)> cb);
valeyev 0:e056ac8fecf8 1883
valeyev 0:e056ac8fecf8 1884 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1885 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1886 */
valeyev 0:e056ac8fecf8 1887 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 1888 Event<void(A0, A1, A2, A3)> event(R (*func)(B0, A0, A1, A2, A3), C0 c0);
valeyev 0:e056ac8fecf8 1889
valeyev 0:e056ac8fecf8 1890 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1891 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1892 */
valeyev 0:e056ac8fecf8 1893 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 1894 Event<void(A0, A1, A2, A3)> event(T *obj, R (T::*method)(B0, A0, A1, A2, A3), C0 c0);
valeyev 0:e056ac8fecf8 1895
valeyev 0:e056ac8fecf8 1896 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1897 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1898 */
valeyev 0:e056ac8fecf8 1899 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 1900 Event<void(A0, A1, A2, A3)> event(const T *obj, R (T::*method)(B0, A0, A1, A2, A3) const, C0 c0);
valeyev 0:e056ac8fecf8 1901
valeyev 0:e056ac8fecf8 1902 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1903 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1904 */
valeyev 0:e056ac8fecf8 1905 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 1906 Event<void(A0, A1, A2, A3)> event(volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3) volatile, C0 c0);
valeyev 0:e056ac8fecf8 1907
valeyev 0:e056ac8fecf8 1908 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1909 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1910 */
valeyev 0:e056ac8fecf8 1911 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 1912 Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3) const volatile, C0 c0);
valeyev 0:e056ac8fecf8 1913
valeyev 0:e056ac8fecf8 1914 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1915 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1916 */
valeyev 0:e056ac8fecf8 1917 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 1918 Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(B0, A0, A1, A2, A3)> cb, C0 c0);
valeyev 0:e056ac8fecf8 1919
valeyev 0:e056ac8fecf8 1920 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1921 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1922 */
valeyev 0:e056ac8fecf8 1923 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 1924 Event<void(A0, A1, A2, A3)> event(R (*func)(B0, B1, A0, A1, A2, A3), C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1925
valeyev 0:e056ac8fecf8 1926 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1927 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1928 */
valeyev 0:e056ac8fecf8 1929 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 1930 Event<void(A0, A1, A2, A3)> event(T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3), C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1931
valeyev 0:e056ac8fecf8 1932 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1933 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1934 */
valeyev 0:e056ac8fecf8 1935 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 1936 Event<void(A0, A1, A2, A3)> event(const T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3) const, C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1937
valeyev 0:e056ac8fecf8 1938 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1939 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1940 */
valeyev 0:e056ac8fecf8 1941 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 1942 Event<void(A0, A1, A2, A3)> event(volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3) volatile, C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1943
valeyev 0:e056ac8fecf8 1944 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1945 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1946 */
valeyev 0:e056ac8fecf8 1947 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 1948 Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3) const volatile, C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1949
valeyev 0:e056ac8fecf8 1950 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1951 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1952 */
valeyev 0:e056ac8fecf8 1953 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 1954 Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(B0, B1, A0, A1, A2, A3)> cb, C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 1955
valeyev 0:e056ac8fecf8 1956 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1957 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1958 */
valeyev 0:e056ac8fecf8 1959 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 1960 Event<void(A0, A1, A2, A3)> event(R (*func)(B0, B1, B2, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1961
valeyev 0:e056ac8fecf8 1962 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1963 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1964 */
valeyev 0:e056ac8fecf8 1965 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 1966 Event<void(A0, A1, A2, A3)> event(T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1967
valeyev 0:e056ac8fecf8 1968 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1969 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1970 */
valeyev 0:e056ac8fecf8 1971 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 1972 Event<void(A0, A1, A2, A3)> event(const T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3) const, C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1973
valeyev 0:e056ac8fecf8 1974 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1975 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1976 */
valeyev 0:e056ac8fecf8 1977 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 1978 Event<void(A0, A1, A2, A3)> event(volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3) volatile, C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1979
valeyev 0:e056ac8fecf8 1980 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1981 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1982 */
valeyev 0:e056ac8fecf8 1983 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 1984 Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3) const volatile, C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1985
valeyev 0:e056ac8fecf8 1986 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1987 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1988 */
valeyev 0:e056ac8fecf8 1989 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 1990 Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(B0, B1, B2, A0, A1, A2, A3)> cb, C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 1991
valeyev 0:e056ac8fecf8 1992 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1993 * @see EventQueue::event
valeyev 0:e056ac8fecf8 1994 */
valeyev 0:e056ac8fecf8 1995 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 1996 Event<void(A0, A1, A2, A3)> event(R (*func)(B0, B1, B2, B3, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 1997
valeyev 0:e056ac8fecf8 1998 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 1999 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2000 */
valeyev 0:e056ac8fecf8 2001 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 2002 Event<void(A0, A1, A2, A3)> event(T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 2003
valeyev 0:e056ac8fecf8 2004 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2005 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2006 */
valeyev 0:e056ac8fecf8 2007 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 2008 Event<void(A0, A1, A2, A3)> event(const T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3) const, C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 2009
valeyev 0:e056ac8fecf8 2010 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2011 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2012 */
valeyev 0:e056ac8fecf8 2013 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 2014 Event<void(A0, A1, A2, A3)> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3) volatile, C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 2015
valeyev 0:e056ac8fecf8 2016 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2017 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2018 */
valeyev 0:e056ac8fecf8 2019 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 2020 Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3) const volatile, C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 2021
valeyev 0:e056ac8fecf8 2022 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2023 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2024 */
valeyev 0:e056ac8fecf8 2025 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 2026 Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(B0, B1, B2, B3, A0, A1, A2, A3)> cb, C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 2027
valeyev 0:e056ac8fecf8 2028 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2029 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2030 */
valeyev 0:e056ac8fecf8 2031 template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 2032 Event<void(A0, A1, A2, A3)> event(R (*func)(B0, B1, B2, B3, B4, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 2033
valeyev 0:e056ac8fecf8 2034 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2035 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2036 */
valeyev 0:e056ac8fecf8 2037 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 2038 Event<void(A0, A1, A2, A3)> event(T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 2039
valeyev 0:e056ac8fecf8 2040 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2041 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2042 */
valeyev 0:e056ac8fecf8 2043 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 2044 Event<void(A0, A1, A2, A3)> event(const T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3) const, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 2045
valeyev 0:e056ac8fecf8 2046 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2047 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2048 */
valeyev 0:e056ac8fecf8 2049 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 2050 Event<void(A0, A1, A2, A3)> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3) volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 2051
valeyev 0:e056ac8fecf8 2052 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2053 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2054 */
valeyev 0:e056ac8fecf8 2055 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 2056 Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3) const volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 2057
valeyev 0:e056ac8fecf8 2058 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2059 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2060 */
valeyev 0:e056ac8fecf8 2061 template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 2062 Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(B0, B1, B2, B3, B4, A0, A1, A2, A3)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 2063
valeyev 0:e056ac8fecf8 2064 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2065 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2066 */
valeyev 0:e056ac8fecf8 2067 template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2068 Event<void(A0, A1, A2, A3, A4)> event(R (*func)(A0, A1, A2, A3, A4));
valeyev 0:e056ac8fecf8 2069
valeyev 0:e056ac8fecf8 2070 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2071 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2072 */
valeyev 0:e056ac8fecf8 2073 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2074 Event<void(A0, A1, A2, A3, A4)> event(T *obj, R (T::*method)(A0, A1, A2, A3, A4));
valeyev 0:e056ac8fecf8 2075
valeyev 0:e056ac8fecf8 2076 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2077 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2078 */
valeyev 0:e056ac8fecf8 2079 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2080 Event<void(A0, A1, A2, A3, A4)> event(const T *obj, R (T::*method)(A0, A1, A2, A3, A4) const);
valeyev 0:e056ac8fecf8 2081
valeyev 0:e056ac8fecf8 2082 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2083 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2084 */
valeyev 0:e056ac8fecf8 2085 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2086 Event<void(A0, A1, A2, A3, A4)> event(volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) volatile);
valeyev 0:e056ac8fecf8 2087
valeyev 0:e056ac8fecf8 2088 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2089 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2090 */
valeyev 0:e056ac8fecf8 2091 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2092 Event<void(A0, A1, A2, A3, A4)> event(const volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) const volatile);
valeyev 0:e056ac8fecf8 2093
valeyev 0:e056ac8fecf8 2094 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2095 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2096 */
valeyev 0:e056ac8fecf8 2097 template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2098 Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(A0, A1, A2, A3, A4)> cb);
valeyev 0:e056ac8fecf8 2099
valeyev 0:e056ac8fecf8 2100 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2101 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2102 */
valeyev 0:e056ac8fecf8 2103 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2104 Event<void(A0, A1, A2, A3, A4)> event(R (*func)(B0, A0, A1, A2, A3, A4), C0 c0);
valeyev 0:e056ac8fecf8 2105
valeyev 0:e056ac8fecf8 2106 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2107 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2108 */
valeyev 0:e056ac8fecf8 2109 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2110 Event<void(A0, A1, A2, A3, A4)> event(T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4), C0 c0);
valeyev 0:e056ac8fecf8 2111
valeyev 0:e056ac8fecf8 2112 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2113 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2114 */
valeyev 0:e056ac8fecf8 2115 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2116 Event<void(A0, A1, A2, A3, A4)> event(const T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4) const, C0 c0);
valeyev 0:e056ac8fecf8 2117
valeyev 0:e056ac8fecf8 2118 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2119 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2120 */
valeyev 0:e056ac8fecf8 2121 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2122 Event<void(A0, A1, A2, A3, A4)> event(volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4) volatile, C0 c0);
valeyev 0:e056ac8fecf8 2123
valeyev 0:e056ac8fecf8 2124 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2125 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2126 */
valeyev 0:e056ac8fecf8 2127 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2128 Event<void(A0, A1, A2, A3, A4)> event(const volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4) const volatile, C0 c0);
valeyev 0:e056ac8fecf8 2129
valeyev 0:e056ac8fecf8 2130 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2131 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2132 */
valeyev 0:e056ac8fecf8 2133 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2134 Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(B0, A0, A1, A2, A3, A4)> cb, C0 c0);
valeyev 0:e056ac8fecf8 2135
valeyev 0:e056ac8fecf8 2136 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2137 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2138 */
valeyev 0:e056ac8fecf8 2139 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2140 Event<void(A0, A1, A2, A3, A4)> event(R (*func)(B0, B1, A0, A1, A2, A3, A4), C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 2141
valeyev 0:e056ac8fecf8 2142 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2143 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2144 */
valeyev 0:e056ac8fecf8 2145 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2146 Event<void(A0, A1, A2, A3, A4)> event(T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3, A4), C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 2147
valeyev 0:e056ac8fecf8 2148 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2149 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2150 */
valeyev 0:e056ac8fecf8 2151 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2152 Event<void(A0, A1, A2, A3, A4)> event(const T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3, A4) const, C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 2153
valeyev 0:e056ac8fecf8 2154 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2155 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2156 */
valeyev 0:e056ac8fecf8 2157 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2158 Event<void(A0, A1, A2, A3, A4)> event(volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3, A4) volatile, C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 2159
valeyev 0:e056ac8fecf8 2160 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2161 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2162 */
valeyev 0:e056ac8fecf8 2163 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2164 Event<void(A0, A1, A2, A3, A4)> event(const volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3, A4) const volatile, C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 2165
valeyev 0:e056ac8fecf8 2166 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2167 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2168 */
valeyev 0:e056ac8fecf8 2169 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2170 Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(B0, B1, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1);
valeyev 0:e056ac8fecf8 2171
valeyev 0:e056ac8fecf8 2172 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2173 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2174 */
valeyev 0:e056ac8fecf8 2175 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2176 Event<void(A0, A1, A2, A3, A4)> event(R (*func)(B0, B1, B2, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 2177
valeyev 0:e056ac8fecf8 2178 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2179 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2180 */
valeyev 0:e056ac8fecf8 2181 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2182 Event<void(A0, A1, A2, A3, A4)> event(T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 2183
valeyev 0:e056ac8fecf8 2184 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2185 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2186 */
valeyev 0:e056ac8fecf8 2187 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2188 Event<void(A0, A1, A2, A3, A4)> event(const T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3, A4) const, C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 2189
valeyev 0:e056ac8fecf8 2190 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2191 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2192 */
valeyev 0:e056ac8fecf8 2193 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2194 Event<void(A0, A1, A2, A3, A4)> event(volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3, A4) volatile, C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 2195
valeyev 0:e056ac8fecf8 2196 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2197 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2198 */
valeyev 0:e056ac8fecf8 2199 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2200 Event<void(A0, A1, A2, A3, A4)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3, A4) const volatile, C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 2201
valeyev 0:e056ac8fecf8 2202 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2203 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2204 */
valeyev 0:e056ac8fecf8 2205 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2206 Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(B0, B1, B2, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1, C2 c2);
valeyev 0:e056ac8fecf8 2207
valeyev 0:e056ac8fecf8 2208 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2209 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2210 */
valeyev 0:e056ac8fecf8 2211 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2212 Event<void(A0, A1, A2, A3, A4)> event(R (*func)(B0, B1, B2, B3, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 2213
valeyev 0:e056ac8fecf8 2214 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2215 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2216 */
valeyev 0:e056ac8fecf8 2217 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2218 Event<void(A0, A1, A2, A3, A4)> event(T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 2219
valeyev 0:e056ac8fecf8 2220 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2221 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2222 */
valeyev 0:e056ac8fecf8 2223 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2224 Event<void(A0, A1, A2, A3, A4)> event(const T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3, A4) const, C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 2225
valeyev 0:e056ac8fecf8 2226 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2227 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2228 */
valeyev 0:e056ac8fecf8 2229 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2230 Event<void(A0, A1, A2, A3, A4)> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3, A4) volatile, C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 2231
valeyev 0:e056ac8fecf8 2232 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2233 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2234 */
valeyev 0:e056ac8fecf8 2235 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2236 Event<void(A0, A1, A2, A3, A4)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3, A4) const volatile, C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 2237
valeyev 0:e056ac8fecf8 2238 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2239 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2240 */
valeyev 0:e056ac8fecf8 2241 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2242 Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(B0, B1, B2, B3, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1, C2 c2, C3 c3);
valeyev 0:e056ac8fecf8 2243
valeyev 0:e056ac8fecf8 2244 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2245 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2246 */
valeyev 0:e056ac8fecf8 2247 template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2248 Event<void(A0, A1, A2, A3, A4)> event(R (*func)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 2249
valeyev 0:e056ac8fecf8 2250 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2251 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2252 */
valeyev 0:e056ac8fecf8 2253 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2254 Event<void(A0, A1, A2, A3, A4)> event(T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 2255
valeyev 0:e056ac8fecf8 2256 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2257 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2258 */
valeyev 0:e056ac8fecf8 2259 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2260 Event<void(A0, A1, A2, A3, A4)> event(const T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4) const, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 2261
valeyev 0:e056ac8fecf8 2262 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2263 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2264 */
valeyev 0:e056ac8fecf8 2265 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2266 Event<void(A0, A1, A2, A3, A4)> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4) volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 2267
valeyev 0:e056ac8fecf8 2268 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2269 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2270 */
valeyev 0:e056ac8fecf8 2271 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2272 Event<void(A0, A1, A2, A3, A4)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4) const volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 2273
valeyev 0:e056ac8fecf8 2274 /** Creates an event bound to the event queue
valeyev 0:e056ac8fecf8 2275 * @see EventQueue::event
valeyev 0:e056ac8fecf8 2276 */
valeyev 0:e056ac8fecf8 2277 template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2278 Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
valeyev 0:e056ac8fecf8 2279
valeyev 0:e056ac8fecf8 2280 protected:
valeyev 0:e056ac8fecf8 2281 template <typename F>
valeyev 0:e056ac8fecf8 2282 friend class Event;
valeyev 0:e056ac8fecf8 2283 struct equeue _equeue;
valeyev 0:e056ac8fecf8 2284 mbed::Callback<void(int)> _update;
valeyev 0:e056ac8fecf8 2285
valeyev 0:e056ac8fecf8 2286 // Function attributes
valeyev 0:e056ac8fecf8 2287 template <typename F>
valeyev 0:e056ac8fecf8 2288 static void function_call(void *p) {
valeyev 0:e056ac8fecf8 2289 (*(F*)p)();
valeyev 0:e056ac8fecf8 2290 }
valeyev 0:e056ac8fecf8 2291
valeyev 0:e056ac8fecf8 2292 template <typename F>
valeyev 0:e056ac8fecf8 2293 static void function_dtor(void *p) {
valeyev 0:e056ac8fecf8 2294 ((F*)p)->~F();
valeyev 0:e056ac8fecf8 2295 }
valeyev 0:e056ac8fecf8 2296
valeyev 0:e056ac8fecf8 2297 // Context structures
valeyev 0:e056ac8fecf8 2298 template <typename F>
valeyev 0:e056ac8fecf8 2299 struct context00 {
valeyev 0:e056ac8fecf8 2300 F f;
valeyev 0:e056ac8fecf8 2301
valeyev 0:e056ac8fecf8 2302 context00(F f)
valeyev 0:e056ac8fecf8 2303 : f(f) {}
valeyev 0:e056ac8fecf8 2304
valeyev 0:e056ac8fecf8 2305 void operator()() {
valeyev 0:e056ac8fecf8 2306 f();
valeyev 0:e056ac8fecf8 2307 }
valeyev 0:e056ac8fecf8 2308 };
valeyev 0:e056ac8fecf8 2309
valeyev 0:e056ac8fecf8 2310 template <typename F, typename C0>
valeyev 0:e056ac8fecf8 2311 struct context10 {
valeyev 0:e056ac8fecf8 2312 F f; C0 c0;
valeyev 0:e056ac8fecf8 2313
valeyev 0:e056ac8fecf8 2314 context10(F f, C0 c0)
valeyev 0:e056ac8fecf8 2315 : f(f), c0(c0) {}
valeyev 0:e056ac8fecf8 2316
valeyev 0:e056ac8fecf8 2317 void operator()() {
valeyev 0:e056ac8fecf8 2318 f(c0);
valeyev 0:e056ac8fecf8 2319 }
valeyev 0:e056ac8fecf8 2320 };
valeyev 0:e056ac8fecf8 2321
valeyev 0:e056ac8fecf8 2322 template <typename F, typename C0, typename C1>
valeyev 0:e056ac8fecf8 2323 struct context20 {
valeyev 0:e056ac8fecf8 2324 F f; C0 c0; C1 c1;
valeyev 0:e056ac8fecf8 2325
valeyev 0:e056ac8fecf8 2326 context20(F f, C0 c0, C1 c1)
valeyev 0:e056ac8fecf8 2327 : f(f), c0(c0), c1(c1) {}
valeyev 0:e056ac8fecf8 2328
valeyev 0:e056ac8fecf8 2329 void operator()() {
valeyev 0:e056ac8fecf8 2330 f(c0, c1);
valeyev 0:e056ac8fecf8 2331 }
valeyev 0:e056ac8fecf8 2332 };
valeyev 0:e056ac8fecf8 2333
valeyev 0:e056ac8fecf8 2334 template <typename F, typename C0, typename C1, typename C2>
valeyev 0:e056ac8fecf8 2335 struct context30 {
valeyev 0:e056ac8fecf8 2336 F f; C0 c0; C1 c1; C2 c2;
valeyev 0:e056ac8fecf8 2337
valeyev 0:e056ac8fecf8 2338 context30(F f, C0 c0, C1 c1, C2 c2)
valeyev 0:e056ac8fecf8 2339 : f(f), c0(c0), c1(c1), c2(c2) {}
valeyev 0:e056ac8fecf8 2340
valeyev 0:e056ac8fecf8 2341 void operator()() {
valeyev 0:e056ac8fecf8 2342 f(c0, c1, c2);
valeyev 0:e056ac8fecf8 2343 }
valeyev 0:e056ac8fecf8 2344 };
valeyev 0:e056ac8fecf8 2345
valeyev 0:e056ac8fecf8 2346 template <typename F, typename C0, typename C1, typename C2, typename C3>
valeyev 0:e056ac8fecf8 2347 struct context40 {
valeyev 0:e056ac8fecf8 2348 F f; C0 c0; C1 c1; C2 c2; C3 c3;
valeyev 0:e056ac8fecf8 2349
valeyev 0:e056ac8fecf8 2350 context40(F f, C0 c0, C1 c1, C2 c2, C3 c3)
valeyev 0:e056ac8fecf8 2351 : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {}
valeyev 0:e056ac8fecf8 2352
valeyev 0:e056ac8fecf8 2353 void operator()() {
valeyev 0:e056ac8fecf8 2354 f(c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 2355 }
valeyev 0:e056ac8fecf8 2356 };
valeyev 0:e056ac8fecf8 2357
valeyev 0:e056ac8fecf8 2358 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4>
valeyev 0:e056ac8fecf8 2359 struct context50 {
valeyev 0:e056ac8fecf8 2360 F f; C0 c0; C1 c1; C2 c2; C3 c3; C4 c4;
valeyev 0:e056ac8fecf8 2361
valeyev 0:e056ac8fecf8 2362 context50(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
valeyev 0:e056ac8fecf8 2363 : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {}
valeyev 0:e056ac8fecf8 2364
valeyev 0:e056ac8fecf8 2365 void operator()() {
valeyev 0:e056ac8fecf8 2366 f(c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 2367 }
valeyev 0:e056ac8fecf8 2368 };
valeyev 0:e056ac8fecf8 2369
valeyev 0:e056ac8fecf8 2370 template <typename F, typename A0>
valeyev 0:e056ac8fecf8 2371 struct context01 {
valeyev 0:e056ac8fecf8 2372 F f;
valeyev 0:e056ac8fecf8 2373
valeyev 0:e056ac8fecf8 2374 context01(F f)
valeyev 0:e056ac8fecf8 2375 : f(f) {}
valeyev 0:e056ac8fecf8 2376
valeyev 0:e056ac8fecf8 2377 void operator()(A0 a0) {
valeyev 0:e056ac8fecf8 2378 f(a0);
valeyev 0:e056ac8fecf8 2379 }
valeyev 0:e056ac8fecf8 2380 };
valeyev 0:e056ac8fecf8 2381
valeyev 0:e056ac8fecf8 2382 template <typename F, typename C0, typename A0>
valeyev 0:e056ac8fecf8 2383 struct context11 {
valeyev 0:e056ac8fecf8 2384 F f; C0 c0;
valeyev 0:e056ac8fecf8 2385
valeyev 0:e056ac8fecf8 2386 context11(F f, C0 c0)
valeyev 0:e056ac8fecf8 2387 : f(f), c0(c0) {}
valeyev 0:e056ac8fecf8 2388
valeyev 0:e056ac8fecf8 2389 void operator()(A0 a0) {
valeyev 0:e056ac8fecf8 2390 f(c0, a0);
valeyev 0:e056ac8fecf8 2391 }
valeyev 0:e056ac8fecf8 2392 };
valeyev 0:e056ac8fecf8 2393
valeyev 0:e056ac8fecf8 2394 template <typename F, typename C0, typename C1, typename A0>
valeyev 0:e056ac8fecf8 2395 struct context21 {
valeyev 0:e056ac8fecf8 2396 F f; C0 c0; C1 c1;
valeyev 0:e056ac8fecf8 2397
valeyev 0:e056ac8fecf8 2398 context21(F f, C0 c0, C1 c1)
valeyev 0:e056ac8fecf8 2399 : f(f), c0(c0), c1(c1) {}
valeyev 0:e056ac8fecf8 2400
valeyev 0:e056ac8fecf8 2401 void operator()(A0 a0) {
valeyev 0:e056ac8fecf8 2402 f(c0, c1, a0);
valeyev 0:e056ac8fecf8 2403 }
valeyev 0:e056ac8fecf8 2404 };
valeyev 0:e056ac8fecf8 2405
valeyev 0:e056ac8fecf8 2406 template <typename F, typename C0, typename C1, typename C2, typename A0>
valeyev 0:e056ac8fecf8 2407 struct context31 {
valeyev 0:e056ac8fecf8 2408 F f; C0 c0; C1 c1; C2 c2;
valeyev 0:e056ac8fecf8 2409
valeyev 0:e056ac8fecf8 2410 context31(F f, C0 c0, C1 c1, C2 c2)
valeyev 0:e056ac8fecf8 2411 : f(f), c0(c0), c1(c1), c2(c2) {}
valeyev 0:e056ac8fecf8 2412
valeyev 0:e056ac8fecf8 2413 void operator()(A0 a0) {
valeyev 0:e056ac8fecf8 2414 f(c0, c1, c2, a0);
valeyev 0:e056ac8fecf8 2415 }
valeyev 0:e056ac8fecf8 2416 };
valeyev 0:e056ac8fecf8 2417
valeyev 0:e056ac8fecf8 2418 template <typename F, typename C0, typename C1, typename C2, typename C3, typename A0>
valeyev 0:e056ac8fecf8 2419 struct context41 {
valeyev 0:e056ac8fecf8 2420 F f; C0 c0; C1 c1; C2 c2; C3 c3;
valeyev 0:e056ac8fecf8 2421
valeyev 0:e056ac8fecf8 2422 context41(F f, C0 c0, C1 c1, C2 c2, C3 c3)
valeyev 0:e056ac8fecf8 2423 : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {}
valeyev 0:e056ac8fecf8 2424
valeyev 0:e056ac8fecf8 2425 void operator()(A0 a0) {
valeyev 0:e056ac8fecf8 2426 f(c0, c1, c2, c3, a0);
valeyev 0:e056ac8fecf8 2427 }
valeyev 0:e056ac8fecf8 2428 };
valeyev 0:e056ac8fecf8 2429
valeyev 0:e056ac8fecf8 2430 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0>
valeyev 0:e056ac8fecf8 2431 struct context51 {
valeyev 0:e056ac8fecf8 2432 F f; C0 c0; C1 c1; C2 c2; C3 c3; C4 c4;
valeyev 0:e056ac8fecf8 2433
valeyev 0:e056ac8fecf8 2434 context51(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
valeyev 0:e056ac8fecf8 2435 : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {}
valeyev 0:e056ac8fecf8 2436
valeyev 0:e056ac8fecf8 2437 void operator()(A0 a0) {
valeyev 0:e056ac8fecf8 2438 f(c0, c1, c2, c3, c4, a0);
valeyev 0:e056ac8fecf8 2439 }
valeyev 0:e056ac8fecf8 2440 };
valeyev 0:e056ac8fecf8 2441
valeyev 0:e056ac8fecf8 2442 template <typename F, typename A0, typename A1>
valeyev 0:e056ac8fecf8 2443 struct context02 {
valeyev 0:e056ac8fecf8 2444 F f;
valeyev 0:e056ac8fecf8 2445
valeyev 0:e056ac8fecf8 2446 context02(F f)
valeyev 0:e056ac8fecf8 2447 : f(f) {}
valeyev 0:e056ac8fecf8 2448
valeyev 0:e056ac8fecf8 2449 void operator()(A0 a0, A1 a1) {
valeyev 0:e056ac8fecf8 2450 f(a0, a1);
valeyev 0:e056ac8fecf8 2451 }
valeyev 0:e056ac8fecf8 2452 };
valeyev 0:e056ac8fecf8 2453
valeyev 0:e056ac8fecf8 2454 template <typename F, typename C0, typename A0, typename A1>
valeyev 0:e056ac8fecf8 2455 struct context12 {
valeyev 0:e056ac8fecf8 2456 F f; C0 c0;
valeyev 0:e056ac8fecf8 2457
valeyev 0:e056ac8fecf8 2458 context12(F f, C0 c0)
valeyev 0:e056ac8fecf8 2459 : f(f), c0(c0) {}
valeyev 0:e056ac8fecf8 2460
valeyev 0:e056ac8fecf8 2461 void operator()(A0 a0, A1 a1) {
valeyev 0:e056ac8fecf8 2462 f(c0, a0, a1);
valeyev 0:e056ac8fecf8 2463 }
valeyev 0:e056ac8fecf8 2464 };
valeyev 0:e056ac8fecf8 2465
valeyev 0:e056ac8fecf8 2466 template <typename F, typename C0, typename C1, typename A0, typename A1>
valeyev 0:e056ac8fecf8 2467 struct context22 {
valeyev 0:e056ac8fecf8 2468 F f; C0 c0; C1 c1;
valeyev 0:e056ac8fecf8 2469
valeyev 0:e056ac8fecf8 2470 context22(F f, C0 c0, C1 c1)
valeyev 0:e056ac8fecf8 2471 : f(f), c0(c0), c1(c1) {}
valeyev 0:e056ac8fecf8 2472
valeyev 0:e056ac8fecf8 2473 void operator()(A0 a0, A1 a1) {
valeyev 0:e056ac8fecf8 2474 f(c0, c1, a0, a1);
valeyev 0:e056ac8fecf8 2475 }
valeyev 0:e056ac8fecf8 2476 };
valeyev 0:e056ac8fecf8 2477
valeyev 0:e056ac8fecf8 2478 template <typename F, typename C0, typename C1, typename C2, typename A0, typename A1>
valeyev 0:e056ac8fecf8 2479 struct context32 {
valeyev 0:e056ac8fecf8 2480 F f; C0 c0; C1 c1; C2 c2;
valeyev 0:e056ac8fecf8 2481
valeyev 0:e056ac8fecf8 2482 context32(F f, C0 c0, C1 c1, C2 c2)
valeyev 0:e056ac8fecf8 2483 : f(f), c0(c0), c1(c1), c2(c2) {}
valeyev 0:e056ac8fecf8 2484
valeyev 0:e056ac8fecf8 2485 void operator()(A0 a0, A1 a1) {
valeyev 0:e056ac8fecf8 2486 f(c0, c1, c2, a0, a1);
valeyev 0:e056ac8fecf8 2487 }
valeyev 0:e056ac8fecf8 2488 };
valeyev 0:e056ac8fecf8 2489
valeyev 0:e056ac8fecf8 2490 template <typename F, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1>
valeyev 0:e056ac8fecf8 2491 struct context42 {
valeyev 0:e056ac8fecf8 2492 F f; C0 c0; C1 c1; C2 c2; C3 c3;
valeyev 0:e056ac8fecf8 2493
valeyev 0:e056ac8fecf8 2494 context42(F f, C0 c0, C1 c1, C2 c2, C3 c3)
valeyev 0:e056ac8fecf8 2495 : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {}
valeyev 0:e056ac8fecf8 2496
valeyev 0:e056ac8fecf8 2497 void operator()(A0 a0, A1 a1) {
valeyev 0:e056ac8fecf8 2498 f(c0, c1, c2, c3, a0, a1);
valeyev 0:e056ac8fecf8 2499 }
valeyev 0:e056ac8fecf8 2500 };
valeyev 0:e056ac8fecf8 2501
valeyev 0:e056ac8fecf8 2502 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1>
valeyev 0:e056ac8fecf8 2503 struct context52 {
valeyev 0:e056ac8fecf8 2504 F f; C0 c0; C1 c1; C2 c2; C3 c3; C4 c4;
valeyev 0:e056ac8fecf8 2505
valeyev 0:e056ac8fecf8 2506 context52(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
valeyev 0:e056ac8fecf8 2507 : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {}
valeyev 0:e056ac8fecf8 2508
valeyev 0:e056ac8fecf8 2509 void operator()(A0 a0, A1 a1) {
valeyev 0:e056ac8fecf8 2510 f(c0, c1, c2, c3, c4, a0, a1);
valeyev 0:e056ac8fecf8 2511 }
valeyev 0:e056ac8fecf8 2512 };
valeyev 0:e056ac8fecf8 2513
valeyev 0:e056ac8fecf8 2514 template <typename F, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 2515 struct context03 {
valeyev 0:e056ac8fecf8 2516 F f;
valeyev 0:e056ac8fecf8 2517
valeyev 0:e056ac8fecf8 2518 context03(F f)
valeyev 0:e056ac8fecf8 2519 : f(f) {}
valeyev 0:e056ac8fecf8 2520
valeyev 0:e056ac8fecf8 2521 void operator()(A0 a0, A1 a1, A2 a2) {
valeyev 0:e056ac8fecf8 2522 f(a0, a1, a2);
valeyev 0:e056ac8fecf8 2523 }
valeyev 0:e056ac8fecf8 2524 };
valeyev 0:e056ac8fecf8 2525
valeyev 0:e056ac8fecf8 2526 template <typename F, typename C0, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 2527 struct context13 {
valeyev 0:e056ac8fecf8 2528 F f; C0 c0;
valeyev 0:e056ac8fecf8 2529
valeyev 0:e056ac8fecf8 2530 context13(F f, C0 c0)
valeyev 0:e056ac8fecf8 2531 : f(f), c0(c0) {}
valeyev 0:e056ac8fecf8 2532
valeyev 0:e056ac8fecf8 2533 void operator()(A0 a0, A1 a1, A2 a2) {
valeyev 0:e056ac8fecf8 2534 f(c0, a0, a1, a2);
valeyev 0:e056ac8fecf8 2535 }
valeyev 0:e056ac8fecf8 2536 };
valeyev 0:e056ac8fecf8 2537
valeyev 0:e056ac8fecf8 2538 template <typename F, typename C0, typename C1, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 2539 struct context23 {
valeyev 0:e056ac8fecf8 2540 F f; C0 c0; C1 c1;
valeyev 0:e056ac8fecf8 2541
valeyev 0:e056ac8fecf8 2542 context23(F f, C0 c0, C1 c1)
valeyev 0:e056ac8fecf8 2543 : f(f), c0(c0), c1(c1) {}
valeyev 0:e056ac8fecf8 2544
valeyev 0:e056ac8fecf8 2545 void operator()(A0 a0, A1 a1, A2 a2) {
valeyev 0:e056ac8fecf8 2546 f(c0, c1, a0, a1, a2);
valeyev 0:e056ac8fecf8 2547 }
valeyev 0:e056ac8fecf8 2548 };
valeyev 0:e056ac8fecf8 2549
valeyev 0:e056ac8fecf8 2550 template <typename F, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 2551 struct context33 {
valeyev 0:e056ac8fecf8 2552 F f; C0 c0; C1 c1; C2 c2;
valeyev 0:e056ac8fecf8 2553
valeyev 0:e056ac8fecf8 2554 context33(F f, C0 c0, C1 c1, C2 c2)
valeyev 0:e056ac8fecf8 2555 : f(f), c0(c0), c1(c1), c2(c2) {}
valeyev 0:e056ac8fecf8 2556
valeyev 0:e056ac8fecf8 2557 void operator()(A0 a0, A1 a1, A2 a2) {
valeyev 0:e056ac8fecf8 2558 f(c0, c1, c2, a0, a1, a2);
valeyev 0:e056ac8fecf8 2559 }
valeyev 0:e056ac8fecf8 2560 };
valeyev 0:e056ac8fecf8 2561
valeyev 0:e056ac8fecf8 2562 template <typename F, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 2563 struct context43 {
valeyev 0:e056ac8fecf8 2564 F f; C0 c0; C1 c1; C2 c2; C3 c3;
valeyev 0:e056ac8fecf8 2565
valeyev 0:e056ac8fecf8 2566 context43(F f, C0 c0, C1 c1, C2 c2, C3 c3)
valeyev 0:e056ac8fecf8 2567 : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {}
valeyev 0:e056ac8fecf8 2568
valeyev 0:e056ac8fecf8 2569 void operator()(A0 a0, A1 a1, A2 a2) {
valeyev 0:e056ac8fecf8 2570 f(c0, c1, c2, c3, a0, a1, a2);
valeyev 0:e056ac8fecf8 2571 }
valeyev 0:e056ac8fecf8 2572 };
valeyev 0:e056ac8fecf8 2573
valeyev 0:e056ac8fecf8 2574 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 2575 struct context53 {
valeyev 0:e056ac8fecf8 2576 F f; C0 c0; C1 c1; C2 c2; C3 c3; C4 c4;
valeyev 0:e056ac8fecf8 2577
valeyev 0:e056ac8fecf8 2578 context53(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
valeyev 0:e056ac8fecf8 2579 : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {}
valeyev 0:e056ac8fecf8 2580
valeyev 0:e056ac8fecf8 2581 void operator()(A0 a0, A1 a1, A2 a2) {
valeyev 0:e056ac8fecf8 2582 f(c0, c1, c2, c3, c4, a0, a1, a2);
valeyev 0:e056ac8fecf8 2583 }
valeyev 0:e056ac8fecf8 2584 };
valeyev 0:e056ac8fecf8 2585
valeyev 0:e056ac8fecf8 2586 template <typename F, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 2587 struct context04 {
valeyev 0:e056ac8fecf8 2588 F f;
valeyev 0:e056ac8fecf8 2589
valeyev 0:e056ac8fecf8 2590 context04(F f)
valeyev 0:e056ac8fecf8 2591 : f(f) {}
valeyev 0:e056ac8fecf8 2592
valeyev 0:e056ac8fecf8 2593 void operator()(A0 a0, A1 a1, A2 a2, A3 a3) {
valeyev 0:e056ac8fecf8 2594 f(a0, a1, a2, a3);
valeyev 0:e056ac8fecf8 2595 }
valeyev 0:e056ac8fecf8 2596 };
valeyev 0:e056ac8fecf8 2597
valeyev 0:e056ac8fecf8 2598 template <typename F, typename C0, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 2599 struct context14 {
valeyev 0:e056ac8fecf8 2600 F f; C0 c0;
valeyev 0:e056ac8fecf8 2601
valeyev 0:e056ac8fecf8 2602 context14(F f, C0 c0)
valeyev 0:e056ac8fecf8 2603 : f(f), c0(c0) {}
valeyev 0:e056ac8fecf8 2604
valeyev 0:e056ac8fecf8 2605 void operator()(A0 a0, A1 a1, A2 a2, A3 a3) {
valeyev 0:e056ac8fecf8 2606 f(c0, a0, a1, a2, a3);
valeyev 0:e056ac8fecf8 2607 }
valeyev 0:e056ac8fecf8 2608 };
valeyev 0:e056ac8fecf8 2609
valeyev 0:e056ac8fecf8 2610 template <typename F, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 2611 struct context24 {
valeyev 0:e056ac8fecf8 2612 F f; C0 c0; C1 c1;
valeyev 0:e056ac8fecf8 2613
valeyev 0:e056ac8fecf8 2614 context24(F f, C0 c0, C1 c1)
valeyev 0:e056ac8fecf8 2615 : f(f), c0(c0), c1(c1) {}
valeyev 0:e056ac8fecf8 2616
valeyev 0:e056ac8fecf8 2617 void operator()(A0 a0, A1 a1, A2 a2, A3 a3) {
valeyev 0:e056ac8fecf8 2618 f(c0, c1, a0, a1, a2, a3);
valeyev 0:e056ac8fecf8 2619 }
valeyev 0:e056ac8fecf8 2620 };
valeyev 0:e056ac8fecf8 2621
valeyev 0:e056ac8fecf8 2622 template <typename F, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 2623 struct context34 {
valeyev 0:e056ac8fecf8 2624 F f; C0 c0; C1 c1; C2 c2;
valeyev 0:e056ac8fecf8 2625
valeyev 0:e056ac8fecf8 2626 context34(F f, C0 c0, C1 c1, C2 c2)
valeyev 0:e056ac8fecf8 2627 : f(f), c0(c0), c1(c1), c2(c2) {}
valeyev 0:e056ac8fecf8 2628
valeyev 0:e056ac8fecf8 2629 void operator()(A0 a0, A1 a1, A2 a2, A3 a3) {
valeyev 0:e056ac8fecf8 2630 f(c0, c1, c2, a0, a1, a2, a3);
valeyev 0:e056ac8fecf8 2631 }
valeyev 0:e056ac8fecf8 2632 };
valeyev 0:e056ac8fecf8 2633
valeyev 0:e056ac8fecf8 2634 template <typename F, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 2635 struct context44 {
valeyev 0:e056ac8fecf8 2636 F f; C0 c0; C1 c1; C2 c2; C3 c3;
valeyev 0:e056ac8fecf8 2637
valeyev 0:e056ac8fecf8 2638 context44(F f, C0 c0, C1 c1, C2 c2, C3 c3)
valeyev 0:e056ac8fecf8 2639 : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {}
valeyev 0:e056ac8fecf8 2640
valeyev 0:e056ac8fecf8 2641 void operator()(A0 a0, A1 a1, A2 a2, A3 a3) {
valeyev 0:e056ac8fecf8 2642 f(c0, c1, c2, c3, a0, a1, a2, a3);
valeyev 0:e056ac8fecf8 2643 }
valeyev 0:e056ac8fecf8 2644 };
valeyev 0:e056ac8fecf8 2645
valeyev 0:e056ac8fecf8 2646 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 2647 struct context54 {
valeyev 0:e056ac8fecf8 2648 F f; C0 c0; C1 c1; C2 c2; C3 c3; C4 c4;
valeyev 0:e056ac8fecf8 2649
valeyev 0:e056ac8fecf8 2650 context54(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
valeyev 0:e056ac8fecf8 2651 : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {}
valeyev 0:e056ac8fecf8 2652
valeyev 0:e056ac8fecf8 2653 void operator()(A0 a0, A1 a1, A2 a2, A3 a3) {
valeyev 0:e056ac8fecf8 2654 f(c0, c1, c2, c3, c4, a0, a1, a2, a3);
valeyev 0:e056ac8fecf8 2655 }
valeyev 0:e056ac8fecf8 2656 };
valeyev 0:e056ac8fecf8 2657
valeyev 0:e056ac8fecf8 2658 template <typename F, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2659 struct context05 {
valeyev 0:e056ac8fecf8 2660 F f;
valeyev 0:e056ac8fecf8 2661
valeyev 0:e056ac8fecf8 2662 context05(F f)
valeyev 0:e056ac8fecf8 2663 : f(f) {}
valeyev 0:e056ac8fecf8 2664
valeyev 0:e056ac8fecf8 2665 void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
valeyev 0:e056ac8fecf8 2666 f(a0, a1, a2, a3, a4);
valeyev 0:e056ac8fecf8 2667 }
valeyev 0:e056ac8fecf8 2668 };
valeyev 0:e056ac8fecf8 2669
valeyev 0:e056ac8fecf8 2670 template <typename F, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2671 struct context15 {
valeyev 0:e056ac8fecf8 2672 F f; C0 c0;
valeyev 0:e056ac8fecf8 2673
valeyev 0:e056ac8fecf8 2674 context15(F f, C0 c0)
valeyev 0:e056ac8fecf8 2675 : f(f), c0(c0) {}
valeyev 0:e056ac8fecf8 2676
valeyev 0:e056ac8fecf8 2677 void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
valeyev 0:e056ac8fecf8 2678 f(c0, a0, a1, a2, a3, a4);
valeyev 0:e056ac8fecf8 2679 }
valeyev 0:e056ac8fecf8 2680 };
valeyev 0:e056ac8fecf8 2681
valeyev 0:e056ac8fecf8 2682 template <typename F, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2683 struct context25 {
valeyev 0:e056ac8fecf8 2684 F f; C0 c0; C1 c1;
valeyev 0:e056ac8fecf8 2685
valeyev 0:e056ac8fecf8 2686 context25(F f, C0 c0, C1 c1)
valeyev 0:e056ac8fecf8 2687 : f(f), c0(c0), c1(c1) {}
valeyev 0:e056ac8fecf8 2688
valeyev 0:e056ac8fecf8 2689 void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
valeyev 0:e056ac8fecf8 2690 f(c0, c1, a0, a1, a2, a3, a4);
valeyev 0:e056ac8fecf8 2691 }
valeyev 0:e056ac8fecf8 2692 };
valeyev 0:e056ac8fecf8 2693
valeyev 0:e056ac8fecf8 2694 template <typename F, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2695 struct context35 {
valeyev 0:e056ac8fecf8 2696 F f; C0 c0; C1 c1; C2 c2;
valeyev 0:e056ac8fecf8 2697
valeyev 0:e056ac8fecf8 2698 context35(F f, C0 c0, C1 c1, C2 c2)
valeyev 0:e056ac8fecf8 2699 : f(f), c0(c0), c1(c1), c2(c2) {}
valeyev 0:e056ac8fecf8 2700
valeyev 0:e056ac8fecf8 2701 void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
valeyev 0:e056ac8fecf8 2702 f(c0, c1, c2, a0, a1, a2, a3, a4);
valeyev 0:e056ac8fecf8 2703 }
valeyev 0:e056ac8fecf8 2704 };
valeyev 0:e056ac8fecf8 2705
valeyev 0:e056ac8fecf8 2706 template <typename F, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2707 struct context45 {
valeyev 0:e056ac8fecf8 2708 F f; C0 c0; C1 c1; C2 c2; C3 c3;
valeyev 0:e056ac8fecf8 2709
valeyev 0:e056ac8fecf8 2710 context45(F f, C0 c0, C1 c1, C2 c2, C3 c3)
valeyev 0:e056ac8fecf8 2711 : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {}
valeyev 0:e056ac8fecf8 2712
valeyev 0:e056ac8fecf8 2713 void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
valeyev 0:e056ac8fecf8 2714 f(c0, c1, c2, c3, a0, a1, a2, a3, a4);
valeyev 0:e056ac8fecf8 2715 }
valeyev 0:e056ac8fecf8 2716 };
valeyev 0:e056ac8fecf8 2717
valeyev 0:e056ac8fecf8 2718 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2719 struct context55 {
valeyev 0:e056ac8fecf8 2720 F f; C0 c0; C1 c1; C2 c2; C3 c3; C4 c4;
valeyev 0:e056ac8fecf8 2721
valeyev 0:e056ac8fecf8 2722 context55(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
valeyev 0:e056ac8fecf8 2723 : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {}
valeyev 0:e056ac8fecf8 2724
valeyev 0:e056ac8fecf8 2725 void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
valeyev 0:e056ac8fecf8 2726 f(c0, c1, c2, c3, c4, a0, a1, a2, a3, a4);
valeyev 0:e056ac8fecf8 2727 }
valeyev 0:e056ac8fecf8 2728 };
valeyev 0:e056ac8fecf8 2729 };
valeyev 0:e056ac8fecf8 2730
valeyev 0:e056ac8fecf8 2731 }
valeyev 0:e056ac8fecf8 2732
valeyev 0:e056ac8fecf8 2733 #endif
valeyev 0:e056ac8fecf8 2734