Embed:
(wiki syntax)
Show/hide line numbers
EventQueue.h
00001 /* events 00002 * Copyright (c) 2016 ARM Limited 00003 * 00004 * Licensed under the Apache License, Version 2.0 (the "License"); 00005 * you may not use this file except in compliance with the License. 00006 * You may obtain a copy of the License at 00007 * 00008 * http://www.apache.org/licenses/LICENSE-2.0 00009 * 00010 * Unless required by applicable law or agreed to in writing, software 00011 * distributed under the License is distributed on an "AS IS" BASIS, 00012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 00013 * See the License for the specific language governing permissions and 00014 * limitations under the License. 00015 */ 00016 00017 #ifndef EVENT_QUEUE_H 00018 #define EVENT_QUEUE_H 00019 00020 #include "equeue/equeue.h" 00021 #include "platform/Callback.h" 00022 #include "platform/NonCopyable.h" 00023 #include <cstddef> 00024 #include <new> 00025 00026 namespace events { 00027 /** \addtogroup events */ 00028 00029 /** EVENTS_EVENT_SIZE 00030 * Minimum size of an event 00031 * This size fits a Callback<void()> at minimum 00032 */ 00033 #define EVENTS_EVENT_SIZE \ 00034 (EQUEUE_EVENT_SIZE - 2*sizeof(void*) + sizeof(mbed::Callback<void()>)) 00035 00036 /** EVENTS_QUEUE_SIZE 00037 * Default size of buffer for events 00038 */ 00039 #define EVENTS_QUEUE_SIZE (32*EVENTS_EVENT_SIZE) 00040 00041 // Predeclared classes 00042 template <typename F> 00043 class Event; 00044 00045 00046 /** EventQueue 00047 * 00048 * Flexible event queue for dispatching events 00049 * @ingroup events 00050 */ 00051 class EventQueue : private mbed::NonCopyable<EventQueue> { 00052 public: 00053 /** Create an EventQueue 00054 * 00055 * Create an event queue. The event queue either allocates a buffer of 00056 * the specified size with malloc or uses the user provided buffer. 00057 * 00058 * @param size Size of buffer to use for events in bytes 00059 * (default to EVENTS_QUEUE_SIZE) 00060 * @param buffer Pointer to buffer to use for events 00061 * (default to NULL) 00062 */ 00063 EventQueue(unsigned size=EVENTS_QUEUE_SIZE, unsigned char *buffer=NULL); 00064 00065 /** Destroy an EventQueue 00066 */ 00067 ~EventQueue(); 00068 00069 /** Dispatch events 00070 * 00071 * Executes events until the specified milliseconds have passed. 00072 * If ms is negative, the dispatch function will dispatch events 00073 * indefinitely or until break_dispatch is called on this queue. 00074 * 00075 * When called with a finite timeout, the dispatch function is guaranteed 00076 * to terminate. When called with a timeout of 0, the dispatch function 00077 * does not wait and is irq safe. 00078 * 00079 * @param ms Time to wait for events in milliseconds, a negative 00080 * value will dispatch events indefinitely 00081 * (default to -1) 00082 */ 00083 void dispatch(int ms=-1); 00084 00085 /** Dispatch events without a timeout 00086 * 00087 * This is equivalent to EventQueue::dispatch with no arguments, but 00088 * avoids overload ambiguities when passed as a callback. 00089 * 00090 * @see EventQueue::dispatch 00091 */ 00092 void dispatch_forever() { dispatch(); } 00093 00094 /** Break out of a running event loop 00095 * 00096 * Forces the specified event queue's dispatch loop to terminate. Pending 00097 * events may finish executing, but no new events will be executed. 00098 */ 00099 void break_dispatch(); 00100 00101 /** Millisecond counter 00102 * 00103 * Returns the underlying tick of the event queue represented as the 00104 * number of milliseconds that have passed since an arbitrary point in 00105 * time. Intentionally overflows to 0 after 2^32-1. 00106 * 00107 * @return The underlying tick of the event queue in milliseconds 00108 */ 00109 unsigned tick(); 00110 00111 /** Cancel an in-flight event 00112 * 00113 * Attempts to cancel an event referenced by the unique id returned from 00114 * one of the call functions. It is safe to call cancel after an event 00115 * has already been dispatched. 00116 * 00117 * The cancel function is irq safe. 00118 * 00119 * If called while the event queue's dispatch loop is active, the cancel 00120 * function does not guarantee that the event will not execute after it 00121 * returns, as the event may have already begun executing. 00122 * 00123 * @param id Unique id of the event 00124 */ 00125 void cancel(int id); 00126 00127 /** Background an event queue onto a single-shot timer-interrupt 00128 * 00129 * When updated, the event queue will call the provided update function 00130 * with a timeout indicating when the queue should be dispatched. A 00131 * negative timeout will be passed to the update function when the 00132 * timer-interrupt is no longer needed. 00133 * 00134 * Passing a null function disables the existing update function. 00135 * 00136 * The background function allows an event queue to take advantage of 00137 * hardware timers or other event loops, allowing an event queue to be 00138 * ran in the background without consuming the foreground thread. 00139 * 00140 * @param update Function called to indicate when the queue should be 00141 * dispatched 00142 */ 00143 void background(mbed::Callback<void(int)> update); 00144 00145 /** Chain an event queue onto another event queue 00146 * 00147 * After chaining a queue to a target, calling dispatch on the target 00148 * queue will also dispatch events from this queue. The queues use 00149 * their own buffers and events must be handled independently. 00150 * 00151 * A null queue as the target will unchain the existing queue. 00152 * 00153 * The chain function allows multiple event queues to be composed, 00154 * sharing the context of a dispatch loop while still being managed 00155 * independently 00156 * 00157 * @param target Queue that will dispatch this queue's events as a 00158 * part of its dispatch loop 00159 */ 00160 void chain(EventQueue *target); 00161 00162 /** Calls an event on the queue 00163 * 00164 * The specified callback will be executed in the context of the event 00165 * queue's dispatch loop. 00166 * 00167 * The call function is irq safe and can act as a mechanism for moving 00168 * events out of irq contexts. 00169 * 00170 * @param f Function to execute in the context of the dispatch loop 00171 * @return A unique id that represents the posted event and can 00172 * be passed to cancel, or an id of 0 if there is not 00173 * enough memory to allocate the event. 00174 */ 00175 template <typename F> 00176 int call(F f) { 00177 void *p = equeue_alloc(&_equeue, sizeof(F)); 00178 if (!p) { 00179 return 0; 00180 } 00181 00182 F *e = new (p) F(f); 00183 equeue_event_dtor(e, &EventQueue::function_dtor<F>); 00184 return equeue_post(&_equeue, &EventQueue::function_call<F>, e); 00185 } 00186 00187 /** Calls an event on the queue 00188 * @see EventQueue::call 00189 * @param f Function to execute in the context of the dispatch loop 00190 * @param a0 Argument to pass to the callback 00191 */ 00192 template <typename F, typename A0> 00193 int call(F f, A0 a0) { 00194 return call(context10<F, A0>(f, a0)); 00195 } 00196 00197 /** Calls an event on the queue 00198 * @see EventQueue::call 00199 * @param f Function to execute in the context of the dispatch loop 00200 * @param a0,a1 Arguments to pass to the callback 00201 */ 00202 template <typename F, typename A0, typename A1> 00203 int call(F f, A0 a0, A1 a1) { 00204 return call(context20<F, A0, A1>(f, a0, a1)); 00205 } 00206 00207 /** Calls an event on the queue 00208 * @see EventQueue::call 00209 * @param f Function to execute in the context of the dispatch loop 00210 * @param a0,a1,a2 Arguments to pass to the callback 00211 */ 00212 template <typename F, typename A0, typename A1, typename A2> 00213 int call(F f, A0 a0, A1 a1, A2 a2) { 00214 return call(context30<F, A0, A1, A2>(f, a0, a1, a2)); 00215 } 00216 00217 /** Calls an event on the queue 00218 * @see EventQueue::call 00219 * @param f Function to execute in the context of the dispatch loop 00220 * @param a0,a1,a2,a3 Arguments to pass to the callback 00221 */ 00222 template <typename F, typename A0, typename A1, typename A2, typename A3> 00223 int call(F f, A0 a0, A1 a1, A2 a2, A3 a3) { 00224 return call(context40<F, A0, A1, A2, A3>(f, a0, a1, a2, a3)); 00225 } 00226 00227 /** Calls an event on the queue 00228 * @see EventQueue::call 00229 * @param f Function to execute in the context of the dispatch loop 00230 * @param a0,a1,a2,a3,a4 Arguments to pass to the callback 00231 */ 00232 template <typename F, typename A0, typename A1, typename A2, typename A3, typename A4> 00233 int call(F f, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 00234 return call(context50<F, A0, A1, A2, A3, A4>(f, a0, a1, a2, a3, a4)); 00235 } 00236 00237 /** Calls an event on the queue 00238 * @see EventQueue::call 00239 */ 00240 template <typename T, typename R> 00241 int call(T *obj, R (T::*method)()) { 00242 return call(mbed::callback(obj, method)); 00243 } 00244 00245 /** Calls an event on the queue 00246 * @see EventQueue::call 00247 */ 00248 template <typename T, typename R> 00249 int call(const T *obj, R (T::*method)() const) { 00250 return call(mbed::callback(obj, method)); 00251 } 00252 00253 /** Calls an event on the queue 00254 * @see EventQueue::call 00255 */ 00256 template <typename T, typename R> 00257 int call(volatile T *obj, R (T::*method)() volatile) { 00258 return call(mbed::callback(obj, method)); 00259 } 00260 00261 /** Calls an event on the queue 00262 * @see EventQueue::call 00263 */ 00264 template <typename T, typename R> 00265 int call(const volatile T *obj, R (T::*method)() const volatile) { 00266 return call(mbed::callback(obj, method)); 00267 } 00268 00269 /** Calls an event on the queue 00270 * @see EventQueue::call 00271 */ 00272 template <typename T, typename R, typename A0> 00273 int call(T *obj, R (T::*method)(A0), A0 a0) { 00274 return call(mbed::callback(obj, method), a0); 00275 } 00276 00277 /** Calls an event on the queue 00278 * @see EventQueue::call 00279 */ 00280 template <typename T, typename R, typename A0> 00281 int call(const T *obj, R (T::*method)(A0) const, A0 a0) { 00282 return call(mbed::callback(obj, method), a0); 00283 } 00284 00285 /** Calls an event on the queue 00286 * @see EventQueue::call 00287 */ 00288 template <typename T, typename R, typename A0> 00289 int call(volatile T *obj, R (T::*method)(A0) volatile, A0 a0) { 00290 return call(mbed::callback(obj, method), a0); 00291 } 00292 00293 /** Calls an event on the queue 00294 * @see EventQueue::call 00295 */ 00296 template <typename T, typename R, typename A0> 00297 int call(const volatile T *obj, R (T::*method)(A0) const volatile, A0 a0) { 00298 return call(mbed::callback(obj, method), a0); 00299 } 00300 00301 /** Calls an event on the queue 00302 * @see EventQueue::call 00303 */ 00304 template <typename T, typename R, typename A0, typename A1> 00305 int call(T *obj, R (T::*method)(A0, A1), A0 a0, A1 a1) { 00306 return call(mbed::callback(obj, method), a0, a1); 00307 } 00308 00309 /** Calls an event on the queue 00310 * @see EventQueue::call 00311 */ 00312 template <typename T, typename R, typename A0, typename A1> 00313 int call(const T *obj, R (T::*method)(A0, A1) const, A0 a0, A1 a1) { 00314 return call(mbed::callback(obj, method), a0, a1); 00315 } 00316 00317 /** Calls an event on the queue 00318 * @see EventQueue::call 00319 */ 00320 template <typename T, typename R, typename A0, typename A1> 00321 int call(volatile T *obj, R (T::*method)(A0, A1) volatile, A0 a0, A1 a1) { 00322 return call(mbed::callback(obj, method), a0, a1); 00323 } 00324 00325 /** Calls an event on the queue 00326 * @see EventQueue::call 00327 */ 00328 template <typename T, typename R, typename A0, typename A1> 00329 int call(const volatile T *obj, R (T::*method)(A0, A1) const volatile, A0 a0, A1 a1) { 00330 return call(mbed::callback(obj, method), a0, a1); 00331 } 00332 00333 /** Calls an event on the queue 00334 * @see EventQueue::call 00335 */ 00336 template <typename T, typename R, typename A0, typename A1, typename A2> 00337 int call(T *obj, R (T::*method)(A0, A1, A2), A0 a0, A1 a1, A2 a2) { 00338 return call(mbed::callback(obj, method), a0, a1, a2); 00339 } 00340 00341 /** Calls an event on the queue 00342 * @see EventQueue::call 00343 */ 00344 template <typename T, typename R, typename A0, typename A1, typename A2> 00345 int call(const T *obj, R (T::*method)(A0, A1, A2) const, A0 a0, A1 a1, A2 a2) { 00346 return call(mbed::callback(obj, method), a0, a1, a2); 00347 } 00348 00349 /** Calls an event on the queue 00350 * @see EventQueue::call 00351 */ 00352 template <typename T, typename R, typename A0, typename A1, typename A2> 00353 int call(volatile T *obj, R (T::*method)(A0, A1, A2) volatile, A0 a0, A1 a1, A2 a2) { 00354 return call(mbed::callback(obj, method), a0, a1, a2); 00355 } 00356 00357 /** Calls an event on the queue 00358 * @see EventQueue::call 00359 */ 00360 template <typename T, typename R, typename A0, typename A1, typename A2> 00361 int call(const volatile T *obj, R (T::*method)(A0, A1, A2) const volatile, A0 a0, A1 a1, A2 a2) { 00362 return call(mbed::callback(obj, method), a0, a1, a2); 00363 } 00364 00365 /** Calls an event on the queue 00366 * @see EventQueue::call 00367 */ 00368 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 00369 int call(T *obj, R (T::*method)(A0, A1, A2, A3), A0 a0, A1 a1, A2 a2, A3 a3) { 00370 return call(mbed::callback(obj, method), a0, a1, a2, a3); 00371 } 00372 00373 /** Calls an event on the queue 00374 * @see EventQueue::call 00375 */ 00376 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 00377 int call(const T *obj, R (T::*method)(A0, A1, A2, A3) const, A0 a0, A1 a1, A2 a2, A3 a3) { 00378 return call(mbed::callback(obj, method), a0, a1, a2, a3); 00379 } 00380 00381 /** Calls an event on the queue 00382 * @see EventQueue::call 00383 */ 00384 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 00385 int call(volatile T *obj, R (T::*method)(A0, A1, A2, A3) volatile, A0 a0, A1 a1, A2 a2, A3 a3) { 00386 return call(mbed::callback(obj, method), a0, a1, a2, a3); 00387 } 00388 00389 /** Calls an event on the queue 00390 * @see EventQueue::call 00391 */ 00392 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 00393 int call(const volatile T *obj, R (T::*method)(A0, A1, A2, A3) const volatile, A0 a0, A1 a1, A2 a2, A3 a3) { 00394 return call(mbed::callback(obj, method), a0, a1, a2, a3); 00395 } 00396 00397 /** Calls an event on the queue 00398 * @see EventQueue::call 00399 */ 00400 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 00401 int call(T *obj, R (T::*method)(A0, A1, A2, A3, A4), A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 00402 return call(mbed::callback(obj, method), a0, a1, a2, a3, a4); 00403 } 00404 00405 /** Calls an event on the queue 00406 * @see EventQueue::call 00407 */ 00408 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 00409 int call(const T *obj, R (T::*method)(A0, A1, A2, A3, A4) const, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 00410 return call(mbed::callback(obj, method), a0, a1, a2, a3, a4); 00411 } 00412 00413 /** Calls an event on the queue 00414 * @see EventQueue::call 00415 */ 00416 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 00417 int call(volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) volatile, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 00418 return call(mbed::callback(obj, method), a0, a1, a2, a3, a4); 00419 } 00420 00421 /** Calls an event on the queue 00422 * @see EventQueue::call 00423 */ 00424 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 00425 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) { 00426 return call(mbed::callback(obj, method), a0, a1, a2, a3, a4); 00427 } 00428 00429 /** Calls an event on the queue after a specified delay 00430 * 00431 * The specified callback will be executed in the context of the event 00432 * queue's dispatch loop. 00433 * 00434 * The call_in function is irq safe and can act as a mechanism for moving 00435 * events out of irq contexts. 00436 * 00437 * @param f Function to execute in the context of the dispatch loop 00438 * @param ms Time to delay in milliseconds 00439 * @return A unique id that represents the posted event and can 00440 * be passed to cancel, or an id of 0 if there is not 00441 * enough memory to allocate the event. 00442 */ 00443 template <typename F> 00444 int call_in(int ms, F f) { 00445 void *p = equeue_alloc(&_equeue, sizeof(F)); 00446 if (!p) { 00447 return 0; 00448 } 00449 00450 F *e = new (p) F(f); 00451 equeue_event_delay(e, ms); 00452 equeue_event_dtor(e, &EventQueue::function_dtor<F>); 00453 return equeue_post(&_equeue, &EventQueue::function_call<F>, e); 00454 } 00455 00456 /** Calls an event on the queue after a specified delay 00457 * @see EventQueue::call_in 00458 * @param ms Time to delay in milliseconds 00459 * @param f Function to execute in the context of the dispatch loop 00460 * @param a0 Argument to pass to the callback 00461 */ 00462 template <typename F, typename A0> 00463 int call_in(int ms, F f, A0 a0) { 00464 return call_in(ms, context10<F, A0>(f, a0)); 00465 } 00466 00467 /** Calls an event on the queue after a specified delay 00468 * @see EventQueue::call_in 00469 * @param ms Time to delay in milliseconds 00470 * @param f Function to execute in the context of the dispatch loop 00471 * @param a0,a1 Arguments to pass to the callback 00472 */ 00473 template <typename F, typename A0, typename A1> 00474 int call_in(int ms, F f, A0 a0, A1 a1) { 00475 return call_in(ms, context20<F, A0, A1>(f, a0, a1)); 00476 } 00477 00478 /** Calls an event on the queue after a specified delay 00479 * @see EventQueue::call_in 00480 * @param ms Time to delay in milliseconds 00481 * @param f Function to execute in the context of the dispatch loop 00482 * @param a0,a1,a2 Arguments to pass to the callback 00483 */ 00484 template <typename F, typename A0, typename A1, typename A2> 00485 int call_in(int ms, F f, A0 a0, A1 a1, A2 a2) { 00486 return call_in(ms, context30<F, A0, A1, A2>(f, a0, a1, a2)); 00487 } 00488 00489 /** Calls an event on the queue after a specified delay 00490 * @see EventQueue::call_in 00491 * @param ms Time to delay in milliseconds 00492 * @param f Function to execute in the context of the dispatch loop 00493 * @param a0,a1,a2,a3 Arguments to pass to the callback 00494 */ 00495 template <typename F, typename A0, typename A1, typename A2, typename A3> 00496 int call_in(int ms, F f, A0 a0, A1 a1, A2 a2, A3 a3) { 00497 return call_in(ms, context40<F, A0, A1, A2, A3>(f, a0, a1, a2, a3)); 00498 } 00499 00500 /** Calls an event on the queue after a specified delay 00501 * @see EventQueue::call_in 00502 * @param ms Time to delay in milliseconds 00503 * @param f Function to execute in the context of the dispatch loop 00504 * @param a0,a1,a2,a3,a4 Arguments to pass to the callback 00505 */ 00506 template <typename F, typename A0, typename A1, typename A2, typename A3, typename A4> 00507 int call_in(int ms, F f, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 00508 return call_in(ms, context50<F, A0, A1, A2, A3, A4>(f, a0, a1, a2, a3, a4)); 00509 } 00510 00511 /** Calls an event on the queue after a specified delay 00512 * @see EventQueue::call_in 00513 */ 00514 template <typename T, typename R> 00515 int call_in(int ms, T *obj, R (T::*method)()) { 00516 return call_in(ms, mbed::callback(obj, method)); 00517 } 00518 00519 /** Calls an event on the queue after a specified delay 00520 * @see EventQueue::call_in 00521 */ 00522 template <typename T, typename R> 00523 int call_in(int ms, const T *obj, R (T::*method)() const) { 00524 return call_in(ms, mbed::callback(obj, method)); 00525 } 00526 00527 /** Calls an event on the queue after a specified delay 00528 * @see EventQueue::call_in 00529 */ 00530 template <typename T, typename R> 00531 int call_in(int ms, volatile T *obj, R (T::*method)() volatile) { 00532 return call_in(ms, mbed::callback(obj, method)); 00533 } 00534 00535 /** Calls an event on the queue after a specified delay 00536 * @see EventQueue::call_in 00537 */ 00538 template <typename T, typename R> 00539 int call_in(int ms, const volatile T *obj, R (T::*method)() const volatile) { 00540 return call_in(ms, mbed::callback(obj, method)); 00541 } 00542 00543 /** Calls an event on the queue after a specified delay 00544 * @see EventQueue::call_in 00545 */ 00546 template <typename T, typename R, typename A0> 00547 int call_in(int ms, T *obj, R (T::*method)(A0), A0 a0) { 00548 return call_in(ms, mbed::callback(obj, method), a0); 00549 } 00550 00551 /** Calls an event on the queue after a specified delay 00552 * @see EventQueue::call_in 00553 */ 00554 template <typename T, typename R, typename A0> 00555 int call_in(int ms, const T *obj, R (T::*method)(A0) const, A0 a0) { 00556 return call_in(ms, mbed::callback(obj, method), a0); 00557 } 00558 00559 /** Calls an event on the queue after a specified delay 00560 * @see EventQueue::call_in 00561 */ 00562 template <typename T, typename R, typename A0> 00563 int call_in(int ms, volatile T *obj, R (T::*method)(A0) volatile, A0 a0) { 00564 return call_in(ms, mbed::callback(obj, method), a0); 00565 } 00566 00567 /** Calls an event on the queue after a specified delay 00568 * @see EventQueue::call_in 00569 */ 00570 template <typename T, typename R, typename A0> 00571 int call_in(int ms, const volatile T *obj, R (T::*method)(A0) const volatile, A0 a0) { 00572 return call_in(ms, mbed::callback(obj, method), a0); 00573 } 00574 00575 /** Calls an event on the queue after a specified delay 00576 * @see EventQueue::call_in 00577 */ 00578 template <typename T, typename R, typename A0, typename A1> 00579 int call_in(int ms, T *obj, R (T::*method)(A0, A1), A0 a0, A1 a1) { 00580 return call_in(ms, mbed::callback(obj, method), a0, a1); 00581 } 00582 00583 /** Calls an event on the queue after a specified delay 00584 * @see EventQueue::call_in 00585 */ 00586 template <typename T, typename R, typename A0, typename A1> 00587 int call_in(int ms, const T *obj, R (T::*method)(A0, A1) const, A0 a0, A1 a1) { 00588 return call_in(ms, mbed::callback(obj, method), a0, a1); 00589 } 00590 00591 /** Calls an event on the queue after a specified delay 00592 * @see EventQueue::call_in 00593 */ 00594 template <typename T, typename R, typename A0, typename A1> 00595 int call_in(int ms, volatile T *obj, R (T::*method)(A0, A1) volatile, A0 a0, A1 a1) { 00596 return call_in(ms, mbed::callback(obj, method), a0, a1); 00597 } 00598 00599 /** Calls an event on the queue after a specified delay 00600 * @see EventQueue::call_in 00601 */ 00602 template <typename T, typename R, typename A0, typename A1> 00603 int call_in(int ms, const volatile T *obj, R (T::*method)(A0, A1) const volatile, A0 a0, A1 a1) { 00604 return call_in(ms, mbed::callback(obj, method), a0, a1); 00605 } 00606 00607 /** Calls an event on the queue after a specified delay 00608 * @see EventQueue::call_in 00609 */ 00610 template <typename T, typename R, typename A0, typename A1, typename A2> 00611 int call_in(int ms, T *obj, R (T::*method)(A0, A1, A2), A0 a0, A1 a1, A2 a2) { 00612 return call_in(ms, mbed::callback(obj, method), a0, a1, a2); 00613 } 00614 00615 /** Calls an event on the queue after a specified delay 00616 * @see EventQueue::call_in 00617 */ 00618 template <typename T, typename R, typename A0, typename A1, typename A2> 00619 int call_in(int ms, const T *obj, R (T::*method)(A0, A1, A2) const, A0 a0, A1 a1, A2 a2) { 00620 return call_in(ms, mbed::callback(obj, method), a0, a1, a2); 00621 } 00622 00623 /** Calls an event on the queue after a specified delay 00624 * @see EventQueue::call_in 00625 */ 00626 template <typename T, typename R, typename A0, typename A1, typename A2> 00627 int call_in(int ms, volatile T *obj, R (T::*method)(A0, A1, A2) volatile, A0 a0, A1 a1, A2 a2) { 00628 return call_in(ms, mbed::callback(obj, method), a0, a1, a2); 00629 } 00630 00631 /** Calls an event on the queue after a specified delay 00632 * @see EventQueue::call_in 00633 */ 00634 template <typename T, typename R, typename A0, typename A1, typename A2> 00635 int call_in(int ms, const volatile T *obj, R (T::*method)(A0, A1, A2) const volatile, A0 a0, A1 a1, A2 a2) { 00636 return call_in(ms, mbed::callback(obj, method), a0, a1, a2); 00637 } 00638 00639 /** Calls an event on the queue after a specified delay 00640 * @see EventQueue::call_in 00641 */ 00642 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 00643 int call_in(int ms, T *obj, R (T::*method)(A0, A1, A2, A3), A0 a0, A1 a1, A2 a2, A3 a3) { 00644 return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3); 00645 } 00646 00647 /** Calls an event on the queue after a specified delay 00648 * @see EventQueue::call_in 00649 */ 00650 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 00651 int call_in(int ms, const T *obj, R (T::*method)(A0, A1, A2, A3) const, A0 a0, A1 a1, A2 a2, A3 a3) { 00652 return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3); 00653 } 00654 00655 /** Calls an event on the queue after a specified delay 00656 * @see EventQueue::call_in 00657 */ 00658 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 00659 int call_in(int ms, volatile T *obj, R (T::*method)(A0, A1, A2, A3) volatile, A0 a0, A1 a1, A2 a2, A3 a3) { 00660 return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3); 00661 } 00662 00663 /** Calls an event on the queue after a specified delay 00664 * @see EventQueue::call_in 00665 */ 00666 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 00667 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) { 00668 return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3); 00669 } 00670 00671 /** Calls an event on the queue after a specified delay 00672 * @see EventQueue::call_in 00673 */ 00674 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 00675 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) { 00676 return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4); 00677 } 00678 00679 /** Calls an event on the queue after a specified delay 00680 * @see EventQueue::call_in 00681 */ 00682 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 00683 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) { 00684 return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4); 00685 } 00686 00687 /** Calls an event on the queue after a specified delay 00688 * @see EventQueue::call_in 00689 */ 00690 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 00691 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) { 00692 return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4); 00693 } 00694 00695 /** Calls an event on the queue after a specified delay 00696 * @see EventQueue::call_in 00697 */ 00698 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 00699 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) { 00700 return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4); 00701 } 00702 00703 /** Calls an event on the queue periodically 00704 * 00705 * @note The first call_every event occurs after the specified delay. 00706 * To create a periodic event that fires immediately, @see Event. 00707 * 00708 * The specified callback will be executed in the context of the event 00709 * queue's dispatch loop. 00710 * 00711 * The call_every function is irq safe and can act as a mechanism for 00712 * moving events out of irq contexts. 00713 * 00714 * @param f Function to execute in the context of the dispatch loop 00715 * @param ms Period of the event in milliseconds 00716 * @return A unique id that represents the posted event and can 00717 * be passed to cancel, or an id of 0 if there is not 00718 * enough memory to allocate the event. 00719 */ 00720 template <typename F> 00721 int call_every(int ms, F f) { 00722 void *p = equeue_alloc(&_equeue, sizeof(F)); 00723 if (!p) { 00724 return 0; 00725 } 00726 00727 F *e = new (p) F(f); 00728 equeue_event_delay(e, ms); 00729 equeue_event_period(e, ms); 00730 equeue_event_dtor(e, &EventQueue::function_dtor<F>); 00731 return equeue_post(&_equeue, &EventQueue::function_call<F>, e); 00732 } 00733 00734 /** Calls an event on the queue periodically 00735 * @see EventQueue::call_every 00736 * @param f Function to execute in the context of the dispatch loop 00737 * @param a0 Argument to pass to the callback 00738 * @param ms Period of the event in milliseconds 00739 */ 00740 template <typename F, typename A0> 00741 int call_every(int ms, F f, A0 a0) { 00742 return call_every(ms, context10<F, A0>(f, a0)); 00743 } 00744 00745 /** Calls an event on the queue periodically 00746 * @see EventQueue::call_every 00747 * @param f Function to execute in the context of the dispatch loop 00748 * @param a0,a1 Arguments to pass to the callback 00749 * @param ms Period of the event in milliseconds 00750 */ 00751 template <typename F, typename A0, typename A1> 00752 int call_every(int ms, F f, A0 a0, A1 a1) { 00753 return call_every(ms, context20<F, A0, A1>(f, a0, a1)); 00754 } 00755 00756 /** Calls an event on the queue periodically 00757 * @see EventQueue::call_every 00758 * @param f Function to execute in the context of the dispatch loop 00759 * @param a0,a1,a2 Arguments to pass to the callback 00760 * @param ms Period of the event in milliseconds 00761 */ 00762 template <typename F, typename A0, typename A1, typename A2> 00763 int call_every(int ms, F f, A0 a0, A1 a1, A2 a2) { 00764 return call_every(ms, context30<F, A0, A1, A2>(f, a0, a1, a2)); 00765 } 00766 00767 /** Calls an event on the queue periodically 00768 * @see EventQueue::call_every 00769 * @param f Function to execute in the context of the dispatch loop 00770 * @param a0,a1,a2,a3 Arguments to pass to the callback 00771 * @param ms Period of the event in milliseconds 00772 */ 00773 template <typename F, typename A0, typename A1, typename A2, typename A3> 00774 int call_every(int ms, F f, A0 a0, A1 a1, A2 a2, A3 a3) { 00775 return call_every(ms, context40<F, A0, A1, A2, A3>(f, a0, a1, a2, a3)); 00776 } 00777 00778 /** Calls an event on the queue periodically 00779 * @see EventQueue::call_every 00780 * @param f Function to execute in the context of the dispatch loop 00781 * @param a0,a1,a2,a3,a4 Arguments to pass to the callback 00782 * @param ms Period of the event in milliseconds 00783 */ 00784 template <typename F, typename A0, typename A1, typename A2, typename A3, typename A4> 00785 int call_every(int ms, F f, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 00786 return call_every(ms, context50<F, A0, A1, A2, A3, A4>(f, a0, a1, a2, a3, a4)); 00787 } 00788 00789 /** Calls an event on the queue periodically 00790 * @see EventQueue::call_every 00791 */ 00792 template <typename T, typename R> 00793 int call_every(int ms, T *obj, R (T::*method)()) { 00794 return call_every(ms, mbed::callback(obj, method)); 00795 } 00796 00797 /** Calls an event on the queue periodically 00798 * @see EventQueue::call_every 00799 */ 00800 template <typename T, typename R> 00801 int call_every(int ms, const T *obj, R (T::*method)() const) { 00802 return call_every(ms, mbed::callback(obj, method)); 00803 } 00804 00805 /** Calls an event on the queue periodically 00806 * @see EventQueue::call_every 00807 */ 00808 template <typename T, typename R> 00809 int call_every(int ms, volatile T *obj, R (T::*method)() volatile) { 00810 return call_every(ms, mbed::callback(obj, method)); 00811 } 00812 00813 /** Calls an event on the queue periodically 00814 * @see EventQueue::call_every 00815 */ 00816 template <typename T, typename R> 00817 int call_every(int ms, const volatile T *obj, R (T::*method)() const volatile) { 00818 return call_every(ms, mbed::callback(obj, method)); 00819 } 00820 00821 /** Calls an event on the queue periodically 00822 * @see EventQueue::call_every 00823 */ 00824 template <typename T, typename R, typename A0> 00825 int call_every(int ms, T *obj, R (T::*method)(A0), A0 a0) { 00826 return call_every(ms, mbed::callback(obj, method), a0); 00827 } 00828 00829 /** Calls an event on the queue periodically 00830 * @see EventQueue::call_every 00831 */ 00832 template <typename T, typename R, typename A0> 00833 int call_every(int ms, const T *obj, R (T::*method)(A0) const, A0 a0) { 00834 return call_every(ms, mbed::callback(obj, method), a0); 00835 } 00836 00837 /** Calls an event on the queue periodically 00838 * @see EventQueue::call_every 00839 */ 00840 template <typename T, typename R, typename A0> 00841 int call_every(int ms, volatile T *obj, R (T::*method)(A0) volatile, A0 a0) { 00842 return call_every(ms, mbed::callback(obj, method), a0); 00843 } 00844 00845 /** Calls an event on the queue periodically 00846 * @see EventQueue::call_every 00847 */ 00848 template <typename T, typename R, typename A0> 00849 int call_every(int ms, const volatile T *obj, R (T::*method)(A0) const volatile, A0 a0) { 00850 return call_every(ms, mbed::callback(obj, method), a0); 00851 } 00852 00853 /** Calls an event on the queue periodically 00854 * @see EventQueue::call_every 00855 */ 00856 template <typename T, typename R, typename A0, typename A1> 00857 int call_every(int ms, T *obj, R (T::*method)(A0, A1), A0 a0, A1 a1) { 00858 return call_every(ms, mbed::callback(obj, method), a0, a1); 00859 } 00860 00861 /** Calls an event on the queue periodically 00862 * @see EventQueue::call_every 00863 */ 00864 template <typename T, typename R, typename A0, typename A1> 00865 int call_every(int ms, const T *obj, R (T::*method)(A0, A1) const, A0 a0, A1 a1) { 00866 return call_every(ms, mbed::callback(obj, method), a0, a1); 00867 } 00868 00869 /** Calls an event on the queue periodically 00870 * @see EventQueue::call_every 00871 */ 00872 template <typename T, typename R, typename A0, typename A1> 00873 int call_every(int ms, volatile T *obj, R (T::*method)(A0, A1) volatile, A0 a0, A1 a1) { 00874 return call_every(ms, mbed::callback(obj, method), a0, a1); 00875 } 00876 00877 /** Calls an event on the queue periodically 00878 * @see EventQueue::call_every 00879 */ 00880 template <typename T, typename R, typename A0, typename A1> 00881 int call_every(int ms, const volatile T *obj, R (T::*method)(A0, A1) const volatile, A0 a0, A1 a1) { 00882 return call_every(ms, mbed::callback(obj, method), a0, a1); 00883 } 00884 00885 /** Calls an event on the queue periodically 00886 * @see EventQueue::call_every 00887 */ 00888 template <typename T, typename R, typename A0, typename A1, typename A2> 00889 int call_every(int ms, T *obj, R (T::*method)(A0, A1, A2), A0 a0, A1 a1, A2 a2) { 00890 return call_every(ms, mbed::callback(obj, method), a0, a1, a2); 00891 } 00892 00893 /** Calls an event on the queue periodically 00894 * @see EventQueue::call_every 00895 */ 00896 template <typename T, typename R, typename A0, typename A1, typename A2> 00897 int call_every(int ms, const T *obj, R (T::*method)(A0, A1, A2) const, A0 a0, A1 a1, A2 a2) { 00898 return call_every(ms, mbed::callback(obj, method), a0, a1, a2); 00899 } 00900 00901 /** Calls an event on the queue periodically 00902 * @see EventQueue::call_every 00903 */ 00904 template <typename T, typename R, typename A0, typename A1, typename A2> 00905 int call_every(int ms, volatile T *obj, R (T::*method)(A0, A1, A2) volatile, A0 a0, A1 a1, A2 a2) { 00906 return call_every(ms, mbed::callback(obj, method), a0, a1, a2); 00907 } 00908 00909 /** Calls an event on the queue periodically 00910 * @see EventQueue::call_every 00911 */ 00912 template <typename T, typename R, typename A0, typename A1, typename A2> 00913 int call_every(int ms, const volatile T *obj, R (T::*method)(A0, A1, A2) const volatile, A0 a0, A1 a1, A2 a2) { 00914 return call_every(ms, mbed::callback(obj, method), a0, a1, a2); 00915 } 00916 00917 /** Calls an event on the queue periodically 00918 * @see EventQueue::call_every 00919 */ 00920 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 00921 int call_every(int ms, T *obj, R (T::*method)(A0, A1, A2, A3), A0 a0, A1 a1, A2 a2, A3 a3) { 00922 return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3); 00923 } 00924 00925 /** Calls an event on the queue periodically 00926 * @see EventQueue::call_every 00927 */ 00928 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 00929 int call_every(int ms, const T *obj, R (T::*method)(A0, A1, A2, A3) const, A0 a0, A1 a1, A2 a2, A3 a3) { 00930 return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3); 00931 } 00932 00933 /** Calls an event on the queue periodically 00934 * @see EventQueue::call_every 00935 */ 00936 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 00937 int call_every(int ms, volatile T *obj, R (T::*method)(A0, A1, A2, A3) volatile, A0 a0, A1 a1, A2 a2, A3 a3) { 00938 return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3); 00939 } 00940 00941 /** Calls an event on the queue periodically 00942 * @see EventQueue::call_every 00943 */ 00944 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 00945 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) { 00946 return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3); 00947 } 00948 00949 /** Calls an event on the queue periodically 00950 * @see EventQueue::call_every 00951 */ 00952 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 00953 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) { 00954 return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4); 00955 } 00956 00957 /** Calls an event on the queue periodically 00958 * @see EventQueue::call_every 00959 */ 00960 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 00961 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) { 00962 return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4); 00963 } 00964 00965 /** Calls an event on the queue periodically 00966 * @see EventQueue::call_every 00967 */ 00968 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 00969 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) { 00970 return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4); 00971 } 00972 00973 /** Calls an event on the queue periodically 00974 * @see EventQueue::call_every 00975 */ 00976 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 00977 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) { 00978 return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4); 00979 } 00980 00981 /** Creates an event bound to the event queue 00982 * 00983 * Constructs an event bound to the specified event queue. The specified 00984 * callback acts as the target for the event and is executed in the 00985 * context of the event queue's dispatch loop once posted. 00986 * 00987 * @param func Function to execute when the event is dispatched 00988 * @return Event that will dispatch on the specific queue 00989 */ 00990 template <typename R> 00991 Event<void()> event(R (*func)()); 00992 00993 /** Creates an event bound to the event queue 00994 * @see EventQueue::event 00995 */ 00996 template <typename T, typename R> 00997 Event<void()> event(T *obj, R (T::*method)()); 00998 00999 /** Creates an event bound to the event queue 01000 * @see EventQueue::event 01001 */ 01002 template <typename T, typename R> 01003 Event<void()> event(const T *obj, R (T::*method)() const); 01004 01005 /** Creates an event bound to the event queue 01006 * @see EventQueue::event 01007 */ 01008 template <typename T, typename R> 01009 Event<void()> event(volatile T *obj, R (T::*method)() volatile); 01010 01011 /** Creates an event bound to the event queue 01012 * @see EventQueue::event 01013 */ 01014 template <typename T, typename R> 01015 Event<void()> event(const volatile T *obj, R (T::*method)() const volatile); 01016 01017 /** Creates an event bound to the event queue 01018 * @see EventQueue::event 01019 */ 01020 template <typename R> 01021 Event<void()> event(mbed::Callback<R()> cb); 01022 01023 /** Creates an event bound to the event queue 01024 * @see EventQueue::event 01025 */ 01026 template <typename R, typename B0, typename C0> 01027 Event<void()> event(R (*func)(B0), C0 c0); 01028 01029 /** Creates an event bound to the event queue 01030 * @see EventQueue::event 01031 */ 01032 template <typename T, typename R, typename B0, typename C0> 01033 Event<void()> event(T *obj, R (T::*method)(B0), C0 c0); 01034 01035 /** Creates an event bound to the event queue 01036 * @see EventQueue::event 01037 */ 01038 template <typename T, typename R, typename B0, typename C0> 01039 Event<void()> event(const T *obj, R (T::*method)(B0) const, C0 c0); 01040 01041 /** Creates an event bound to the event queue 01042 * @see EventQueue::event 01043 */ 01044 template <typename T, typename R, typename B0, typename C0> 01045 Event<void()> event(volatile T *obj, R (T::*method)(B0) volatile, C0 c0); 01046 01047 /** Creates an event bound to the event queue 01048 * @see EventQueue::event 01049 */ 01050 template <typename T, typename R, typename B0, typename C0> 01051 Event<void()> event(const volatile T *obj, R (T::*method)(B0) const volatile, C0 c0); 01052 01053 /** Creates an event bound to the event queue 01054 * @see EventQueue::event 01055 */ 01056 template <typename R, typename B0, typename C0> 01057 Event<void()> event(mbed::Callback<R(B0)> cb, C0 c0); 01058 01059 /** Creates an event bound to the event queue 01060 * @see EventQueue::event 01061 */ 01062 template <typename R, typename B0, typename B1, typename C0, typename C1> 01063 Event<void()> event(R (*func)(B0, B1), C0 c0, C1 c1); 01064 01065 /** Creates an event bound to the event queue 01066 * @see EventQueue::event 01067 */ 01068 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1> 01069 Event<void()> event(T *obj, R (T::*method)(B0, B1), C0 c0, C1 c1); 01070 01071 /** Creates an event bound to the event queue 01072 * @see EventQueue::event 01073 */ 01074 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1> 01075 Event<void()> event(const T *obj, R (T::*method)(B0, B1) const, C0 c0, C1 c1); 01076 01077 /** Creates an event bound to the event queue 01078 * @see EventQueue::event 01079 */ 01080 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1> 01081 Event<void()> event(volatile T *obj, R (T::*method)(B0, B1) volatile, C0 c0, C1 c1); 01082 01083 /** Creates an event bound to the event queue 01084 * @see EventQueue::event 01085 */ 01086 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1> 01087 Event<void()> event(const volatile T *obj, R (T::*method)(B0, B1) const volatile, C0 c0, C1 c1); 01088 01089 /** Creates an event bound to the event queue 01090 * @see EventQueue::event 01091 */ 01092 template <typename R, typename B0, typename B1, typename C0, typename C1> 01093 Event<void()> event(mbed::Callback<R(B0, B1)> cb, C0 c0, C1 c1); 01094 01095 /** Creates an event bound to the event queue 01096 * @see EventQueue::event 01097 */ 01098 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2> 01099 Event<void()> event(R (*func)(B0, B1, B2), C0 c0, C1 c1, C2 c2); 01100 01101 /** Creates an event bound to the event queue 01102 * @see EventQueue::event 01103 */ 01104 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2> 01105 Event<void()> event(T *obj, R (T::*method)(B0, B1, B2), C0 c0, C1 c1, C2 c2); 01106 01107 /** Creates an event bound to the event queue 01108 * @see EventQueue::event 01109 */ 01110 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2> 01111 Event<void()> event(const T *obj, R (T::*method)(B0, B1, B2) const, C0 c0, C1 c1, C2 c2); 01112 01113 /** Creates an event bound to the event queue 01114 * @see EventQueue::event 01115 */ 01116 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2> 01117 Event<void()> event(volatile T *obj, R (T::*method)(B0, B1, B2) volatile, C0 c0, C1 c1, C2 c2); 01118 01119 /** Creates an event bound to the event queue 01120 * @see EventQueue::event 01121 */ 01122 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2> 01123 Event<void()> event(const volatile T *obj, R (T::*method)(B0, B1, B2) const volatile, C0 c0, C1 c1, C2 c2); 01124 01125 /** Creates an event bound to the event queue 01126 * @see EventQueue::event 01127 */ 01128 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2> 01129 Event<void()> event(mbed::Callback<R(B0, B1, B2)> cb, C0 c0, C1 c1, C2 c2); 01130 01131 /** Creates an event bound to the event queue 01132 * @see EventQueue::event 01133 */ 01134 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3> 01135 Event<void()> event(R (*func)(B0, B1, B2, B3), C0 c0, C1 c1, C2 c2, C3 c3); 01136 01137 /** Creates an event bound to the event queue 01138 * @see EventQueue::event 01139 */ 01140 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3> 01141 Event<void()> event(T *obj, R (T::*method)(B0, B1, B2, B3), C0 c0, C1 c1, C2 c2, C3 c3); 01142 01143 /** Creates an event bound to the event queue 01144 * @see EventQueue::event 01145 */ 01146 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3> 01147 Event<void()> event(const T *obj, R (T::*method)(B0, B1, B2, B3) const, C0 c0, C1 c1, C2 c2, C3 c3); 01148 01149 /** Creates an event bound to the event queue 01150 * @see EventQueue::event 01151 */ 01152 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3> 01153 Event<void()> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3) volatile, C0 c0, C1 c1, C2 c2, C3 c3); 01154 01155 /** Creates an event bound to the event queue 01156 * @see EventQueue::event 01157 */ 01158 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3> 01159 Event<void()> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3) const volatile, C0 c0, C1 c1, C2 c2, C3 c3); 01160 01161 /** Creates an event bound to the event queue 01162 * @see EventQueue::event 01163 */ 01164 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3> 01165 Event<void()> event(mbed::Callback<R(B0, B1, B2, B3)> cb, C0 c0, C1 c1, C2 c2, C3 c3); 01166 01167 /** Creates an event bound to the event queue 01168 * @see EventQueue::event 01169 */ 01170 template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4> 01171 Event<void()> event(R (*func)(B0, B1, B2, B3, B4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4); 01172 01173 /** Creates an event bound to the event queue 01174 * @see EventQueue::event 01175 */ 01176 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> 01177 Event<void()> event(T *obj, R (T::*method)(B0, B1, B2, B3, B4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4); 01178 01179 /** Creates an event bound to the event queue 01180 * @see EventQueue::event 01181 */ 01182 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> 01183 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); 01184 01185 /** Creates an event bound to the event queue 01186 * @see EventQueue::event 01187 */ 01188 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> 01189 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); 01190 01191 /** Creates an event bound to the event queue 01192 * @see EventQueue::event 01193 */ 01194 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> 01195 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); 01196 01197 /** Creates an event bound to the event queue 01198 * @see EventQueue::event 01199 */ 01200 template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4> 01201 Event<void()> event(mbed::Callback<R(B0, B1, B2, B3, B4)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4); 01202 01203 /** Creates an event bound to the event queue 01204 * @see EventQueue::event 01205 */ 01206 template <typename R, typename A0> 01207 Event<void(A0)> event(R (*func)(A0)); 01208 01209 /** Creates an event bound to the event queue 01210 * @see EventQueue::event 01211 */ 01212 template <typename T, typename R, typename A0> 01213 Event<void(A0)> event(T *obj, R (T::*method)(A0)); 01214 01215 /** Creates an event bound to the event queue 01216 * @see EventQueue::event 01217 */ 01218 template <typename T, typename R, typename A0> 01219 Event<void(A0)> event(const T *obj, R (T::*method)(A0) const); 01220 01221 /** Creates an event bound to the event queue 01222 * @see EventQueue::event 01223 */ 01224 template <typename T, typename R, typename A0> 01225 Event<void(A0)> event(volatile T *obj, R (T::*method)(A0) volatile); 01226 01227 /** Creates an event bound to the event queue 01228 * @see EventQueue::event 01229 */ 01230 template <typename T, typename R, typename A0> 01231 Event<void(A0)> event(const volatile T *obj, R (T::*method)(A0) const volatile); 01232 01233 /** Creates an event bound to the event queue 01234 * @see EventQueue::event 01235 */ 01236 template <typename R, typename A0> 01237 Event<void(A0)> event(mbed::Callback<R(A0)> cb); 01238 01239 /** Creates an event bound to the event queue 01240 * @see EventQueue::event 01241 */ 01242 template <typename R, typename B0, typename C0, typename A0> 01243 Event<void(A0)> event(R (*func)(B0, A0), C0 c0); 01244 01245 /** Creates an event bound to the event queue 01246 * @see EventQueue::event 01247 */ 01248 template <typename T, typename R, typename B0, typename C0, typename A0> 01249 Event<void(A0)> event(T *obj, R (T::*method)(B0, A0), C0 c0); 01250 01251 /** Creates an event bound to the event queue 01252 * @see EventQueue::event 01253 */ 01254 template <typename T, typename R, typename B0, typename C0, typename A0> 01255 Event<void(A0)> event(const T *obj, R (T::*method)(B0, A0) const, C0 c0); 01256 01257 /** Creates an event bound to the event queue 01258 * @see EventQueue::event 01259 */ 01260 template <typename T, typename R, typename B0, typename C0, typename A0> 01261 Event<void(A0)> event(volatile T *obj, R (T::*method)(B0, A0) volatile, C0 c0); 01262 01263 /** Creates an event bound to the event queue 01264 * @see EventQueue::event 01265 */ 01266 template <typename T, typename R, typename B0, typename C0, typename A0> 01267 Event<void(A0)> event(const volatile T *obj, R (T::*method)(B0, A0) const volatile, C0 c0); 01268 01269 /** Creates an event bound to the event queue 01270 * @see EventQueue::event 01271 */ 01272 template <typename R, typename B0, typename C0, typename A0> 01273 Event<void(A0)> event(mbed::Callback<R(B0, A0)> cb, C0 c0); 01274 01275 /** Creates an event bound to the event queue 01276 * @see EventQueue::event 01277 */ 01278 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0> 01279 Event<void(A0)> event(R (*func)(B0, B1, A0), C0 c0, C1 c1); 01280 01281 /** Creates an event bound to the event queue 01282 * @see EventQueue::event 01283 */ 01284 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0> 01285 Event<void(A0)> event(T *obj, R (T::*method)(B0, B1, A0), C0 c0, C1 c1); 01286 01287 /** Creates an event bound to the event queue 01288 * @see EventQueue::event 01289 */ 01290 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0> 01291 Event<void(A0)> event(const T *obj, R (T::*method)(B0, B1, A0) const, C0 c0, C1 c1); 01292 01293 /** Creates an event bound to the event queue 01294 * @see EventQueue::event 01295 */ 01296 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0> 01297 Event<void(A0)> event(volatile T *obj, R (T::*method)(B0, B1, A0) volatile, C0 c0, C1 c1); 01298 01299 /** Creates an event bound to the event queue 01300 * @see EventQueue::event 01301 */ 01302 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0> 01303 Event<void(A0)> event(const volatile T *obj, R (T::*method)(B0, B1, A0) const volatile, C0 c0, C1 c1); 01304 01305 /** Creates an event bound to the event queue 01306 * @see EventQueue::event 01307 */ 01308 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0> 01309 Event<void(A0)> event(mbed::Callback<R(B0, B1, A0)> cb, C0 c0, C1 c1); 01310 01311 /** Creates an event bound to the event queue 01312 * @see EventQueue::event 01313 */ 01314 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0> 01315 Event<void(A0)> event(R (*func)(B0, B1, B2, A0), C0 c0, C1 c1, C2 c2); 01316 01317 /** Creates an event bound to the event queue 01318 * @see EventQueue::event 01319 */ 01320 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0> 01321 Event<void(A0)> event(T *obj, R (T::*method)(B0, B1, B2, A0), C0 c0, C1 c1, C2 c2); 01322 01323 /** Creates an event bound to the event queue 01324 * @see EventQueue::event 01325 */ 01326 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0> 01327 Event<void(A0)> event(const T *obj, R (T::*method)(B0, B1, B2, A0) const, C0 c0, C1 c1, C2 c2); 01328 01329 /** Creates an event bound to the event queue 01330 * @see EventQueue::event 01331 */ 01332 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0> 01333 Event<void(A0)> event(volatile T *obj, R (T::*method)(B0, B1, B2, A0) volatile, C0 c0, C1 c1, C2 c2); 01334 01335 /** Creates an event bound to the event queue 01336 * @see EventQueue::event 01337 */ 01338 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0> 01339 Event<void(A0)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, A0) const volatile, C0 c0, C1 c1, C2 c2); 01340 01341 /** Creates an event bound to the event queue 01342 * @see EventQueue::event 01343 */ 01344 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0> 01345 Event<void(A0)> event(mbed::Callback<R(B0, B1, B2, A0)> cb, C0 c0, C1 c1, C2 c2); 01346 01347 /** Creates an event bound to the event queue 01348 * @see EventQueue::event 01349 */ 01350 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0> 01351 Event<void(A0)> event(R (*func)(B0, B1, B2, B3, A0), C0 c0, C1 c1, C2 c2, C3 c3); 01352 01353 /** Creates an event bound to the event queue 01354 * @see EventQueue::event 01355 */ 01356 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0> 01357 Event<void(A0)> event(T *obj, R (T::*method)(B0, B1, B2, B3, A0), C0 c0, C1 c1, C2 c2, C3 c3); 01358 01359 /** Creates an event bound to the event queue 01360 * @see EventQueue::event 01361 */ 01362 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0> 01363 Event<void(A0)> event(const T *obj, R (T::*method)(B0, B1, B2, B3, A0) const, C0 c0, C1 c1, C2 c2, C3 c3); 01364 01365 /** Creates an event bound to the event queue 01366 * @see EventQueue::event 01367 */ 01368 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0> 01369 Event<void(A0)> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0) volatile, C0 c0, C1 c1, C2 c2, C3 c3); 01370 01371 /** Creates an event bound to the event queue 01372 * @see EventQueue::event 01373 */ 01374 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0> 01375 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); 01376 01377 /** Creates an event bound to the event queue 01378 * @see EventQueue::event 01379 */ 01380 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0> 01381 Event<void(A0)> event(mbed::Callback<R(B0, B1, B2, B3, A0)> cb, C0 c0, C1 c1, C2 c2, C3 c3); 01382 01383 /** Creates an event bound to the event queue 01384 * @see EventQueue::event 01385 */ 01386 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> 01387 Event<void(A0)> event(R (*func)(B0, B1, B2, B3, B4, A0), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4); 01388 01389 /** Creates an event bound to the event queue 01390 * @see EventQueue::event 01391 */ 01392 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> 01393 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); 01394 01395 /** Creates an event bound to the event queue 01396 * @see EventQueue::event 01397 */ 01398 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> 01399 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); 01400 01401 /** Creates an event bound to the event queue 01402 * @see EventQueue::event 01403 */ 01404 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> 01405 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); 01406 01407 /** Creates an event bound to the event queue 01408 * @see EventQueue::event 01409 */ 01410 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> 01411 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); 01412 01413 /** Creates an event bound to the event queue 01414 * @see EventQueue::event 01415 */ 01416 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> 01417 Event<void(A0)> event(mbed::Callback<R(B0, B1, B2, B3, B4, A0)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4); 01418 01419 /** Creates an event bound to the event queue 01420 * @see EventQueue::event 01421 */ 01422 template <typename R, typename A0, typename A1> 01423 Event<void(A0, A1)> event(R (*func)(A0, A1)); 01424 01425 /** Creates an event bound to the event queue 01426 * @see EventQueue::event 01427 */ 01428 template <typename T, typename R, typename A0, typename A1> 01429 Event<void(A0, A1)> event(T *obj, R (T::*method)(A0, A1)); 01430 01431 /** Creates an event bound to the event queue 01432 * @see EventQueue::event 01433 */ 01434 template <typename T, typename R, typename A0, typename A1> 01435 Event<void(A0, A1)> event(const T *obj, R (T::*method)(A0, A1) const); 01436 01437 /** Creates an event bound to the event queue 01438 * @see EventQueue::event 01439 */ 01440 template <typename T, typename R, typename A0, typename A1> 01441 Event<void(A0, A1)> event(volatile T *obj, R (T::*method)(A0, A1) volatile); 01442 01443 /** Creates an event bound to the event queue 01444 * @see EventQueue::event 01445 */ 01446 template <typename T, typename R, typename A0, typename A1> 01447 Event<void(A0, A1)> event(const volatile T *obj, R (T::*method)(A0, A1) const volatile); 01448 01449 /** Creates an event bound to the event queue 01450 * @see EventQueue::event 01451 */ 01452 template <typename R, typename A0, typename A1> 01453 Event<void(A0, A1)> event(mbed::Callback<R(A0, A1)> cb); 01454 01455 /** Creates an event bound to the event queue 01456 * @see EventQueue::event 01457 */ 01458 template <typename R, typename B0, typename C0, typename A0, typename A1> 01459 Event<void(A0, A1)> event(R (*func)(B0, A0, A1), C0 c0); 01460 01461 /** Creates an event bound to the event queue 01462 * @see EventQueue::event 01463 */ 01464 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1> 01465 Event<void(A0, A1)> event(T *obj, R (T::*method)(B0, A0, A1), C0 c0); 01466 01467 /** Creates an event bound to the event queue 01468 * @see EventQueue::event 01469 */ 01470 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1> 01471 Event<void(A0, A1)> event(const T *obj, R (T::*method)(B0, A0, A1) const, C0 c0); 01472 01473 /** Creates an event bound to the event queue 01474 * @see EventQueue::event 01475 */ 01476 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1> 01477 Event<void(A0, A1)> event(volatile T *obj, R (T::*method)(B0, A0, A1) volatile, C0 c0); 01478 01479 /** Creates an event bound to the event queue 01480 * @see EventQueue::event 01481 */ 01482 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1> 01483 Event<void(A0, A1)> event(const volatile T *obj, R (T::*method)(B0, A0, A1) const volatile, C0 c0); 01484 01485 /** Creates an event bound to the event queue 01486 * @see EventQueue::event 01487 */ 01488 template <typename R, typename B0, typename C0, typename A0, typename A1> 01489 Event<void(A0, A1)> event(mbed::Callback<R(B0, A0, A1)> cb, C0 c0); 01490 01491 /** Creates an event bound to the event queue 01492 * @see EventQueue::event 01493 */ 01494 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1> 01495 Event<void(A0, A1)> event(R (*func)(B0, B1, A0, A1), C0 c0, C1 c1); 01496 01497 /** Creates an event bound to the event queue 01498 * @see EventQueue::event 01499 */ 01500 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1> 01501 Event<void(A0, A1)> event(T *obj, R (T::*method)(B0, B1, A0, A1), C0 c0, C1 c1); 01502 01503 /** Creates an event bound to the event queue 01504 * @see EventQueue::event 01505 */ 01506 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1> 01507 Event<void(A0, A1)> event(const T *obj, R (T::*method)(B0, B1, A0, A1) const, C0 c0, C1 c1); 01508 01509 /** Creates an event bound to the event queue 01510 * @see EventQueue::event 01511 */ 01512 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1> 01513 Event<void(A0, A1)> event(volatile T *obj, R (T::*method)(B0, B1, A0, A1) volatile, C0 c0, C1 c1); 01514 01515 /** Creates an event bound to the event queue 01516 * @see EventQueue::event 01517 */ 01518 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1> 01519 Event<void(A0, A1)> event(const volatile T *obj, R (T::*method)(B0, B1, A0, A1) const volatile, C0 c0, C1 c1); 01520 01521 /** Creates an event bound to the event queue 01522 * @see EventQueue::event 01523 */ 01524 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1> 01525 Event<void(A0, A1)> event(mbed::Callback<R(B0, B1, A0, A1)> cb, C0 c0, C1 c1); 01526 01527 /** Creates an event bound to the event queue 01528 * @see EventQueue::event 01529 */ 01530 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1> 01531 Event<void(A0, A1)> event(R (*func)(B0, B1, B2, A0, A1), C0 c0, C1 c1, C2 c2); 01532 01533 /** Creates an event bound to the event queue 01534 * @see EventQueue::event 01535 */ 01536 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1> 01537 Event<void(A0, A1)> event(T *obj, R (T::*method)(B0, B1, B2, A0, A1), C0 c0, C1 c1, C2 c2); 01538 01539 /** Creates an event bound to the event queue 01540 * @see EventQueue::event 01541 */ 01542 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1> 01543 Event<void(A0, A1)> event(const T *obj, R (T::*method)(B0, B1, B2, A0, A1) const, C0 c0, C1 c1, C2 c2); 01544 01545 /** Creates an event bound to the event queue 01546 * @see EventQueue::event 01547 */ 01548 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1> 01549 Event<void(A0, A1)> event(volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1) volatile, C0 c0, C1 c1, C2 c2); 01550 01551 /** Creates an event bound to the event queue 01552 * @see EventQueue::event 01553 */ 01554 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1> 01555 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); 01556 01557 /** Creates an event bound to the event queue 01558 * @see EventQueue::event 01559 */ 01560 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1> 01561 Event<void(A0, A1)> event(mbed::Callback<R(B0, B1, B2, A0, A1)> cb, C0 c0, C1 c1, C2 c2); 01562 01563 /** Creates an event bound to the event queue 01564 * @see EventQueue::event 01565 */ 01566 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1> 01567 Event<void(A0, A1)> event(R (*func)(B0, B1, B2, B3, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3); 01568 01569 /** Creates an event bound to the event queue 01570 * @see EventQueue::event 01571 */ 01572 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> 01573 Event<void(A0, A1)> event(T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3); 01574 01575 /** Creates an event bound to the event queue 01576 * @see EventQueue::event 01577 */ 01578 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> 01579 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); 01580 01581 /** Creates an event bound to the event queue 01582 * @see EventQueue::event 01583 */ 01584 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> 01585 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); 01586 01587 /** Creates an event bound to the event queue 01588 * @see EventQueue::event 01589 */ 01590 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> 01591 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); 01592 01593 /** Creates an event bound to the event queue 01594 * @see EventQueue::event 01595 */ 01596 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1> 01597 Event<void(A0, A1)> event(mbed::Callback<R(B0, B1, B2, B3, A0, A1)> cb, C0 c0, C1 c1, C2 c2, C3 c3); 01598 01599 /** Creates an event bound to the event queue 01600 * @see EventQueue::event 01601 */ 01602 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> 01603 Event<void(A0, A1)> event(R (*func)(B0, B1, B2, B3, B4, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4); 01604 01605 /** Creates an event bound to the event queue 01606 * @see EventQueue::event 01607 */ 01608 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> 01609 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); 01610 01611 /** Creates an event bound to the event queue 01612 * @see EventQueue::event 01613 */ 01614 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> 01615 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); 01616 01617 /** Creates an event bound to the event queue 01618 * @see EventQueue::event 01619 */ 01620 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> 01621 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); 01622 01623 /** Creates an event bound to the event queue 01624 * @see EventQueue::event 01625 */ 01626 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> 01627 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); 01628 01629 /** Creates an event bound to the event queue 01630 * @see EventQueue::event 01631 */ 01632 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> 01633 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); 01634 01635 /** Creates an event bound to the event queue 01636 * @see EventQueue::event 01637 */ 01638 template <typename R, typename A0, typename A1, typename A2> 01639 Event<void(A0, A1, A2)> event(R (*func)(A0, A1, A2)); 01640 01641 /** Creates an event bound to the event queue 01642 * @see EventQueue::event 01643 */ 01644 template <typename T, typename R, typename A0, typename A1, typename A2> 01645 Event<void(A0, A1, A2)> event(T *obj, R (T::*method)(A0, A1, A2)); 01646 01647 /** Creates an event bound to the event queue 01648 * @see EventQueue::event 01649 */ 01650 template <typename T, typename R, typename A0, typename A1, typename A2> 01651 Event<void(A0, A1, A2)> event(const T *obj, R (T::*method)(A0, A1, A2) const); 01652 01653 /** Creates an event bound to the event queue 01654 * @see EventQueue::event 01655 */ 01656 template <typename T, typename R, typename A0, typename A1, typename A2> 01657 Event<void(A0, A1, A2)> event(volatile T *obj, R (T::*method)(A0, A1, A2) volatile); 01658 01659 /** Creates an event bound to the event queue 01660 * @see EventQueue::event 01661 */ 01662 template <typename T, typename R, typename A0, typename A1, typename A2> 01663 Event<void(A0, A1, A2)> event(const volatile T *obj, R (T::*method)(A0, A1, A2) const volatile); 01664 01665 /** Creates an event bound to the event queue 01666 * @see EventQueue::event 01667 */ 01668 template <typename R, typename A0, typename A1, typename A2> 01669 Event<void(A0, A1, A2)> event(mbed::Callback<R(A0, A1, A2)> cb); 01670 01671 /** Creates an event bound to the event queue 01672 * @see EventQueue::event 01673 */ 01674 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2> 01675 Event<void(A0, A1, A2)> event(R (*func)(B0, A0, A1, A2), C0 c0); 01676 01677 /** Creates an event bound to the event queue 01678 * @see EventQueue::event 01679 */ 01680 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2> 01681 Event<void(A0, A1, A2)> event(T *obj, R (T::*method)(B0, A0, A1, A2), C0 c0); 01682 01683 /** Creates an event bound to the event queue 01684 * @see EventQueue::event 01685 */ 01686 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2> 01687 Event<void(A0, A1, A2)> event(const T *obj, R (T::*method)(B0, A0, A1, A2) const, C0 c0); 01688 01689 /** Creates an event bound to the event queue 01690 * @see EventQueue::event 01691 */ 01692 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2> 01693 Event<void(A0, A1, A2)> event(volatile T *obj, R (T::*method)(B0, A0, A1, A2) volatile, C0 c0); 01694 01695 /** Creates an event bound to the event queue 01696 * @see EventQueue::event 01697 */ 01698 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2> 01699 Event<void(A0, A1, A2)> event(const volatile T *obj, R (T::*method)(B0, A0, A1, A2) const volatile, C0 c0); 01700 01701 /** Creates an event bound to the event queue 01702 * @see EventQueue::event 01703 */ 01704 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2> 01705 Event<void(A0, A1, A2)> event(mbed::Callback<R(B0, A0, A1, A2)> cb, C0 c0); 01706 01707 /** Creates an event bound to the event queue 01708 * @see EventQueue::event 01709 */ 01710 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2> 01711 Event<void(A0, A1, A2)> event(R (*func)(B0, B1, A0, A1, A2), C0 c0, C1 c1); 01712 01713 /** Creates an event bound to the event queue 01714 * @see EventQueue::event 01715 */ 01716 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2> 01717 Event<void(A0, A1, A2)> event(T *obj, R (T::*method)(B0, B1, A0, A1, A2), C0 c0, C1 c1); 01718 01719 /** Creates an event bound to the event queue 01720 * @see EventQueue::event 01721 */ 01722 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2> 01723 Event<void(A0, A1, A2)> event(const T *obj, R (T::*method)(B0, B1, A0, A1, A2) const, C0 c0, C1 c1); 01724 01725 /** Creates an event bound to the event queue 01726 * @see EventQueue::event 01727 */ 01728 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2> 01729 Event<void(A0, A1, A2)> event(volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2) volatile, C0 c0, C1 c1); 01730 01731 /** Creates an event bound to the event queue 01732 * @see EventQueue::event 01733 */ 01734 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2> 01735 Event<void(A0, A1, A2)> event(const volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2) const volatile, C0 c0, C1 c1); 01736 01737 /** Creates an event bound to the event queue 01738 * @see EventQueue::event 01739 */ 01740 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2> 01741 Event<void(A0, A1, A2)> event(mbed::Callback<R(B0, B1, A0, A1, A2)> cb, C0 c0, C1 c1); 01742 01743 /** Creates an event bound to the event queue 01744 * @see EventQueue::event 01745 */ 01746 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2> 01747 Event<void(A0, A1, A2)> event(R (*func)(B0, B1, B2, A0, A1, A2), C0 c0, C1 c1, C2 c2); 01748 01749 /** Creates an event bound to the event queue 01750 * @see EventQueue::event 01751 */ 01752 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2> 01753 Event<void(A0, A1, A2)> event(T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2), C0 c0, C1 c1, C2 c2); 01754 01755 /** Creates an event bound to the event queue 01756 * @see EventQueue::event 01757 */ 01758 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2> 01759 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); 01760 01761 /** Creates an event bound to the event queue 01762 * @see EventQueue::event 01763 */ 01764 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2> 01765 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); 01766 01767 /** Creates an event bound to the event queue 01768 * @see EventQueue::event 01769 */ 01770 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2> 01771 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); 01772 01773 /** Creates an event bound to the event queue 01774 * @see EventQueue::event 01775 */ 01776 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2> 01777 Event<void(A0, A1, A2)> event(mbed::Callback<R(B0, B1, B2, A0, A1, A2)> cb, C0 c0, C1 c1, C2 c2); 01778 01779 /** Creates an event bound to the event queue 01780 * @see EventQueue::event 01781 */ 01782 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> 01783 Event<void(A0, A1, A2)> event(R (*func)(B0, B1, B2, B3, A0, A1, A2), C0 c0, C1 c1, C2 c2, C3 c3); 01784 01785 /** Creates an event bound to the event queue 01786 * @see EventQueue::event 01787 */ 01788 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> 01789 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); 01790 01791 /** Creates an event bound to the event queue 01792 * @see EventQueue::event 01793 */ 01794 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> 01795 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); 01796 01797 /** Creates an event bound to the event queue 01798 * @see EventQueue::event 01799 */ 01800 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> 01801 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); 01802 01803 /** Creates an event bound to the event queue 01804 * @see EventQueue::event 01805 */ 01806 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> 01807 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); 01808 01809 /** Creates an event bound to the event queue 01810 * @see EventQueue::event 01811 */ 01812 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> 01813 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); 01814 01815 /** Creates an event bound to the event queue 01816 * @see EventQueue::event 01817 */ 01818 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> 01819 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); 01820 01821 /** Creates an event bound to the event queue 01822 * @see EventQueue::event 01823 */ 01824 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> 01825 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); 01826 01827 /** Creates an event bound to the event queue 01828 * @see EventQueue::event 01829 */ 01830 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> 01831 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); 01832 01833 /** Creates an event bound to the event queue 01834 * @see EventQueue::event 01835 */ 01836 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> 01837 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); 01838 01839 /** Creates an event bound to the event queue 01840 * @see EventQueue::event 01841 */ 01842 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> 01843 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); 01844 01845 /** Creates an event bound to the event queue 01846 * @see EventQueue::event 01847 */ 01848 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> 01849 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); 01850 01851 /** Creates an event bound to the event queue 01852 * @see EventQueue::event 01853 */ 01854 template <typename R, typename A0, typename A1, typename A2, typename A3> 01855 Event<void(A0, A1, A2, A3)> event(R (*func)(A0, A1, A2, A3)); 01856 01857 /** Creates an event bound to the event queue 01858 * @see EventQueue::event 01859 */ 01860 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 01861 Event<void(A0, A1, A2, A3)> event(T *obj, R (T::*method)(A0, A1, A2, A3)); 01862 01863 /** Creates an event bound to the event queue 01864 * @see EventQueue::event 01865 */ 01866 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 01867 Event<void(A0, A1, A2, A3)> event(const T *obj, R (T::*method)(A0, A1, A2, A3) const); 01868 01869 /** Creates an event bound to the event queue 01870 * @see EventQueue::event 01871 */ 01872 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 01873 Event<void(A0, A1, A2, A3)> event(volatile T *obj, R (T::*method)(A0, A1, A2, A3) volatile); 01874 01875 /** Creates an event bound to the event queue 01876 * @see EventQueue::event 01877 */ 01878 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 01879 Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R (T::*method)(A0, A1, A2, A3) const volatile); 01880 01881 /** Creates an event bound to the event queue 01882 * @see EventQueue::event 01883 */ 01884 template <typename R, typename A0, typename A1, typename A2, typename A3> 01885 Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(A0, A1, A2, A3)> cb); 01886 01887 /** Creates an event bound to the event queue 01888 * @see EventQueue::event 01889 */ 01890 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3> 01891 Event<void(A0, A1, A2, A3)> event(R (*func)(B0, A0, A1, A2, A3), C0 c0); 01892 01893 /** Creates an event bound to the event queue 01894 * @see EventQueue::event 01895 */ 01896 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3> 01897 Event<void(A0, A1, A2, A3)> event(T *obj, R (T::*method)(B0, A0, A1, A2, A3), C0 c0); 01898 01899 /** Creates an event bound to the event queue 01900 * @see EventQueue::event 01901 */ 01902 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3> 01903 Event<void(A0, A1, A2, A3)> event(const T *obj, R (T::*method)(B0, A0, A1, A2, A3) const, C0 c0); 01904 01905 /** Creates an event bound to the event queue 01906 * @see EventQueue::event 01907 */ 01908 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3> 01909 Event<void(A0, A1, A2, A3)> event(volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3) volatile, C0 c0); 01910 01911 /** Creates an event bound to the event queue 01912 * @see EventQueue::event 01913 */ 01914 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3> 01915 Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3) const volatile, C0 c0); 01916 01917 /** Creates an event bound to the event queue 01918 * @see EventQueue::event 01919 */ 01920 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3> 01921 Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(B0, A0, A1, A2, A3)> cb, C0 c0); 01922 01923 /** Creates an event bound to the event queue 01924 * @see EventQueue::event 01925 */ 01926 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3> 01927 Event<void(A0, A1, A2, A3)> event(R (*func)(B0, B1, A0, A1, A2, A3), C0 c0, C1 c1); 01928 01929 /** Creates an event bound to the event queue 01930 * @see EventQueue::event 01931 */ 01932 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3> 01933 Event<void(A0, A1, A2, A3)> event(T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3), C0 c0, C1 c1); 01934 01935 /** Creates an event bound to the event queue 01936 * @see EventQueue::event 01937 */ 01938 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3> 01939 Event<void(A0, A1, A2, A3)> event(const T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3) const, C0 c0, C1 c1); 01940 01941 /** Creates an event bound to the event queue 01942 * @see EventQueue::event 01943 */ 01944 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3> 01945 Event<void(A0, A1, A2, A3)> event(volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3) volatile, C0 c0, C1 c1); 01946 01947 /** Creates an event bound to the event queue 01948 * @see EventQueue::event 01949 */ 01950 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3> 01951 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); 01952 01953 /** Creates an event bound to the event queue 01954 * @see EventQueue::event 01955 */ 01956 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3> 01957 Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(B0, B1, A0, A1, A2, A3)> cb, C0 c0, C1 c1); 01958 01959 /** Creates an event bound to the event queue 01960 * @see EventQueue::event 01961 */ 01962 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3> 01963 Event<void(A0, A1, A2, A3)> event(R (*func)(B0, B1, B2, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2); 01964 01965 /** Creates an event bound to the event queue 01966 * @see EventQueue::event 01967 */ 01968 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> 01969 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); 01970 01971 /** Creates an event bound to the event queue 01972 * @see EventQueue::event 01973 */ 01974 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> 01975 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); 01976 01977 /** Creates an event bound to the event queue 01978 * @see EventQueue::event 01979 */ 01980 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> 01981 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); 01982 01983 /** Creates an event bound to the event queue 01984 * @see EventQueue::event 01985 */ 01986 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> 01987 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); 01988 01989 /** Creates an event bound to the event queue 01990 * @see EventQueue::event 01991 */ 01992 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3> 01993 Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(B0, B1, B2, A0, A1, A2, A3)> cb, C0 c0, C1 c1, C2 c2); 01994 01995 /** Creates an event bound to the event queue 01996 * @see EventQueue::event 01997 */ 01998 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> 01999 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); 02000 02001 /** Creates an event bound to the event queue 02002 * @see EventQueue::event 02003 */ 02004 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> 02005 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); 02006 02007 /** Creates an event bound to the event queue 02008 * @see EventQueue::event 02009 */ 02010 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> 02011 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); 02012 02013 /** Creates an event bound to the event queue 02014 * @see EventQueue::event 02015 */ 02016 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> 02017 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); 02018 02019 /** Creates an event bound to the event queue 02020 * @see EventQueue::event 02021 */ 02022 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> 02023 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); 02024 02025 /** Creates an event bound to the event queue 02026 * @see EventQueue::event 02027 */ 02028 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> 02029 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); 02030 02031 /** Creates an event bound to the event queue 02032 * @see EventQueue::event 02033 */ 02034 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> 02035 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); 02036 02037 /** Creates an event bound to the event queue 02038 * @see EventQueue::event 02039 */ 02040 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> 02041 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); 02042 02043 /** Creates an event bound to the event queue 02044 * @see EventQueue::event 02045 */ 02046 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> 02047 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); 02048 02049 /** Creates an event bound to the event queue 02050 * @see EventQueue::event 02051 */ 02052 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> 02053 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); 02054 02055 /** Creates an event bound to the event queue 02056 * @see EventQueue::event 02057 */ 02058 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> 02059 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); 02060 02061 /** Creates an event bound to the event queue 02062 * @see EventQueue::event 02063 */ 02064 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> 02065 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); 02066 02067 /** Creates an event bound to the event queue 02068 * @see EventQueue::event 02069 */ 02070 template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 02071 Event<void(A0, A1, A2, A3, A4)> event(R (*func)(A0, A1, A2, A3, A4)); 02072 02073 /** Creates an event bound to the event queue 02074 * @see EventQueue::event 02075 */ 02076 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 02077 Event<void(A0, A1, A2, A3, A4)> event(T *obj, R (T::*method)(A0, A1, A2, A3, A4)); 02078 02079 /** Creates an event bound to the event queue 02080 * @see EventQueue::event 02081 */ 02082 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 02083 Event<void(A0, A1, A2, A3, A4)> event(const T *obj, R (T::*method)(A0, A1, A2, A3, A4) const); 02084 02085 /** Creates an event bound to the event queue 02086 * @see EventQueue::event 02087 */ 02088 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 02089 Event<void(A0, A1, A2, A3, A4)> event(volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) volatile); 02090 02091 /** Creates an event bound to the event queue 02092 * @see EventQueue::event 02093 */ 02094 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 02095 Event<void(A0, A1, A2, A3, A4)> event(const volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) const volatile); 02096 02097 /** Creates an event bound to the event queue 02098 * @see EventQueue::event 02099 */ 02100 template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 02101 Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(A0, A1, A2, A3, A4)> cb); 02102 02103 /** Creates an event bound to the event queue 02104 * @see EventQueue::event 02105 */ 02106 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4> 02107 Event<void(A0, A1, A2, A3, A4)> event(R (*func)(B0, A0, A1, A2, A3, A4), C0 c0); 02108 02109 /** Creates an event bound to the event queue 02110 * @see EventQueue::event 02111 */ 02112 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4> 02113 Event<void(A0, A1, A2, A3, A4)> event(T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4), C0 c0); 02114 02115 /** Creates an event bound to the event queue 02116 * @see EventQueue::event 02117 */ 02118 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4> 02119 Event<void(A0, A1, A2, A3, A4)> event(const T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4) const, C0 c0); 02120 02121 /** Creates an event bound to the event queue 02122 * @see EventQueue::event 02123 */ 02124 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4> 02125 Event<void(A0, A1, A2, A3, A4)> event(volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4) volatile, C0 c0); 02126 02127 /** Creates an event bound to the event queue 02128 * @see EventQueue::event 02129 */ 02130 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4> 02131 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); 02132 02133 /** Creates an event bound to the event queue 02134 * @see EventQueue::event 02135 */ 02136 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4> 02137 Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(B0, A0, A1, A2, A3, A4)> cb, C0 c0); 02138 02139 /** Creates an event bound to the event queue 02140 * @see EventQueue::event 02141 */ 02142 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4> 02143 Event<void(A0, A1, A2, A3, A4)> event(R (*func)(B0, B1, A0, A1, A2, A3, A4), C0 c0, C1 c1); 02144 02145 /** Creates an event bound to the event queue 02146 * @see EventQueue::event 02147 */ 02148 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4> 02149 Event<void(A0, A1, A2, A3, A4)> event(T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3, A4), C0 c0, C1 c1); 02150 02151 /** Creates an event bound to the event queue 02152 * @see EventQueue::event 02153 */ 02154 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4> 02155 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); 02156 02157 /** Creates an event bound to the event queue 02158 * @see EventQueue::event 02159 */ 02160 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4> 02161 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); 02162 02163 /** Creates an event bound to the event queue 02164 * @see EventQueue::event 02165 */ 02166 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4> 02167 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); 02168 02169 /** Creates an event bound to the event queue 02170 * @see EventQueue::event 02171 */ 02172 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4> 02173 Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(B0, B1, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1); 02174 02175 /** Creates an event bound to the event queue 02176 * @see EventQueue::event 02177 */ 02178 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> 02179 Event<void(A0, A1, A2, A3, A4)> event(R (*func)(B0, B1, B2, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2); 02180 02181 /** Creates an event bound to the event queue 02182 * @see EventQueue::event 02183 */ 02184 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> 02185 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); 02186 02187 /** Creates an event bound to the event queue 02188 * @see EventQueue::event 02189 */ 02190 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> 02191 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); 02192 02193 /** Creates an event bound to the event queue 02194 * @see EventQueue::event 02195 */ 02196 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> 02197 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); 02198 02199 /** Creates an event bound to the event queue 02200 * @see EventQueue::event 02201 */ 02202 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> 02203 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); 02204 02205 /** Creates an event bound to the event queue 02206 * @see EventQueue::event 02207 */ 02208 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> 02209 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); 02210 02211 /** Creates an event bound to the event queue 02212 * @see EventQueue::event 02213 */ 02214 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> 02215 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); 02216 02217 /** Creates an event bound to the event queue 02218 * @see EventQueue::event 02219 */ 02220 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> 02221 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); 02222 02223 /** Creates an event bound to the event queue 02224 * @see EventQueue::event 02225 */ 02226 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> 02227 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); 02228 02229 /** Creates an event bound to the event queue 02230 * @see EventQueue::event 02231 */ 02232 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> 02233 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); 02234 02235 /** Creates an event bound to the event queue 02236 * @see EventQueue::event 02237 */ 02238 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> 02239 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); 02240 02241 /** Creates an event bound to the event queue 02242 * @see EventQueue::event 02243 */ 02244 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> 02245 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); 02246 02247 /** Creates an event bound to the event queue 02248 * @see EventQueue::event 02249 */ 02250 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> 02251 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); 02252 02253 /** Creates an event bound to the event queue 02254 * @see EventQueue::event 02255 */ 02256 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> 02257 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); 02258 02259 /** Creates an event bound to the event queue 02260 * @see EventQueue::event 02261 */ 02262 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> 02263 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); 02264 02265 /** Creates an event bound to the event queue 02266 * @see EventQueue::event 02267 */ 02268 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> 02269 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); 02270 02271 /** Creates an event bound to the event queue 02272 * @see EventQueue::event 02273 */ 02274 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> 02275 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); 02276 02277 /** Creates an event bound to the event queue 02278 * @see EventQueue::event 02279 */ 02280 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> 02281 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); 02282 02283 protected: 02284 template <typename F> 02285 friend class Event; 02286 struct equeue _equeue; 02287 mbed::Callback<void(int)> _update; 02288 02289 // Function attributes 02290 template <typename F> 02291 static void function_call(void *p) { 02292 (*(F*)p)(); 02293 } 02294 02295 template <typename F> 02296 static void function_dtor(void *p) { 02297 ((F*)p)->~F(); 02298 } 02299 02300 // Context structures 02301 template <typename F> 02302 struct context00 { 02303 F f; 02304 02305 context00(F f) 02306 : f(f) {} 02307 02308 void operator()() { 02309 f(); 02310 } 02311 }; 02312 02313 template <typename F, typename C0> 02314 struct context10 { 02315 F f; C0 c0; 02316 02317 context10(F f, C0 c0) 02318 : f(f), c0(c0) {} 02319 02320 void operator()() { 02321 f(c0); 02322 } 02323 }; 02324 02325 template <typename F, typename C0, typename C1> 02326 struct context20 { 02327 F f; C0 c0; C1 c1; 02328 02329 context20(F f, C0 c0, C1 c1) 02330 : f(f), c0(c0), c1(c1) {} 02331 02332 void operator()() { 02333 f(c0, c1); 02334 } 02335 }; 02336 02337 template <typename F, typename C0, typename C1, typename C2> 02338 struct context30 { 02339 F f; C0 c0; C1 c1; C2 c2; 02340 02341 context30(F f, C0 c0, C1 c1, C2 c2) 02342 : f(f), c0(c0), c1(c1), c2(c2) {} 02343 02344 void operator()() { 02345 f(c0, c1, c2); 02346 } 02347 }; 02348 02349 template <typename F, typename C0, typename C1, typename C2, typename C3> 02350 struct context40 { 02351 F f; C0 c0; C1 c1; C2 c2; C3 c3; 02352 02353 context40(F f, C0 c0, C1 c1, C2 c2, C3 c3) 02354 : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {} 02355 02356 void operator()() { 02357 f(c0, c1, c2, c3); 02358 } 02359 }; 02360 02361 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4> 02362 struct context50 { 02363 F f; C0 c0; C1 c1; C2 c2; C3 c3; C4 c4; 02364 02365 context50(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) 02366 : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {} 02367 02368 void operator()() { 02369 f(c0, c1, c2, c3, c4); 02370 } 02371 }; 02372 02373 template <typename F, typename A0> 02374 struct context01 { 02375 F f; 02376 02377 context01(F f) 02378 : f(f) {} 02379 02380 void operator()(A0 a0) { 02381 f(a0); 02382 } 02383 }; 02384 02385 template <typename F, typename C0, typename A0> 02386 struct context11 { 02387 F f; C0 c0; 02388 02389 context11(F f, C0 c0) 02390 : f(f), c0(c0) {} 02391 02392 void operator()(A0 a0) { 02393 f(c0, a0); 02394 } 02395 }; 02396 02397 template <typename F, typename C0, typename C1, typename A0> 02398 struct context21 { 02399 F f; C0 c0; C1 c1; 02400 02401 context21(F f, C0 c0, C1 c1) 02402 : f(f), c0(c0), c1(c1) {} 02403 02404 void operator()(A0 a0) { 02405 f(c0, c1, a0); 02406 } 02407 }; 02408 02409 template <typename F, typename C0, typename C1, typename C2, typename A0> 02410 struct context31 { 02411 F f; C0 c0; C1 c1; C2 c2; 02412 02413 context31(F f, C0 c0, C1 c1, C2 c2) 02414 : f(f), c0(c0), c1(c1), c2(c2) {} 02415 02416 void operator()(A0 a0) { 02417 f(c0, c1, c2, a0); 02418 } 02419 }; 02420 02421 template <typename F, typename C0, typename C1, typename C2, typename C3, typename A0> 02422 struct context41 { 02423 F f; C0 c0; C1 c1; C2 c2; C3 c3; 02424 02425 context41(F f, C0 c0, C1 c1, C2 c2, C3 c3) 02426 : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {} 02427 02428 void operator()(A0 a0) { 02429 f(c0, c1, c2, c3, a0); 02430 } 02431 }; 02432 02433 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0> 02434 struct context51 { 02435 F f; C0 c0; C1 c1; C2 c2; C3 c3; C4 c4; 02436 02437 context51(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) 02438 : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {} 02439 02440 void operator()(A0 a0) { 02441 f(c0, c1, c2, c3, c4, a0); 02442 } 02443 }; 02444 02445 template <typename F, typename A0, typename A1> 02446 struct context02 { 02447 F f; 02448 02449 context02(F f) 02450 : f(f) {} 02451 02452 void operator()(A0 a0, A1 a1) { 02453 f(a0, a1); 02454 } 02455 }; 02456 02457 template <typename F, typename C0, typename A0, typename A1> 02458 struct context12 { 02459 F f; C0 c0; 02460 02461 context12(F f, C0 c0) 02462 : f(f), c0(c0) {} 02463 02464 void operator()(A0 a0, A1 a1) { 02465 f(c0, a0, a1); 02466 } 02467 }; 02468 02469 template <typename F, typename C0, typename C1, typename A0, typename A1> 02470 struct context22 { 02471 F f; C0 c0; C1 c1; 02472 02473 context22(F f, C0 c0, C1 c1) 02474 : f(f), c0(c0), c1(c1) {} 02475 02476 void operator()(A0 a0, A1 a1) { 02477 f(c0, c1, a0, a1); 02478 } 02479 }; 02480 02481 template <typename F, typename C0, typename C1, typename C2, typename A0, typename A1> 02482 struct context32 { 02483 F f; C0 c0; C1 c1; C2 c2; 02484 02485 context32(F f, C0 c0, C1 c1, C2 c2) 02486 : f(f), c0(c0), c1(c1), c2(c2) {} 02487 02488 void operator()(A0 a0, A1 a1) { 02489 f(c0, c1, c2, a0, a1); 02490 } 02491 }; 02492 02493 template <typename F, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1> 02494 struct context42 { 02495 F f; C0 c0; C1 c1; C2 c2; C3 c3; 02496 02497 context42(F f, C0 c0, C1 c1, C2 c2, C3 c3) 02498 : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {} 02499 02500 void operator()(A0 a0, A1 a1) { 02501 f(c0, c1, c2, c3, a0, a1); 02502 } 02503 }; 02504 02505 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1> 02506 struct context52 { 02507 F f; C0 c0; C1 c1; C2 c2; C3 c3; C4 c4; 02508 02509 context52(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) 02510 : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {} 02511 02512 void operator()(A0 a0, A1 a1) { 02513 f(c0, c1, c2, c3, c4, a0, a1); 02514 } 02515 }; 02516 02517 template <typename F, typename A0, typename A1, typename A2> 02518 struct context03 { 02519 F f; 02520 02521 context03(F f) 02522 : f(f) {} 02523 02524 void operator()(A0 a0, A1 a1, A2 a2) { 02525 f(a0, a1, a2); 02526 } 02527 }; 02528 02529 template <typename F, typename C0, typename A0, typename A1, typename A2> 02530 struct context13 { 02531 F f; C0 c0; 02532 02533 context13(F f, C0 c0) 02534 : f(f), c0(c0) {} 02535 02536 void operator()(A0 a0, A1 a1, A2 a2) { 02537 f(c0, a0, a1, a2); 02538 } 02539 }; 02540 02541 template <typename F, typename C0, typename C1, typename A0, typename A1, typename A2> 02542 struct context23 { 02543 F f; C0 c0; C1 c1; 02544 02545 context23(F f, C0 c0, C1 c1) 02546 : f(f), c0(c0), c1(c1) {} 02547 02548 void operator()(A0 a0, A1 a1, A2 a2) { 02549 f(c0, c1, a0, a1, a2); 02550 } 02551 }; 02552 02553 template <typename F, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2> 02554 struct context33 { 02555 F f; C0 c0; C1 c1; C2 c2; 02556 02557 context33(F f, C0 c0, C1 c1, C2 c2) 02558 : f(f), c0(c0), c1(c1), c2(c2) {} 02559 02560 void operator()(A0 a0, A1 a1, A2 a2) { 02561 f(c0, c1, c2, a0, a1, a2); 02562 } 02563 }; 02564 02565 template <typename F, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2> 02566 struct context43 { 02567 F f; C0 c0; C1 c1; C2 c2; C3 c3; 02568 02569 context43(F f, C0 c0, C1 c1, C2 c2, C3 c3) 02570 : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {} 02571 02572 void operator()(A0 a0, A1 a1, A2 a2) { 02573 f(c0, c1, c2, c3, a0, a1, a2); 02574 } 02575 }; 02576 02577 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2> 02578 struct context53 { 02579 F f; C0 c0; C1 c1; C2 c2; C3 c3; C4 c4; 02580 02581 context53(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) 02582 : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {} 02583 02584 void operator()(A0 a0, A1 a1, A2 a2) { 02585 f(c0, c1, c2, c3, c4, a0, a1, a2); 02586 } 02587 }; 02588 02589 template <typename F, typename A0, typename A1, typename A2, typename A3> 02590 struct context04 { 02591 F f; 02592 02593 context04(F f) 02594 : f(f) {} 02595 02596 void operator()(A0 a0, A1 a1, A2 a2, A3 a3) { 02597 f(a0, a1, a2, a3); 02598 } 02599 }; 02600 02601 template <typename F, typename C0, typename A0, typename A1, typename A2, typename A3> 02602 struct context14 { 02603 F f; C0 c0; 02604 02605 context14(F f, C0 c0) 02606 : f(f), c0(c0) {} 02607 02608 void operator()(A0 a0, A1 a1, A2 a2, A3 a3) { 02609 f(c0, a0, a1, a2, a3); 02610 } 02611 }; 02612 02613 template <typename F, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3> 02614 struct context24 { 02615 F f; C0 c0; C1 c1; 02616 02617 context24(F f, C0 c0, C1 c1) 02618 : f(f), c0(c0), c1(c1) {} 02619 02620 void operator()(A0 a0, A1 a1, A2 a2, A3 a3) { 02621 f(c0, c1, a0, a1, a2, a3); 02622 } 02623 }; 02624 02625 template <typename F, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3> 02626 struct context34 { 02627 F f; C0 c0; C1 c1; C2 c2; 02628 02629 context34(F f, C0 c0, C1 c1, C2 c2) 02630 : f(f), c0(c0), c1(c1), c2(c2) {} 02631 02632 void operator()(A0 a0, A1 a1, A2 a2, A3 a3) { 02633 f(c0, c1, c2, a0, a1, a2, a3); 02634 } 02635 }; 02636 02637 template <typename F, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3> 02638 struct context44 { 02639 F f; C0 c0; C1 c1; C2 c2; C3 c3; 02640 02641 context44(F f, C0 c0, C1 c1, C2 c2, C3 c3) 02642 : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {} 02643 02644 void operator()(A0 a0, A1 a1, A2 a2, A3 a3) { 02645 f(c0, c1, c2, c3, a0, a1, a2, a3); 02646 } 02647 }; 02648 02649 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3> 02650 struct context54 { 02651 F f; C0 c0; C1 c1; C2 c2; C3 c3; C4 c4; 02652 02653 context54(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) 02654 : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {} 02655 02656 void operator()(A0 a0, A1 a1, A2 a2, A3 a3) { 02657 f(c0, c1, c2, c3, c4, a0, a1, a2, a3); 02658 } 02659 }; 02660 02661 template <typename F, typename A0, typename A1, typename A2, typename A3, typename A4> 02662 struct context05 { 02663 F f; 02664 02665 context05(F f) 02666 : f(f) {} 02667 02668 void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 02669 f(a0, a1, a2, a3, a4); 02670 } 02671 }; 02672 02673 template <typename F, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4> 02674 struct context15 { 02675 F f; C0 c0; 02676 02677 context15(F f, C0 c0) 02678 : f(f), c0(c0) {} 02679 02680 void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 02681 f(c0, a0, a1, a2, a3, a4); 02682 } 02683 }; 02684 02685 template <typename F, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4> 02686 struct context25 { 02687 F f; C0 c0; C1 c1; 02688 02689 context25(F f, C0 c0, C1 c1) 02690 : f(f), c0(c0), c1(c1) {} 02691 02692 void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 02693 f(c0, c1, a0, a1, a2, a3, a4); 02694 } 02695 }; 02696 02697 template <typename F, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3, typename A4> 02698 struct context35 { 02699 F f; C0 c0; C1 c1; C2 c2; 02700 02701 context35(F f, C0 c0, C1 c1, C2 c2) 02702 : f(f), c0(c0), c1(c1), c2(c2) {} 02703 02704 void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 02705 f(c0, c1, c2, a0, a1, a2, a3, a4); 02706 } 02707 }; 02708 02709 template <typename F, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3, typename A4> 02710 struct context45 { 02711 F f; C0 c0; C1 c1; C2 c2; C3 c3; 02712 02713 context45(F f, C0 c0, C1 c1, C2 c2, C3 c3) 02714 : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {} 02715 02716 void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 02717 f(c0, c1, c2, c3, a0, a1, a2, a3, a4); 02718 } 02719 }; 02720 02721 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3, typename A4> 02722 struct context55 { 02723 F f; C0 c0; C1 c1; C2 c2; C3 c3; C4 c4; 02724 02725 context55(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) 02726 : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {} 02727 02728 void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 02729 f(c0, c1, c2, c3, c4, a0, a1, a2, a3, a4); 02730 } 02731 }; 02732 }; 02733 02734 } 02735 02736 #endif 02737
Generated on Tue Jul 12 2022 12:21:50 by
1.7.2