Marco Zecchini
/
Example_RTOS
Rtos API example
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 garuntee 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 * The specified callback will be executed in the context of the event 00706 * queue's dispatch loop. 00707 * 00708 * The call_every function is irq safe and can act as a mechanism for 00709 * moving events out of irq contexts. 00710 * 00711 * @param f Function to execute in the context of the dispatch loop 00712 * @param ms Period of the event in milliseconds 00713 * @return A unique id that represents the posted event and can 00714 * be passed to cancel, or an id of 0 if there is not 00715 * enough memory to allocate the event. 00716 */ 00717 template <typename F> 00718 int call_every(int ms, F f) { 00719 void *p = equeue_alloc(&_equeue, sizeof(F)); 00720 if (!p) { 00721 return 0; 00722 } 00723 00724 F *e = new (p) F(f); 00725 equeue_event_delay(e, ms); 00726 equeue_event_period(e, ms); 00727 equeue_event_dtor(e, &EventQueue::function_dtor<F>); 00728 return equeue_post(&_equeue, &EventQueue::function_call<F>, e); 00729 } 00730 00731 /** Calls an event on the queue periodically 00732 * @see EventQueue::call_every 00733 * @param f Function to execute in the context of the dispatch loop 00734 * @param a0 Argument to pass to the callback 00735 * @param ms Period of the event in milliseconds 00736 */ 00737 template <typename F, typename A0> 00738 int call_every(int ms, F f, A0 a0) { 00739 return call_every(ms, context10<F, A0>(f, a0)); 00740 } 00741 00742 /** Calls an event on the queue periodically 00743 * @see EventQueue::call_every 00744 * @param f Function to execute in the context of the dispatch loop 00745 * @param a0,a1 Arguments to pass to the callback 00746 * @param ms Period of the event in milliseconds 00747 */ 00748 template <typename F, typename A0, typename A1> 00749 int call_every(int ms, F f, A0 a0, A1 a1) { 00750 return call_every(ms, context20<F, A0, A1>(f, a0, a1)); 00751 } 00752 00753 /** Calls an event on the queue periodically 00754 * @see EventQueue::call_every 00755 * @param f Function to execute in the context of the dispatch loop 00756 * @param a0,a1,a2 Arguments to pass to the callback 00757 * @param ms Period of the event in milliseconds 00758 */ 00759 template <typename F, typename A0, typename A1, typename A2> 00760 int call_every(int ms, F f, A0 a0, A1 a1, A2 a2) { 00761 return call_every(ms, context30<F, A0, A1, A2>(f, a0, a1, a2)); 00762 } 00763 00764 /** Calls an event on the queue periodically 00765 * @see EventQueue::call_every 00766 * @param f Function to execute in the context of the dispatch loop 00767 * @param a0,a1,a2,a3 Arguments to pass to the callback 00768 * @param ms Period of the event in milliseconds 00769 */ 00770 template <typename F, typename A0, typename A1, typename A2, typename A3> 00771 int call_every(int ms, F f, A0 a0, A1 a1, A2 a2, A3 a3) { 00772 return call_every(ms, context40<F, A0, A1, A2, A3>(f, a0, a1, a2, a3)); 00773 } 00774 00775 /** Calls an event on the queue periodically 00776 * @see EventQueue::call_every 00777 * @param f Function to execute in the context of the dispatch loop 00778 * @param a0,a1,a2,a3,a4 Arguments to pass to the callback 00779 * @param ms Period of the event in milliseconds 00780 */ 00781 template <typename F, typename A0, typename A1, typename A2, typename A3, typename A4> 00782 int call_every(int ms, F f, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 00783 return call_every(ms, context50<F, A0, A1, A2, A3, A4>(f, a0, a1, a2, a3, a4)); 00784 } 00785 00786 /** Calls an event on the queue periodically 00787 * @see EventQueue::call_every 00788 */ 00789 template <typename T, typename R> 00790 int call_every(int ms, T *obj, R (T::*method)()) { 00791 return call_every(ms, mbed::callback(obj, method)); 00792 } 00793 00794 /** Calls an event on the queue periodically 00795 * @see EventQueue::call_every 00796 */ 00797 template <typename T, typename R> 00798 int call_every(int ms, const T *obj, R (T::*method)() const) { 00799 return call_every(ms, mbed::callback(obj, method)); 00800 } 00801 00802 /** Calls an event on the queue periodically 00803 * @see EventQueue::call_every 00804 */ 00805 template <typename T, typename R> 00806 int call_every(int ms, volatile T *obj, R (T::*method)() volatile) { 00807 return call_every(ms, mbed::callback(obj, method)); 00808 } 00809 00810 /** Calls an event on the queue periodically 00811 * @see EventQueue::call_every 00812 */ 00813 template <typename T, typename R> 00814 int call_every(int ms, const volatile T *obj, R (T::*method)() const volatile) { 00815 return call_every(ms, mbed::callback(obj, method)); 00816 } 00817 00818 /** Calls an event on the queue periodically 00819 * @see EventQueue::call_every 00820 */ 00821 template <typename T, typename R, typename A0> 00822 int call_every(int ms, T *obj, R (T::*method)(A0), A0 a0) { 00823 return call_every(ms, mbed::callback(obj, method), a0); 00824 } 00825 00826 /** Calls an event on the queue periodically 00827 * @see EventQueue::call_every 00828 */ 00829 template <typename T, typename R, typename A0> 00830 int call_every(int ms, const T *obj, R (T::*method)(A0) const, A0 a0) { 00831 return call_every(ms, mbed::callback(obj, method), a0); 00832 } 00833 00834 /** Calls an event on the queue periodically 00835 * @see EventQueue::call_every 00836 */ 00837 template <typename T, typename R, typename A0> 00838 int call_every(int ms, volatile T *obj, R (T::*method)(A0) volatile, A0 a0) { 00839 return call_every(ms, mbed::callback(obj, method), a0); 00840 } 00841 00842 /** Calls an event on the queue periodically 00843 * @see EventQueue::call_every 00844 */ 00845 template <typename T, typename R, typename A0> 00846 int call_every(int ms, const volatile T *obj, R (T::*method)(A0) const volatile, A0 a0) { 00847 return call_every(ms, mbed::callback(obj, method), a0); 00848 } 00849 00850 /** Calls an event on the queue periodically 00851 * @see EventQueue::call_every 00852 */ 00853 template <typename T, typename R, typename A0, typename A1> 00854 int call_every(int ms, T *obj, R (T::*method)(A0, A1), A0 a0, A1 a1) { 00855 return call_every(ms, mbed::callback(obj, method), a0, a1); 00856 } 00857 00858 /** Calls an event on the queue periodically 00859 * @see EventQueue::call_every 00860 */ 00861 template <typename T, typename R, typename A0, typename A1> 00862 int call_every(int ms, const T *obj, R (T::*method)(A0, A1) const, A0 a0, A1 a1) { 00863 return call_every(ms, mbed::callback(obj, method), a0, a1); 00864 } 00865 00866 /** Calls an event on the queue periodically 00867 * @see EventQueue::call_every 00868 */ 00869 template <typename T, typename R, typename A0, typename A1> 00870 int call_every(int ms, volatile T *obj, R (T::*method)(A0, A1) volatile, A0 a0, A1 a1) { 00871 return call_every(ms, mbed::callback(obj, method), a0, a1); 00872 } 00873 00874 /** Calls an event on the queue periodically 00875 * @see EventQueue::call_every 00876 */ 00877 template <typename T, typename R, typename A0, typename A1> 00878 int call_every(int ms, const volatile T *obj, R (T::*method)(A0, A1) const volatile, A0 a0, A1 a1) { 00879 return call_every(ms, mbed::callback(obj, method), a0, a1); 00880 } 00881 00882 /** Calls an event on the queue periodically 00883 * @see EventQueue::call_every 00884 */ 00885 template <typename T, typename R, typename A0, typename A1, typename A2> 00886 int call_every(int ms, T *obj, R (T::*method)(A0, A1, A2), A0 a0, A1 a1, A2 a2) { 00887 return call_every(ms, mbed::callback(obj, method), a0, a1, a2); 00888 } 00889 00890 /** Calls an event on the queue periodically 00891 * @see EventQueue::call_every 00892 */ 00893 template <typename T, typename R, typename A0, typename A1, typename A2> 00894 int call_every(int ms, const T *obj, R (T::*method)(A0, A1, A2) const, A0 a0, A1 a1, A2 a2) { 00895 return call_every(ms, mbed::callback(obj, method), a0, a1, a2); 00896 } 00897 00898 /** Calls an event on the queue periodically 00899 * @see EventQueue::call_every 00900 */ 00901 template <typename T, typename R, typename A0, typename A1, typename A2> 00902 int call_every(int ms, volatile T *obj, R (T::*method)(A0, A1, A2) volatile, A0 a0, A1 a1, A2 a2) { 00903 return call_every(ms, mbed::callback(obj, method), a0, a1, a2); 00904 } 00905 00906 /** Calls an event on the queue periodically 00907 * @see EventQueue::call_every 00908 */ 00909 template <typename T, typename R, typename A0, typename A1, typename A2> 00910 int call_every(int ms, const volatile T *obj, R (T::*method)(A0, A1, A2) const volatile, A0 a0, A1 a1, A2 a2) { 00911 return call_every(ms, mbed::callback(obj, method), a0, a1, a2); 00912 } 00913 00914 /** Calls an event on the queue periodically 00915 * @see EventQueue::call_every 00916 */ 00917 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 00918 int call_every(int ms, T *obj, R (T::*method)(A0, A1, A2, A3), A0 a0, A1 a1, A2 a2, A3 a3) { 00919 return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3); 00920 } 00921 00922 /** Calls an event on the queue periodically 00923 * @see EventQueue::call_every 00924 */ 00925 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 00926 int call_every(int ms, const T *obj, R (T::*method)(A0, A1, A2, A3) const, A0 a0, A1 a1, A2 a2, A3 a3) { 00927 return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3); 00928 } 00929 00930 /** Calls an event on the queue periodically 00931 * @see EventQueue::call_every 00932 */ 00933 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 00934 int call_every(int ms, volatile T *obj, R (T::*method)(A0, A1, A2, A3) volatile, A0 a0, A1 a1, A2 a2, A3 a3) { 00935 return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3); 00936 } 00937 00938 /** Calls an event on the queue periodically 00939 * @see EventQueue::call_every 00940 */ 00941 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 00942 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) { 00943 return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3); 00944 } 00945 00946 /** Calls an event on the queue periodically 00947 * @see EventQueue::call_every 00948 */ 00949 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 00950 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) { 00951 return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4); 00952 } 00953 00954 /** Calls an event on the queue periodically 00955 * @see EventQueue::call_every 00956 */ 00957 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 00958 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) { 00959 return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4); 00960 } 00961 00962 /** Calls an event on the queue periodically 00963 * @see EventQueue::call_every 00964 */ 00965 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 00966 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) { 00967 return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4); 00968 } 00969 00970 /** Calls an event on the queue periodically 00971 * @see EventQueue::call_every 00972 */ 00973 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 00974 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) { 00975 return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4); 00976 } 00977 00978 /** Creates an event bound to the event queue 00979 * 00980 * Constructs an event bound to the specified event queue. The specified 00981 * callback acts as the target for the event and is executed in the 00982 * context of the event queue's dispatch loop once posted. 00983 * 00984 * @param func Function to execute when the event is dispatched 00985 * @return Event that will dispatch on the specific queue 00986 */ 00987 template <typename R> 00988 Event<void()> event(R (*func)()); 00989 00990 /** Creates an event bound to the event queue 00991 * @see EventQueue::event 00992 */ 00993 template <typename T, typename R> 00994 Event<void()> event(T *obj, R (T::*method)()); 00995 00996 /** Creates an event bound to the event queue 00997 * @see EventQueue::event 00998 */ 00999 template <typename T, typename R> 01000 Event<void()> event(const T *obj, R (T::*method)() const); 01001 01002 /** Creates an event bound to the event queue 01003 * @see EventQueue::event 01004 */ 01005 template <typename T, typename R> 01006 Event<void()> event(volatile T *obj, R (T::*method)() volatile); 01007 01008 /** Creates an event bound to the event queue 01009 * @see EventQueue::event 01010 */ 01011 template <typename T, typename R> 01012 Event<void()> event(const volatile T *obj, R (T::*method)() const volatile); 01013 01014 /** Creates an event bound to the event queue 01015 * @see EventQueue::event 01016 */ 01017 template <typename R> 01018 Event<void()> event(mbed::Callback<R()> cb); 01019 01020 /** Creates an event bound to the event queue 01021 * @see EventQueue::event 01022 */ 01023 template <typename R, typename B0, typename C0> 01024 Event<void()> event(R (*func)(B0), C0 c0); 01025 01026 /** Creates an event bound to the event queue 01027 * @see EventQueue::event 01028 */ 01029 template <typename T, typename R, typename B0, typename C0> 01030 Event<void()> event(T *obj, R (T::*method)(B0), C0 c0); 01031 01032 /** Creates an event bound to the event queue 01033 * @see EventQueue::event 01034 */ 01035 template <typename T, typename R, typename B0, typename C0> 01036 Event<void()> event(const T *obj, R (T::*method)(B0) const, C0 c0); 01037 01038 /** Creates an event bound to the event queue 01039 * @see EventQueue::event 01040 */ 01041 template <typename T, typename R, typename B0, typename C0> 01042 Event<void()> event(volatile T *obj, R (T::*method)(B0) volatile, C0 c0); 01043 01044 /** Creates an event bound to the event queue 01045 * @see EventQueue::event 01046 */ 01047 template <typename T, typename R, typename B0, typename C0> 01048 Event<void()> event(const volatile T *obj, R (T::*method)(B0) const volatile, C0 c0); 01049 01050 /** Creates an event bound to the event queue 01051 * @see EventQueue::event 01052 */ 01053 template <typename R, typename B0, typename C0> 01054 Event<void()> event(mbed::Callback<R(B0)> cb, C0 c0); 01055 01056 /** Creates an event bound to the event queue 01057 * @see EventQueue::event 01058 */ 01059 template <typename R, typename B0, typename B1, typename C0, typename C1> 01060 Event<void()> event(R (*func)(B0, B1), C0 c0, C1 c1); 01061 01062 /** Creates an event bound to the event queue 01063 * @see EventQueue::event 01064 */ 01065 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1> 01066 Event<void()> event(T *obj, R (T::*method)(B0, B1), C0 c0, C1 c1); 01067 01068 /** Creates an event bound to the event queue 01069 * @see EventQueue::event 01070 */ 01071 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1> 01072 Event<void()> event(const T *obj, R (T::*method)(B0, B1) const, C0 c0, C1 c1); 01073 01074 /** Creates an event bound to the event queue 01075 * @see EventQueue::event 01076 */ 01077 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1> 01078 Event<void()> event(volatile T *obj, R (T::*method)(B0, B1) volatile, C0 c0, C1 c1); 01079 01080 /** Creates an event bound to the event queue 01081 * @see EventQueue::event 01082 */ 01083 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1> 01084 Event<void()> event(const volatile T *obj, R (T::*method)(B0, B1) const volatile, C0 c0, C1 c1); 01085 01086 /** Creates an event bound to the event queue 01087 * @see EventQueue::event 01088 */ 01089 template <typename R, typename B0, typename B1, typename C0, typename C1> 01090 Event<void()> event(mbed::Callback<R(B0, B1)> cb, C0 c0, C1 c1); 01091 01092 /** Creates an event bound to the event queue 01093 * @see EventQueue::event 01094 */ 01095 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2> 01096 Event<void()> event(R (*func)(B0, B1, B2), C0 c0, C1 c1, C2 c2); 01097 01098 /** Creates an event bound to the event queue 01099 * @see EventQueue::event 01100 */ 01101 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2> 01102 Event<void()> event(T *obj, R (T::*method)(B0, B1, B2), C0 c0, C1 c1, C2 c2); 01103 01104 /** Creates an event bound to the event queue 01105 * @see EventQueue::event 01106 */ 01107 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2> 01108 Event<void()> event(const T *obj, R (T::*method)(B0, B1, B2) const, C0 c0, C1 c1, C2 c2); 01109 01110 /** Creates an event bound to the event queue 01111 * @see EventQueue::event 01112 */ 01113 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2> 01114 Event<void()> event(volatile T *obj, R (T::*method)(B0, B1, B2) volatile, C0 c0, C1 c1, C2 c2); 01115 01116 /** Creates an event bound to the event queue 01117 * @see EventQueue::event 01118 */ 01119 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2> 01120 Event<void()> event(const volatile T *obj, R (T::*method)(B0, B1, B2) const volatile, C0 c0, C1 c1, C2 c2); 01121 01122 /** Creates an event bound to the event queue 01123 * @see EventQueue::event 01124 */ 01125 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2> 01126 Event<void()> event(mbed::Callback<R(B0, B1, B2)> cb, C0 c0, C1 c1, C2 c2); 01127 01128 /** Creates an event bound to the event queue 01129 * @see EventQueue::event 01130 */ 01131 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3> 01132 Event<void()> event(R (*func)(B0, B1, B2, B3), C0 c0, C1 c1, C2 c2, C3 c3); 01133 01134 /** Creates an event bound to the event queue 01135 * @see EventQueue::event 01136 */ 01137 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3> 01138 Event<void()> event(T *obj, R (T::*method)(B0, B1, B2, B3), C0 c0, C1 c1, C2 c2, C3 c3); 01139 01140 /** Creates an event bound to the event queue 01141 * @see EventQueue::event 01142 */ 01143 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3> 01144 Event<void()> event(const T *obj, R (T::*method)(B0, B1, B2, B3) const, C0 c0, C1 c1, C2 c2, C3 c3); 01145 01146 /** Creates an event bound to the event queue 01147 * @see EventQueue::event 01148 */ 01149 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3> 01150 Event<void()> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3) volatile, C0 c0, C1 c1, C2 c2, C3 c3); 01151 01152 /** Creates an event bound to the event queue 01153 * @see EventQueue::event 01154 */ 01155 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3> 01156 Event<void()> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3) const volatile, C0 c0, C1 c1, C2 c2, C3 c3); 01157 01158 /** Creates an event bound to the event queue 01159 * @see EventQueue::event 01160 */ 01161 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3> 01162 Event<void()> event(mbed::Callback<R(B0, B1, B2, B3)> cb, C0 c0, C1 c1, C2 c2, C3 c3); 01163 01164 /** Creates an event bound to the event queue 01165 * @see EventQueue::event 01166 */ 01167 template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4> 01168 Event<void()> event(R (*func)(B0, B1, B2, B3, B4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4); 01169 01170 /** Creates an event bound to the event queue 01171 * @see EventQueue::event 01172 */ 01173 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> 01174 Event<void()> event(T *obj, R (T::*method)(B0, B1, B2, B3, B4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4); 01175 01176 /** Creates an event bound to the event queue 01177 * @see EventQueue::event 01178 */ 01179 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> 01180 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); 01181 01182 /** Creates an event bound to the event queue 01183 * @see EventQueue::event 01184 */ 01185 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> 01186 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); 01187 01188 /** Creates an event bound to the event queue 01189 * @see EventQueue::event 01190 */ 01191 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> 01192 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); 01193 01194 /** Creates an event bound to the event queue 01195 * @see EventQueue::event 01196 */ 01197 template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4> 01198 Event<void()> event(mbed::Callback<R(B0, B1, B2, B3, B4)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4); 01199 01200 /** Creates an event bound to the event queue 01201 * @see EventQueue::event 01202 */ 01203 template <typename R, typename A0> 01204 Event<void(A0)> event(R (*func)(A0)); 01205 01206 /** Creates an event bound to the event queue 01207 * @see EventQueue::event 01208 */ 01209 template <typename T, typename R, typename A0> 01210 Event<void(A0)> event(T *obj, R (T::*method)(A0)); 01211 01212 /** Creates an event bound to the event queue 01213 * @see EventQueue::event 01214 */ 01215 template <typename T, typename R, typename A0> 01216 Event<void(A0)> event(const T *obj, R (T::*method)(A0) const); 01217 01218 /** Creates an event bound to the event queue 01219 * @see EventQueue::event 01220 */ 01221 template <typename T, typename R, typename A0> 01222 Event<void(A0)> event(volatile T *obj, R (T::*method)(A0) volatile); 01223 01224 /** Creates an event bound to the event queue 01225 * @see EventQueue::event 01226 */ 01227 template <typename T, typename R, typename A0> 01228 Event<void(A0)> event(const volatile T *obj, R (T::*method)(A0) const volatile); 01229 01230 /** Creates an event bound to the event queue 01231 * @see EventQueue::event 01232 */ 01233 template <typename R, typename A0> 01234 Event<void(A0)> event(mbed::Callback<R(A0)> cb); 01235 01236 /** Creates an event bound to the event queue 01237 * @see EventQueue::event 01238 */ 01239 template <typename R, typename B0, typename C0, typename A0> 01240 Event<void(A0)> event(R (*func)(B0, A0), C0 c0); 01241 01242 /** Creates an event bound to the event queue 01243 * @see EventQueue::event 01244 */ 01245 template <typename T, typename R, typename B0, typename C0, typename A0> 01246 Event<void(A0)> event(T *obj, R (T::*method)(B0, A0), C0 c0); 01247 01248 /** Creates an event bound to the event queue 01249 * @see EventQueue::event 01250 */ 01251 template <typename T, typename R, typename B0, typename C0, typename A0> 01252 Event<void(A0)> event(const T *obj, R (T::*method)(B0, A0) const, C0 c0); 01253 01254 /** Creates an event bound to the event queue 01255 * @see EventQueue::event 01256 */ 01257 template <typename T, typename R, typename B0, typename C0, typename A0> 01258 Event<void(A0)> event(volatile T *obj, R (T::*method)(B0, A0) volatile, C0 c0); 01259 01260 /** Creates an event bound to the event queue 01261 * @see EventQueue::event 01262 */ 01263 template <typename T, typename R, typename B0, typename C0, typename A0> 01264 Event<void(A0)> event(const volatile T *obj, R (T::*method)(B0, A0) const volatile, C0 c0); 01265 01266 /** Creates an event bound to the event queue 01267 * @see EventQueue::event 01268 */ 01269 template <typename R, typename B0, typename C0, typename A0> 01270 Event<void(A0)> event(mbed::Callback<R(B0, A0)> cb, C0 c0); 01271 01272 /** Creates an event bound to the event queue 01273 * @see EventQueue::event 01274 */ 01275 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0> 01276 Event<void(A0)> event(R (*func)(B0, B1, A0), C0 c0, C1 c1); 01277 01278 /** Creates an event bound to the event queue 01279 * @see EventQueue::event 01280 */ 01281 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0> 01282 Event<void(A0)> event(T *obj, R (T::*method)(B0, B1, A0), C0 c0, C1 c1); 01283 01284 /** Creates an event bound to the event queue 01285 * @see EventQueue::event 01286 */ 01287 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0> 01288 Event<void(A0)> event(const T *obj, R (T::*method)(B0, B1, A0) const, C0 c0, C1 c1); 01289 01290 /** Creates an event bound to the event queue 01291 * @see EventQueue::event 01292 */ 01293 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0> 01294 Event<void(A0)> event(volatile T *obj, R (T::*method)(B0, B1, A0) volatile, C0 c0, C1 c1); 01295 01296 /** Creates an event bound to the event queue 01297 * @see EventQueue::event 01298 */ 01299 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0> 01300 Event<void(A0)> event(const volatile T *obj, R (T::*method)(B0, B1, A0) const volatile, C0 c0, C1 c1); 01301 01302 /** Creates an event bound to the event queue 01303 * @see EventQueue::event 01304 */ 01305 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0> 01306 Event<void(A0)> event(mbed::Callback<R(B0, B1, A0)> cb, C0 c0, C1 c1); 01307 01308 /** Creates an event bound to the event queue 01309 * @see EventQueue::event 01310 */ 01311 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0> 01312 Event<void(A0)> event(R (*func)(B0, B1, B2, A0), C0 c0, C1 c1, C2 c2); 01313 01314 /** Creates an event bound to the event queue 01315 * @see EventQueue::event 01316 */ 01317 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0> 01318 Event<void(A0)> event(T *obj, R (T::*method)(B0, B1, B2, A0), C0 c0, C1 c1, C2 c2); 01319 01320 /** Creates an event bound to the event queue 01321 * @see EventQueue::event 01322 */ 01323 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0> 01324 Event<void(A0)> event(const T *obj, R (T::*method)(B0, B1, B2, A0) const, C0 c0, C1 c1, C2 c2); 01325 01326 /** Creates an event bound to the event queue 01327 * @see EventQueue::event 01328 */ 01329 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0> 01330 Event<void(A0)> event(volatile T *obj, R (T::*method)(B0, B1, B2, A0) volatile, C0 c0, C1 c1, C2 c2); 01331 01332 /** Creates an event bound to the event queue 01333 * @see EventQueue::event 01334 */ 01335 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0> 01336 Event<void(A0)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, A0) const volatile, C0 c0, C1 c1, C2 c2); 01337 01338 /** Creates an event bound to the event queue 01339 * @see EventQueue::event 01340 */ 01341 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0> 01342 Event<void(A0)> event(mbed::Callback<R(B0, B1, B2, A0)> cb, C0 c0, C1 c1, C2 c2); 01343 01344 /** Creates an event bound to the event queue 01345 * @see EventQueue::event 01346 */ 01347 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0> 01348 Event<void(A0)> event(R (*func)(B0, B1, B2, B3, A0), C0 c0, C1 c1, C2 c2, C3 c3); 01349 01350 /** Creates an event bound to the event queue 01351 * @see EventQueue::event 01352 */ 01353 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0> 01354 Event<void(A0)> event(T *obj, R (T::*method)(B0, B1, B2, B3, A0), C0 c0, C1 c1, C2 c2, C3 c3); 01355 01356 /** Creates an event bound to the event queue 01357 * @see EventQueue::event 01358 */ 01359 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0> 01360 Event<void(A0)> event(const T *obj, R (T::*method)(B0, B1, B2, B3, A0) const, C0 c0, C1 c1, C2 c2, C3 c3); 01361 01362 /** Creates an event bound to the event queue 01363 * @see EventQueue::event 01364 */ 01365 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0> 01366 Event<void(A0)> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0) volatile, C0 c0, C1 c1, C2 c2, C3 c3); 01367 01368 /** Creates an event bound to the event queue 01369 * @see EventQueue::event 01370 */ 01371 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0> 01372 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); 01373 01374 /** Creates an event bound to the event queue 01375 * @see EventQueue::event 01376 */ 01377 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0> 01378 Event<void(A0)> event(mbed::Callback<R(B0, B1, B2, B3, A0)> cb, C0 c0, C1 c1, C2 c2, C3 c3); 01379 01380 /** Creates an event bound to the event queue 01381 * @see EventQueue::event 01382 */ 01383 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> 01384 Event<void(A0)> event(R (*func)(B0, B1, B2, B3, B4, A0), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4); 01385 01386 /** Creates an event bound to the event queue 01387 * @see EventQueue::event 01388 */ 01389 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> 01390 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); 01391 01392 /** Creates an event bound to the event queue 01393 * @see EventQueue::event 01394 */ 01395 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> 01396 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); 01397 01398 /** Creates an event bound to the event queue 01399 * @see EventQueue::event 01400 */ 01401 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> 01402 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); 01403 01404 /** Creates an event bound to the event queue 01405 * @see EventQueue::event 01406 */ 01407 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> 01408 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); 01409 01410 /** Creates an event bound to the event queue 01411 * @see EventQueue::event 01412 */ 01413 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> 01414 Event<void(A0)> event(mbed::Callback<R(B0, B1, B2, B3, B4, A0)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4); 01415 01416 /** Creates an event bound to the event queue 01417 * @see EventQueue::event 01418 */ 01419 template <typename R, typename A0, typename A1> 01420 Event<void(A0, A1)> event(R (*func)(A0, A1)); 01421 01422 /** Creates an event bound to the event queue 01423 * @see EventQueue::event 01424 */ 01425 template <typename T, typename R, typename A0, typename A1> 01426 Event<void(A0, A1)> event(T *obj, R (T::*method)(A0, A1)); 01427 01428 /** Creates an event bound to the event queue 01429 * @see EventQueue::event 01430 */ 01431 template <typename T, typename R, typename A0, typename A1> 01432 Event<void(A0, A1)> event(const T *obj, R (T::*method)(A0, A1) const); 01433 01434 /** Creates an event bound to the event queue 01435 * @see EventQueue::event 01436 */ 01437 template <typename T, typename R, typename A0, typename A1> 01438 Event<void(A0, A1)> event(volatile T *obj, R (T::*method)(A0, A1) volatile); 01439 01440 /** Creates an event bound to the event queue 01441 * @see EventQueue::event 01442 */ 01443 template <typename T, typename R, typename A0, typename A1> 01444 Event<void(A0, A1)> event(const volatile T *obj, R (T::*method)(A0, A1) const volatile); 01445 01446 /** Creates an event bound to the event queue 01447 * @see EventQueue::event 01448 */ 01449 template <typename R, typename A0, typename A1> 01450 Event<void(A0, A1)> event(mbed::Callback<R(A0, A1)> cb); 01451 01452 /** Creates an event bound to the event queue 01453 * @see EventQueue::event 01454 */ 01455 template <typename R, typename B0, typename C0, typename A0, typename A1> 01456 Event<void(A0, A1)> event(R (*func)(B0, A0, A1), C0 c0); 01457 01458 /** Creates an event bound to the event queue 01459 * @see EventQueue::event 01460 */ 01461 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1> 01462 Event<void(A0, A1)> event(T *obj, R (T::*method)(B0, A0, A1), C0 c0); 01463 01464 /** Creates an event bound to the event queue 01465 * @see EventQueue::event 01466 */ 01467 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1> 01468 Event<void(A0, A1)> event(const T *obj, R (T::*method)(B0, A0, A1) const, C0 c0); 01469 01470 /** Creates an event bound to the event queue 01471 * @see EventQueue::event 01472 */ 01473 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1> 01474 Event<void(A0, A1)> event(volatile T *obj, R (T::*method)(B0, A0, A1) volatile, C0 c0); 01475 01476 /** Creates an event bound to the event queue 01477 * @see EventQueue::event 01478 */ 01479 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1> 01480 Event<void(A0, A1)> event(const volatile T *obj, R (T::*method)(B0, A0, A1) const volatile, C0 c0); 01481 01482 /** Creates an event bound to the event queue 01483 * @see EventQueue::event 01484 */ 01485 template <typename R, typename B0, typename C0, typename A0, typename A1> 01486 Event<void(A0, A1)> event(mbed::Callback<R(B0, A0, A1)> cb, C0 c0); 01487 01488 /** Creates an event bound to the event queue 01489 * @see EventQueue::event 01490 */ 01491 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1> 01492 Event<void(A0, A1)> event(R (*func)(B0, B1, A0, A1), C0 c0, C1 c1); 01493 01494 /** Creates an event bound to the event queue 01495 * @see EventQueue::event 01496 */ 01497 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1> 01498 Event<void(A0, A1)> event(T *obj, R (T::*method)(B0, B1, A0, A1), C0 c0, C1 c1); 01499 01500 /** Creates an event bound to the event queue 01501 * @see EventQueue::event 01502 */ 01503 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1> 01504 Event<void(A0, A1)> event(const T *obj, R (T::*method)(B0, B1, A0, A1) const, C0 c0, C1 c1); 01505 01506 /** Creates an event bound to the event queue 01507 * @see EventQueue::event 01508 */ 01509 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1> 01510 Event<void(A0, A1)> event(volatile T *obj, R (T::*method)(B0, B1, A0, A1) volatile, C0 c0, C1 c1); 01511 01512 /** Creates an event bound to the event queue 01513 * @see EventQueue::event 01514 */ 01515 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1> 01516 Event<void(A0, A1)> event(const volatile T *obj, R (T::*method)(B0, B1, A0, A1) const volatile, C0 c0, C1 c1); 01517 01518 /** Creates an event bound to the event queue 01519 * @see EventQueue::event 01520 */ 01521 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1> 01522 Event<void(A0, A1)> event(mbed::Callback<R(B0, B1, A0, A1)> cb, C0 c0, C1 c1); 01523 01524 /** Creates an event bound to the event queue 01525 * @see EventQueue::event 01526 */ 01527 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1> 01528 Event<void(A0, A1)> event(R (*func)(B0, B1, B2, A0, A1), C0 c0, C1 c1, C2 c2); 01529 01530 /** Creates an event bound to the event queue 01531 * @see EventQueue::event 01532 */ 01533 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1> 01534 Event<void(A0, A1)> event(T *obj, R (T::*method)(B0, B1, B2, A0, A1), C0 c0, C1 c1, C2 c2); 01535 01536 /** Creates an event bound to the event queue 01537 * @see EventQueue::event 01538 */ 01539 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1> 01540 Event<void(A0, A1)> event(const T *obj, R (T::*method)(B0, B1, B2, A0, A1) const, C0 c0, C1 c1, C2 c2); 01541 01542 /** Creates an event bound to the event queue 01543 * @see EventQueue::event 01544 */ 01545 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1> 01546 Event<void(A0, A1)> event(volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1) volatile, C0 c0, C1 c1, C2 c2); 01547 01548 /** Creates an event bound to the event queue 01549 * @see EventQueue::event 01550 */ 01551 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1> 01552 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); 01553 01554 /** Creates an event bound to the event queue 01555 * @see EventQueue::event 01556 */ 01557 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1> 01558 Event<void(A0, A1)> event(mbed::Callback<R(B0, B1, B2, A0, A1)> cb, C0 c0, C1 c1, C2 c2); 01559 01560 /** Creates an event bound to the event queue 01561 * @see EventQueue::event 01562 */ 01563 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1> 01564 Event<void(A0, A1)> event(R (*func)(B0, B1, B2, B3, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3); 01565 01566 /** Creates an event bound to the event queue 01567 * @see EventQueue::event 01568 */ 01569 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> 01570 Event<void(A0, A1)> event(T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3); 01571 01572 /** Creates an event bound to the event queue 01573 * @see EventQueue::event 01574 */ 01575 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> 01576 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); 01577 01578 /** Creates an event bound to the event queue 01579 * @see EventQueue::event 01580 */ 01581 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> 01582 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); 01583 01584 /** Creates an event bound to the event queue 01585 * @see EventQueue::event 01586 */ 01587 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> 01588 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); 01589 01590 /** Creates an event bound to the event queue 01591 * @see EventQueue::event 01592 */ 01593 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1> 01594 Event<void(A0, A1)> event(mbed::Callback<R(B0, B1, B2, B3, A0, A1)> cb, C0 c0, C1 c1, C2 c2, C3 c3); 01595 01596 /** Creates an event bound to the event queue 01597 * @see EventQueue::event 01598 */ 01599 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> 01600 Event<void(A0, A1)> event(R (*func)(B0, B1, B2, B3, B4, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4); 01601 01602 /** Creates an event bound to the event queue 01603 * @see EventQueue::event 01604 */ 01605 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> 01606 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); 01607 01608 /** Creates an event bound to the event queue 01609 * @see EventQueue::event 01610 */ 01611 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> 01612 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); 01613 01614 /** Creates an event bound to the event queue 01615 * @see EventQueue::event 01616 */ 01617 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> 01618 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); 01619 01620 /** Creates an event bound to the event queue 01621 * @see EventQueue::event 01622 */ 01623 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> 01624 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); 01625 01626 /** Creates an event bound to the event queue 01627 * @see EventQueue::event 01628 */ 01629 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> 01630 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); 01631 01632 /** Creates an event bound to the event queue 01633 * @see EventQueue::event 01634 */ 01635 template <typename R, typename A0, typename A1, typename A2> 01636 Event<void(A0, A1, A2)> event(R (*func)(A0, A1, A2)); 01637 01638 /** Creates an event bound to the event queue 01639 * @see EventQueue::event 01640 */ 01641 template <typename T, typename R, typename A0, typename A1, typename A2> 01642 Event<void(A0, A1, A2)> event(T *obj, R (T::*method)(A0, A1, A2)); 01643 01644 /** Creates an event bound to the event queue 01645 * @see EventQueue::event 01646 */ 01647 template <typename T, typename R, typename A0, typename A1, typename A2> 01648 Event<void(A0, A1, A2)> event(const T *obj, R (T::*method)(A0, A1, A2) const); 01649 01650 /** Creates an event bound to the event queue 01651 * @see EventQueue::event 01652 */ 01653 template <typename T, typename R, typename A0, typename A1, typename A2> 01654 Event<void(A0, A1, A2)> event(volatile T *obj, R (T::*method)(A0, A1, A2) volatile); 01655 01656 /** Creates an event bound to the event queue 01657 * @see EventQueue::event 01658 */ 01659 template <typename T, typename R, typename A0, typename A1, typename A2> 01660 Event<void(A0, A1, A2)> event(const volatile T *obj, R (T::*method)(A0, A1, A2) const volatile); 01661 01662 /** Creates an event bound to the event queue 01663 * @see EventQueue::event 01664 */ 01665 template <typename R, typename A0, typename A1, typename A2> 01666 Event<void(A0, A1, A2)> event(mbed::Callback<R(A0, A1, A2)> cb); 01667 01668 /** Creates an event bound to the event queue 01669 * @see EventQueue::event 01670 */ 01671 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2> 01672 Event<void(A0, A1, A2)> event(R (*func)(B0, A0, A1, A2), C0 c0); 01673 01674 /** Creates an event bound to the event queue 01675 * @see EventQueue::event 01676 */ 01677 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2> 01678 Event<void(A0, A1, A2)> event(T *obj, R (T::*method)(B0, A0, A1, A2), C0 c0); 01679 01680 /** Creates an event bound to the event queue 01681 * @see EventQueue::event 01682 */ 01683 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2> 01684 Event<void(A0, A1, A2)> event(const T *obj, R (T::*method)(B0, A0, A1, A2) const, C0 c0); 01685 01686 /** Creates an event bound to the event queue 01687 * @see EventQueue::event 01688 */ 01689 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2> 01690 Event<void(A0, A1, A2)> event(volatile T *obj, R (T::*method)(B0, A0, A1, A2) volatile, C0 c0); 01691 01692 /** Creates an event bound to the event queue 01693 * @see EventQueue::event 01694 */ 01695 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2> 01696 Event<void(A0, A1, A2)> event(const volatile T *obj, R (T::*method)(B0, A0, A1, A2) const volatile, C0 c0); 01697 01698 /** Creates an event bound to the event queue 01699 * @see EventQueue::event 01700 */ 01701 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2> 01702 Event<void(A0, A1, A2)> event(mbed::Callback<R(B0, A0, A1, A2)> cb, C0 c0); 01703 01704 /** Creates an event bound to the event queue 01705 * @see EventQueue::event 01706 */ 01707 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2> 01708 Event<void(A0, A1, A2)> event(R (*func)(B0, B1, A0, A1, A2), C0 c0, C1 c1); 01709 01710 /** Creates an event bound to the event queue 01711 * @see EventQueue::event 01712 */ 01713 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2> 01714 Event<void(A0, A1, A2)> event(T *obj, R (T::*method)(B0, B1, A0, A1, A2), C0 c0, C1 c1); 01715 01716 /** Creates an event bound to the event queue 01717 * @see EventQueue::event 01718 */ 01719 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2> 01720 Event<void(A0, A1, A2)> event(const T *obj, R (T::*method)(B0, B1, A0, A1, A2) const, C0 c0, C1 c1); 01721 01722 /** Creates an event bound to the event queue 01723 * @see EventQueue::event 01724 */ 01725 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2> 01726 Event<void(A0, A1, A2)> event(volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2) volatile, C0 c0, C1 c1); 01727 01728 /** Creates an event bound to the event queue 01729 * @see EventQueue::event 01730 */ 01731 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2> 01732 Event<void(A0, A1, A2)> event(const volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2) const volatile, C0 c0, C1 c1); 01733 01734 /** Creates an event bound to the event queue 01735 * @see EventQueue::event 01736 */ 01737 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2> 01738 Event<void(A0, A1, A2)> event(mbed::Callback<R(B0, B1, A0, A1, A2)> cb, C0 c0, C1 c1); 01739 01740 /** Creates an event bound to the event queue 01741 * @see EventQueue::event 01742 */ 01743 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2> 01744 Event<void(A0, A1, A2)> event(R (*func)(B0, B1, B2, A0, A1, A2), C0 c0, C1 c1, C2 c2); 01745 01746 /** Creates an event bound to the event queue 01747 * @see EventQueue::event 01748 */ 01749 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2> 01750 Event<void(A0, A1, A2)> event(T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2), C0 c0, C1 c1, C2 c2); 01751 01752 /** Creates an event bound to the event queue 01753 * @see EventQueue::event 01754 */ 01755 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2> 01756 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); 01757 01758 /** Creates an event bound to the event queue 01759 * @see EventQueue::event 01760 */ 01761 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2> 01762 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); 01763 01764 /** Creates an event bound to the event queue 01765 * @see EventQueue::event 01766 */ 01767 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2> 01768 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); 01769 01770 /** Creates an event bound to the event queue 01771 * @see EventQueue::event 01772 */ 01773 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2> 01774 Event<void(A0, A1, A2)> event(mbed::Callback<R(B0, B1, B2, A0, A1, A2)> cb, C0 c0, C1 c1, C2 c2); 01775 01776 /** Creates an event bound to the event queue 01777 * @see EventQueue::event 01778 */ 01779 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> 01780 Event<void(A0, A1, A2)> event(R (*func)(B0, B1, B2, B3, A0, A1, A2), C0 c0, C1 c1, C2 c2, C3 c3); 01781 01782 /** Creates an event bound to the event queue 01783 * @see EventQueue::event 01784 */ 01785 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> 01786 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); 01787 01788 /** Creates an event bound to the event queue 01789 * @see EventQueue::event 01790 */ 01791 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> 01792 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); 01793 01794 /** Creates an event bound to the event queue 01795 * @see EventQueue::event 01796 */ 01797 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> 01798 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); 01799 01800 /** Creates an event bound to the event queue 01801 * @see EventQueue::event 01802 */ 01803 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> 01804 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); 01805 01806 /** Creates an event bound to the event queue 01807 * @see EventQueue::event 01808 */ 01809 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> 01810 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); 01811 01812 /** Creates an event bound to the event queue 01813 * @see EventQueue::event 01814 */ 01815 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> 01816 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); 01817 01818 /** Creates an event bound to the event queue 01819 * @see EventQueue::event 01820 */ 01821 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> 01822 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); 01823 01824 /** Creates an event bound to the event queue 01825 * @see EventQueue::event 01826 */ 01827 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> 01828 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); 01829 01830 /** Creates an event bound to the event queue 01831 * @see EventQueue::event 01832 */ 01833 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> 01834 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); 01835 01836 /** Creates an event bound to the event queue 01837 * @see EventQueue::event 01838 */ 01839 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> 01840 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); 01841 01842 /** Creates an event bound to the event queue 01843 * @see EventQueue::event 01844 */ 01845 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> 01846 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); 01847 01848 /** Creates an event bound to the event queue 01849 * @see EventQueue::event 01850 */ 01851 template <typename R, typename A0, typename A1, typename A2, typename A3> 01852 Event<void(A0, A1, A2, A3)> event(R (*func)(A0, A1, A2, A3)); 01853 01854 /** Creates an event bound to the event queue 01855 * @see EventQueue::event 01856 */ 01857 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 01858 Event<void(A0, A1, A2, A3)> event(T *obj, R (T::*method)(A0, A1, A2, A3)); 01859 01860 /** Creates an event bound to the event queue 01861 * @see EventQueue::event 01862 */ 01863 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 01864 Event<void(A0, A1, A2, A3)> event(const T *obj, R (T::*method)(A0, A1, A2, A3) const); 01865 01866 /** Creates an event bound to the event queue 01867 * @see EventQueue::event 01868 */ 01869 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 01870 Event<void(A0, A1, A2, A3)> event(volatile T *obj, R (T::*method)(A0, A1, A2, A3) volatile); 01871 01872 /** Creates an event bound to the event queue 01873 * @see EventQueue::event 01874 */ 01875 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 01876 Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R (T::*method)(A0, A1, A2, A3) const volatile); 01877 01878 /** Creates an event bound to the event queue 01879 * @see EventQueue::event 01880 */ 01881 template <typename R, typename A0, typename A1, typename A2, typename A3> 01882 Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(A0, A1, A2, A3)> cb); 01883 01884 /** Creates an event bound to the event queue 01885 * @see EventQueue::event 01886 */ 01887 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3> 01888 Event<void(A0, A1, A2, A3)> event(R (*func)(B0, A0, A1, A2, A3), C0 c0); 01889 01890 /** Creates an event bound to the event queue 01891 * @see EventQueue::event 01892 */ 01893 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3> 01894 Event<void(A0, A1, A2, A3)> event(T *obj, R (T::*method)(B0, A0, A1, A2, A3), C0 c0); 01895 01896 /** Creates an event bound to the event queue 01897 * @see EventQueue::event 01898 */ 01899 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3> 01900 Event<void(A0, A1, A2, A3)> event(const T *obj, R (T::*method)(B0, A0, A1, A2, A3) const, C0 c0); 01901 01902 /** Creates an event bound to the event queue 01903 * @see EventQueue::event 01904 */ 01905 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3> 01906 Event<void(A0, A1, A2, A3)> event(volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3) volatile, C0 c0); 01907 01908 /** Creates an event bound to the event queue 01909 * @see EventQueue::event 01910 */ 01911 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3> 01912 Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3) const volatile, C0 c0); 01913 01914 /** Creates an event bound to the event queue 01915 * @see EventQueue::event 01916 */ 01917 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3> 01918 Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(B0, A0, A1, A2, A3)> cb, C0 c0); 01919 01920 /** Creates an event bound to the event queue 01921 * @see EventQueue::event 01922 */ 01923 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3> 01924 Event<void(A0, A1, A2, A3)> event(R (*func)(B0, B1, A0, A1, A2, A3), C0 c0, C1 c1); 01925 01926 /** Creates an event bound to the event queue 01927 * @see EventQueue::event 01928 */ 01929 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3> 01930 Event<void(A0, A1, A2, A3)> event(T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3), C0 c0, C1 c1); 01931 01932 /** Creates an event bound to the event queue 01933 * @see EventQueue::event 01934 */ 01935 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3> 01936 Event<void(A0, A1, A2, A3)> event(const T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3) const, C0 c0, C1 c1); 01937 01938 /** Creates an event bound to the event queue 01939 * @see EventQueue::event 01940 */ 01941 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3> 01942 Event<void(A0, A1, A2, A3)> event(volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3) volatile, C0 c0, C1 c1); 01943 01944 /** Creates an event bound to the event queue 01945 * @see EventQueue::event 01946 */ 01947 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3> 01948 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); 01949 01950 /** Creates an event bound to the event queue 01951 * @see EventQueue::event 01952 */ 01953 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3> 01954 Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(B0, B1, A0, A1, A2, A3)> cb, C0 c0, C1 c1); 01955 01956 /** Creates an event bound to the event queue 01957 * @see EventQueue::event 01958 */ 01959 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3> 01960 Event<void(A0, A1, A2, A3)> event(R (*func)(B0, B1, B2, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2); 01961 01962 /** Creates an event bound to the event queue 01963 * @see EventQueue::event 01964 */ 01965 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> 01966 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); 01967 01968 /** Creates an event bound to the event queue 01969 * @see EventQueue::event 01970 */ 01971 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> 01972 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); 01973 01974 /** Creates an event bound to the event queue 01975 * @see EventQueue::event 01976 */ 01977 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> 01978 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); 01979 01980 /** Creates an event bound to the event queue 01981 * @see EventQueue::event 01982 */ 01983 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> 01984 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); 01985 01986 /** Creates an event bound to the event queue 01987 * @see EventQueue::event 01988 */ 01989 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3> 01990 Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(B0, B1, B2, A0, A1, A2, A3)> cb, C0 c0, C1 c1, C2 c2); 01991 01992 /** Creates an event bound to the event queue 01993 * @see EventQueue::event 01994 */ 01995 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> 01996 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); 01997 01998 /** Creates an event bound to the event queue 01999 * @see EventQueue::event 02000 */ 02001 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> 02002 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); 02003 02004 /** Creates an event bound to the event queue 02005 * @see EventQueue::event 02006 */ 02007 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> 02008 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); 02009 02010 /** Creates an event bound to the event queue 02011 * @see EventQueue::event 02012 */ 02013 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> 02014 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); 02015 02016 /** Creates an event bound to the event queue 02017 * @see EventQueue::event 02018 */ 02019 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> 02020 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); 02021 02022 /** Creates an event bound to the event queue 02023 * @see EventQueue::event 02024 */ 02025 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> 02026 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); 02027 02028 /** Creates an event bound to the event queue 02029 * @see EventQueue::event 02030 */ 02031 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> 02032 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); 02033 02034 /** Creates an event bound to the event queue 02035 * @see EventQueue::event 02036 */ 02037 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> 02038 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); 02039 02040 /** Creates an event bound to the event queue 02041 * @see EventQueue::event 02042 */ 02043 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> 02044 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); 02045 02046 /** Creates an event bound to the event queue 02047 * @see EventQueue::event 02048 */ 02049 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> 02050 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); 02051 02052 /** Creates an event bound to the event queue 02053 * @see EventQueue::event 02054 */ 02055 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> 02056 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); 02057 02058 /** Creates an event bound to the event queue 02059 * @see EventQueue::event 02060 */ 02061 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> 02062 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); 02063 02064 /** Creates an event bound to the event queue 02065 * @see EventQueue::event 02066 */ 02067 template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 02068 Event<void(A0, A1, A2, A3, A4)> event(R (*func)(A0, A1, A2, A3, A4)); 02069 02070 /** Creates an event bound to the event queue 02071 * @see EventQueue::event 02072 */ 02073 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 02074 Event<void(A0, A1, A2, A3, A4)> event(T *obj, R (T::*method)(A0, A1, A2, A3, A4)); 02075 02076 /** Creates an event bound to the event queue 02077 * @see EventQueue::event 02078 */ 02079 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 02080 Event<void(A0, A1, A2, A3, A4)> event(const T *obj, R (T::*method)(A0, A1, A2, A3, A4) const); 02081 02082 /** Creates an event bound to the event queue 02083 * @see EventQueue::event 02084 */ 02085 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 02086 Event<void(A0, A1, A2, A3, A4)> event(volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) volatile); 02087 02088 /** Creates an event bound to the event queue 02089 * @see EventQueue::event 02090 */ 02091 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 02092 Event<void(A0, A1, A2, A3, A4)> event(const volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) const volatile); 02093 02094 /** Creates an event bound to the event queue 02095 * @see EventQueue::event 02096 */ 02097 template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 02098 Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(A0, A1, A2, A3, A4)> cb); 02099 02100 /** Creates an event bound to the event queue 02101 * @see EventQueue::event 02102 */ 02103 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4> 02104 Event<void(A0, A1, A2, A3, A4)> event(R (*func)(B0, A0, A1, A2, A3, A4), C0 c0); 02105 02106 /** Creates an event bound to the event queue 02107 * @see EventQueue::event 02108 */ 02109 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4> 02110 Event<void(A0, A1, A2, A3, A4)> event(T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4), C0 c0); 02111 02112 /** Creates an event bound to the event queue 02113 * @see EventQueue::event 02114 */ 02115 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4> 02116 Event<void(A0, A1, A2, A3, A4)> event(const T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4) const, C0 c0); 02117 02118 /** Creates an event bound to the event queue 02119 * @see EventQueue::event 02120 */ 02121 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4> 02122 Event<void(A0, A1, A2, A3, A4)> event(volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4) volatile, C0 c0); 02123 02124 /** Creates an event bound to the event queue 02125 * @see EventQueue::event 02126 */ 02127 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4> 02128 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); 02129 02130 /** Creates an event bound to the event queue 02131 * @see EventQueue::event 02132 */ 02133 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4> 02134 Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(B0, A0, A1, A2, A3, A4)> cb, C0 c0); 02135 02136 /** Creates an event bound to the event queue 02137 * @see EventQueue::event 02138 */ 02139 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4> 02140 Event<void(A0, A1, A2, A3, A4)> event(R (*func)(B0, B1, A0, A1, A2, A3, A4), C0 c0, C1 c1); 02141 02142 /** Creates an event bound to the event queue 02143 * @see EventQueue::event 02144 */ 02145 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4> 02146 Event<void(A0, A1, A2, A3, A4)> event(T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3, A4), C0 c0, C1 c1); 02147 02148 /** Creates an event bound to the event queue 02149 * @see EventQueue::event 02150 */ 02151 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4> 02152 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); 02153 02154 /** Creates an event bound to the event queue 02155 * @see EventQueue::event 02156 */ 02157 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4> 02158 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); 02159 02160 /** Creates an event bound to the event queue 02161 * @see EventQueue::event 02162 */ 02163 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4> 02164 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); 02165 02166 /** Creates an event bound to the event queue 02167 * @see EventQueue::event 02168 */ 02169 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4> 02170 Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(B0, B1, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1); 02171 02172 /** Creates an event bound to the event queue 02173 * @see EventQueue::event 02174 */ 02175 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> 02176 Event<void(A0, A1, A2, A3, A4)> event(R (*func)(B0, B1, B2, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2); 02177 02178 /** Creates an event bound to the event queue 02179 * @see EventQueue::event 02180 */ 02181 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> 02182 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); 02183 02184 /** Creates an event bound to the event queue 02185 * @see EventQueue::event 02186 */ 02187 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> 02188 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); 02189 02190 /** Creates an event bound to the event queue 02191 * @see EventQueue::event 02192 */ 02193 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> 02194 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); 02195 02196 /** Creates an event bound to the event queue 02197 * @see EventQueue::event 02198 */ 02199 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> 02200 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); 02201 02202 /** Creates an event bound to the event queue 02203 * @see EventQueue::event 02204 */ 02205 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> 02206 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); 02207 02208 /** Creates an event bound to the event queue 02209 * @see EventQueue::event 02210 */ 02211 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> 02212 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); 02213 02214 /** Creates an event bound to the event queue 02215 * @see EventQueue::event 02216 */ 02217 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> 02218 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); 02219 02220 /** Creates an event bound to the event queue 02221 * @see EventQueue::event 02222 */ 02223 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> 02224 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); 02225 02226 /** Creates an event bound to the event queue 02227 * @see EventQueue::event 02228 */ 02229 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> 02230 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); 02231 02232 /** Creates an event bound to the event queue 02233 * @see EventQueue::event 02234 */ 02235 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> 02236 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); 02237 02238 /** Creates an event bound to the event queue 02239 * @see EventQueue::event 02240 */ 02241 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> 02242 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); 02243 02244 /** Creates an event bound to the event queue 02245 * @see EventQueue::event 02246 */ 02247 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> 02248 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); 02249 02250 /** Creates an event bound to the event queue 02251 * @see EventQueue::event 02252 */ 02253 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> 02254 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); 02255 02256 /** Creates an event bound to the event queue 02257 * @see EventQueue::event 02258 */ 02259 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> 02260 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); 02261 02262 /** Creates an event bound to the event queue 02263 * @see EventQueue::event 02264 */ 02265 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> 02266 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); 02267 02268 /** Creates an event bound to the event queue 02269 * @see EventQueue::event 02270 */ 02271 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> 02272 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); 02273 02274 /** Creates an event bound to the event queue 02275 * @see EventQueue::event 02276 */ 02277 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> 02278 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); 02279 02280 protected: 02281 template <typename F> 02282 friend class Event; 02283 struct equeue _equeue; 02284 mbed::Callback<void(int)> _update; 02285 02286 // Function attributes 02287 template <typename F> 02288 static void function_call(void *p) { 02289 (*(F*)p)(); 02290 } 02291 02292 template <typename F> 02293 static void function_dtor(void *p) { 02294 ((F*)p)->~F(); 02295 } 02296 02297 // Context structures 02298 template <typename F> 02299 struct context00 { 02300 F f; 02301 02302 context00(F f) 02303 : f(f) {} 02304 02305 void operator()() { 02306 f(); 02307 } 02308 }; 02309 02310 template <typename F, typename C0> 02311 struct context10 { 02312 F f; C0 c0; 02313 02314 context10(F f, C0 c0) 02315 : f(f), c0(c0) {} 02316 02317 void operator()() { 02318 f(c0); 02319 } 02320 }; 02321 02322 template <typename F, typename C0, typename C1> 02323 struct context20 { 02324 F f; C0 c0; C1 c1; 02325 02326 context20(F f, C0 c0, C1 c1) 02327 : f(f), c0(c0), c1(c1) {} 02328 02329 void operator()() { 02330 f(c0, c1); 02331 } 02332 }; 02333 02334 template <typename F, typename C0, typename C1, typename C2> 02335 struct context30 { 02336 F f; C0 c0; C1 c1; C2 c2; 02337 02338 context30(F f, C0 c0, C1 c1, C2 c2) 02339 : f(f), c0(c0), c1(c1), c2(c2) {} 02340 02341 void operator()() { 02342 f(c0, c1, c2); 02343 } 02344 }; 02345 02346 template <typename F, typename C0, typename C1, typename C2, typename C3> 02347 struct context40 { 02348 F f; C0 c0; C1 c1; C2 c2; C3 c3; 02349 02350 context40(F f, C0 c0, C1 c1, C2 c2, C3 c3) 02351 : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {} 02352 02353 void operator()() { 02354 f(c0, c1, c2, c3); 02355 } 02356 }; 02357 02358 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4> 02359 struct context50 { 02360 F f; C0 c0; C1 c1; C2 c2; C3 c3; C4 c4; 02361 02362 context50(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) 02363 : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {} 02364 02365 void operator()() { 02366 f(c0, c1, c2, c3, c4); 02367 } 02368 }; 02369 02370 template <typename F, typename A0> 02371 struct context01 { 02372 F f; 02373 02374 context01(F f) 02375 : f(f) {} 02376 02377 void operator()(A0 a0) { 02378 f(a0); 02379 } 02380 }; 02381 02382 template <typename F, typename C0, typename A0> 02383 struct context11 { 02384 F f; C0 c0; 02385 02386 context11(F f, C0 c0) 02387 : f(f), c0(c0) {} 02388 02389 void operator()(A0 a0) { 02390 f(c0, a0); 02391 } 02392 }; 02393 02394 template <typename F, typename C0, typename C1, typename A0> 02395 struct context21 { 02396 F f; C0 c0; C1 c1; 02397 02398 context21(F f, C0 c0, C1 c1) 02399 : f(f), c0(c0), c1(c1) {} 02400 02401 void operator()(A0 a0) { 02402 f(c0, c1, a0); 02403 } 02404 }; 02405 02406 template <typename F, typename C0, typename C1, typename C2, typename A0> 02407 struct context31 { 02408 F f; C0 c0; C1 c1; C2 c2; 02409 02410 context31(F f, C0 c0, C1 c1, C2 c2) 02411 : f(f), c0(c0), c1(c1), c2(c2) {} 02412 02413 void operator()(A0 a0) { 02414 f(c0, c1, c2, a0); 02415 } 02416 }; 02417 02418 template <typename F, typename C0, typename C1, typename C2, typename C3, typename A0> 02419 struct context41 { 02420 F f; C0 c0; C1 c1; C2 c2; C3 c3; 02421 02422 context41(F f, C0 c0, C1 c1, C2 c2, C3 c3) 02423 : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {} 02424 02425 void operator()(A0 a0) { 02426 f(c0, c1, c2, c3, a0); 02427 } 02428 }; 02429 02430 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0> 02431 struct context51 { 02432 F f; C0 c0; C1 c1; C2 c2; C3 c3; C4 c4; 02433 02434 context51(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) 02435 : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {} 02436 02437 void operator()(A0 a0) { 02438 f(c0, c1, c2, c3, c4, a0); 02439 } 02440 }; 02441 02442 template <typename F, typename A0, typename A1> 02443 struct context02 { 02444 F f; 02445 02446 context02(F f) 02447 : f(f) {} 02448 02449 void operator()(A0 a0, A1 a1) { 02450 f(a0, a1); 02451 } 02452 }; 02453 02454 template <typename F, typename C0, typename A0, typename A1> 02455 struct context12 { 02456 F f; C0 c0; 02457 02458 context12(F f, C0 c0) 02459 : f(f), c0(c0) {} 02460 02461 void operator()(A0 a0, A1 a1) { 02462 f(c0, a0, a1); 02463 } 02464 }; 02465 02466 template <typename F, typename C0, typename C1, typename A0, typename A1> 02467 struct context22 { 02468 F f; C0 c0; C1 c1; 02469 02470 context22(F f, C0 c0, C1 c1) 02471 : f(f), c0(c0), c1(c1) {} 02472 02473 void operator()(A0 a0, A1 a1) { 02474 f(c0, c1, a0, a1); 02475 } 02476 }; 02477 02478 template <typename F, typename C0, typename C1, typename C2, typename A0, typename A1> 02479 struct context32 { 02480 F f; C0 c0; C1 c1; C2 c2; 02481 02482 context32(F f, C0 c0, C1 c1, C2 c2) 02483 : f(f), c0(c0), c1(c1), c2(c2) {} 02484 02485 void operator()(A0 a0, A1 a1) { 02486 f(c0, c1, c2, a0, a1); 02487 } 02488 }; 02489 02490 template <typename F, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1> 02491 struct context42 { 02492 F f; C0 c0; C1 c1; C2 c2; C3 c3; 02493 02494 context42(F f, C0 c0, C1 c1, C2 c2, C3 c3) 02495 : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {} 02496 02497 void operator()(A0 a0, A1 a1) { 02498 f(c0, c1, c2, c3, a0, a1); 02499 } 02500 }; 02501 02502 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1> 02503 struct context52 { 02504 F f; C0 c0; C1 c1; C2 c2; C3 c3; C4 c4; 02505 02506 context52(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) 02507 : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {} 02508 02509 void operator()(A0 a0, A1 a1) { 02510 f(c0, c1, c2, c3, c4, a0, a1); 02511 } 02512 }; 02513 02514 template <typename F, typename A0, typename A1, typename A2> 02515 struct context03 { 02516 F f; 02517 02518 context03(F f) 02519 : f(f) {} 02520 02521 void operator()(A0 a0, A1 a1, A2 a2) { 02522 f(a0, a1, a2); 02523 } 02524 }; 02525 02526 template <typename F, typename C0, typename A0, typename A1, typename A2> 02527 struct context13 { 02528 F f; C0 c0; 02529 02530 context13(F f, C0 c0) 02531 : f(f), c0(c0) {} 02532 02533 void operator()(A0 a0, A1 a1, A2 a2) { 02534 f(c0, a0, a1, a2); 02535 } 02536 }; 02537 02538 template <typename F, typename C0, typename C1, typename A0, typename A1, typename A2> 02539 struct context23 { 02540 F f; C0 c0; C1 c1; 02541 02542 context23(F f, C0 c0, C1 c1) 02543 : f(f), c0(c0), c1(c1) {} 02544 02545 void operator()(A0 a0, A1 a1, A2 a2) { 02546 f(c0, c1, a0, a1, a2); 02547 } 02548 }; 02549 02550 template <typename F, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2> 02551 struct context33 { 02552 F f; C0 c0; C1 c1; C2 c2; 02553 02554 context33(F f, C0 c0, C1 c1, C2 c2) 02555 : f(f), c0(c0), c1(c1), c2(c2) {} 02556 02557 void operator()(A0 a0, A1 a1, A2 a2) { 02558 f(c0, c1, c2, a0, a1, a2); 02559 } 02560 }; 02561 02562 template <typename F, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2> 02563 struct context43 { 02564 F f; C0 c0; C1 c1; C2 c2; C3 c3; 02565 02566 context43(F f, C0 c0, C1 c1, C2 c2, C3 c3) 02567 : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {} 02568 02569 void operator()(A0 a0, A1 a1, A2 a2) { 02570 f(c0, c1, c2, c3, a0, a1, a2); 02571 } 02572 }; 02573 02574 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2> 02575 struct context53 { 02576 F f; C0 c0; C1 c1; C2 c2; C3 c3; C4 c4; 02577 02578 context53(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) 02579 : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {} 02580 02581 void operator()(A0 a0, A1 a1, A2 a2) { 02582 f(c0, c1, c2, c3, c4, a0, a1, a2); 02583 } 02584 }; 02585 02586 template <typename F, typename A0, typename A1, typename A2, typename A3> 02587 struct context04 { 02588 F f; 02589 02590 context04(F f) 02591 : f(f) {} 02592 02593 void operator()(A0 a0, A1 a1, A2 a2, A3 a3) { 02594 f(a0, a1, a2, a3); 02595 } 02596 }; 02597 02598 template <typename F, typename C0, typename A0, typename A1, typename A2, typename A3> 02599 struct context14 { 02600 F f; C0 c0; 02601 02602 context14(F f, C0 c0) 02603 : f(f), c0(c0) {} 02604 02605 void operator()(A0 a0, A1 a1, A2 a2, A3 a3) { 02606 f(c0, a0, a1, a2, a3); 02607 } 02608 }; 02609 02610 template <typename F, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3> 02611 struct context24 { 02612 F f; C0 c0; C1 c1; 02613 02614 context24(F f, C0 c0, C1 c1) 02615 : f(f), c0(c0), c1(c1) {} 02616 02617 void operator()(A0 a0, A1 a1, A2 a2, A3 a3) { 02618 f(c0, c1, a0, a1, a2, a3); 02619 } 02620 }; 02621 02622 template <typename F, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3> 02623 struct context34 { 02624 F f; C0 c0; C1 c1; C2 c2; 02625 02626 context34(F f, C0 c0, C1 c1, C2 c2) 02627 : f(f), c0(c0), c1(c1), c2(c2) {} 02628 02629 void operator()(A0 a0, A1 a1, A2 a2, A3 a3) { 02630 f(c0, c1, c2, a0, a1, a2, a3); 02631 } 02632 }; 02633 02634 template <typename F, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3> 02635 struct context44 { 02636 F f; C0 c0; C1 c1; C2 c2; C3 c3; 02637 02638 context44(F f, C0 c0, C1 c1, C2 c2, C3 c3) 02639 : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {} 02640 02641 void operator()(A0 a0, A1 a1, A2 a2, A3 a3) { 02642 f(c0, c1, c2, c3, a0, a1, a2, a3); 02643 } 02644 }; 02645 02646 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3> 02647 struct context54 { 02648 F f; C0 c0; C1 c1; C2 c2; C3 c3; C4 c4; 02649 02650 context54(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) 02651 : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {} 02652 02653 void operator()(A0 a0, A1 a1, A2 a2, A3 a3) { 02654 f(c0, c1, c2, c3, c4, a0, a1, a2, a3); 02655 } 02656 }; 02657 02658 template <typename F, typename A0, typename A1, typename A2, typename A3, typename A4> 02659 struct context05 { 02660 F f; 02661 02662 context05(F f) 02663 : f(f) {} 02664 02665 void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 02666 f(a0, a1, a2, a3, a4); 02667 } 02668 }; 02669 02670 template <typename F, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4> 02671 struct context15 { 02672 F f; C0 c0; 02673 02674 context15(F f, C0 c0) 02675 : f(f), c0(c0) {} 02676 02677 void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 02678 f(c0, a0, a1, a2, a3, a4); 02679 } 02680 }; 02681 02682 template <typename F, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4> 02683 struct context25 { 02684 F f; C0 c0; C1 c1; 02685 02686 context25(F f, C0 c0, C1 c1) 02687 : f(f), c0(c0), c1(c1) {} 02688 02689 void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 02690 f(c0, c1, a0, a1, a2, a3, a4); 02691 } 02692 }; 02693 02694 template <typename F, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3, typename A4> 02695 struct context35 { 02696 F f; C0 c0; C1 c1; C2 c2; 02697 02698 context35(F f, C0 c0, C1 c1, C2 c2) 02699 : f(f), c0(c0), c1(c1), c2(c2) {} 02700 02701 void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 02702 f(c0, c1, c2, a0, a1, a2, a3, a4); 02703 } 02704 }; 02705 02706 template <typename F, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3, typename A4> 02707 struct context45 { 02708 F f; C0 c0; C1 c1; C2 c2; C3 c3; 02709 02710 context45(F f, C0 c0, C1 c1, C2 c2, C3 c3) 02711 : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {} 02712 02713 void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 02714 f(c0, c1, c2, c3, a0, a1, a2, a3, a4); 02715 } 02716 }; 02717 02718 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3, typename A4> 02719 struct context55 { 02720 F f; C0 c0; C1 c1; C2 c2; C3 c3; C4 c4; 02721 02722 context55(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) 02723 : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {} 02724 02725 void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 02726 f(c0, c1, c2, c3, c4, a0, a1, a2, a3, a4); 02727 } 02728 }; 02729 }; 02730 02731 } 02732 02733 #endif 02734
Generated on Sun Jul 17 2022 08:25:22 by 1.7.2