Kev Mann / mbed-dev-OS5_10_4

RTC auf true

events/EventQueue.h@2:7aab896b1a3b, 2019-03-13 (annotated)

Committer:
kevman
Date:
Wed Mar 13 11:03:24 2019 +0000
Revision:
2:7aab896b1a3b
Parent:
0:38ceb79fef03 
2019-03-13

Who changed what in which revision?

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