Marco Zecchini
Rtos API example
Embed:
(wiki syntax)
Show/hide line numbers
Event.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 #ifndef EVENT_H 00017 #define EVENT_H 00018 00019 #include "events/EventQueue.h" 00020 #include "platform/mbed_assert.h" 00021 00022 namespace events { 00023 /** \addtogroup events */ 00024 00025 /** Event 00026 * 00027 * Representation of an event for fine-grain dispatch control 00028 * @ingroup events 00029 */ 00030 template <typename F> 00031 class Event; 00032 00033 /** Event 00034 * 00035 * Representation of an event for fine-grain dispatch control 00036 * @ingroup events 00037 */ 00038 template <> 00039 class Event<void()> { 00040 public: 00041 /** Create an event 00042 * 00043 * Constructs an event bound to the specified event queue. The specified 00044 * callback acts as the target for the event and is executed in the 00045 * context of the event queue's dispatch loop once posted. 00046 * 00047 * @param q Event queue to dispatch on 00048 * @param f Function to execute when the event is dispatched 00049 */ 00050 template <typename F> 00051 Event(EventQueue *q, F f) { 00052 _event = static_cast<struct event *>( 00053 equeue_alloc(&q->_equeue, sizeof(struct event) + sizeof(F))); 00054 00055 if (_event) { 00056 _event->equeue = &q->_equeue; 00057 _event->id = 0; 00058 _event->delay = 0; 00059 _event->period = -1; 00060 00061 _event->post = &Event::event_post<F>; 00062 _event->dtor = &Event::event_dtor<F>; 00063 00064 new (_event+1) F(f); 00065 00066 _event->ref = 1; 00067 } 00068 } 00069 00070 /** Copy constructor for events 00071 */ 00072 Event(const Event &e) { 00073 _event = 0; 00074 if (e._event) { 00075 _event = e._event; 00076 _event->ref += 1; 00077 } 00078 } 00079 00080 /** Assignment operator for events 00081 */ 00082 Event &operator=(const Event &that) { 00083 if (this != &that) { 00084 this->~Event(); 00085 new (this) Event(that); 00086 } 00087 00088 return *this; 00089 } 00090 00091 /** Destructor for events 00092 */ 00093 ~Event() { 00094 if (_event) { 00095 _event->ref -= 1; 00096 if (_event->ref == 0) { 00097 _event->dtor(_event); 00098 equeue_dealloc(_event->equeue, _event); 00099 } 00100 } 00101 } 00102 00103 /** Configure the delay of an event 00104 * 00105 * @param delay Millisecond delay before dispatching the event 00106 */ 00107 void delay(int delay) { 00108 if (_event) { 00109 _event->delay = delay; 00110 } 00111 } 00112 00113 /** Configure the period of an event 00114 * 00115 * @param period Millisecond period for repeatedly dispatching an event 00116 */ 00117 void period(int period) { 00118 if (_event) { 00119 _event->period = period; 00120 } 00121 } 00122 00123 /** Posts an event onto the underlying event queue 00124 * 00125 * The event is posted to the underlying queue and is executed in the 00126 * context of the event queue's dispatch loop. 00127 * 00128 * The post function is irq safe and can act as a mechanism for moving 00129 * events out of irq contexts. 00130 * 00131 * @return A unique id that represents the posted event and can 00132 * be passed to EventQueue::cancel, or an id of 0 if 00133 * there is not enough memory to allocate the event. 00134 */ 00135 int post() const { 00136 if (!_event) { 00137 return 0; 00138 } 00139 00140 _event->id = _event->post(_event); 00141 return _event->id; 00142 } 00143 00144 /** Posts an event onto the underlying event queue, returning void 00145 * 00146 */ 00147 void call() const { 00148 MBED_UNUSED int id = post(); 00149 MBED_ASSERT(id); 00150 } 00151 00152 /** Posts an event onto the underlying event queue, returning void 00153 * 00154 */ 00155 void operator()() const { 00156 return call(); 00157 } 00158 00159 /** Static thunk for passing as C-style function 00160 * 00161 * @param func Event to call passed as a void pointer 00162 */ 00163 static void thunk(void *func) { 00164 return static_cast<Event*>(func)->call(); 00165 } 00166 00167 /** Cancels the most recently posted event 00168 * 00169 * Attempts to cancel the most recently posted event. It is safe to call 00170 * cancel after an event has already been dispatched. 00171 * 00172 * The cancel function is irq safe. 00173 * 00174 * If called while the event queue's dispatch loop is active, the cancel 00175 * function does not garuntee that the event will not execute after it 00176 * returns, as the event may have already begun executing. 00177 */ 00178 void cancel() const { 00179 if (_event) { 00180 equeue_cancel(_event->equeue, _event->id); 00181 } 00182 } 00183 00184 private: 00185 struct event { 00186 unsigned ref; 00187 equeue_t *equeue; 00188 int id; 00189 00190 int delay; 00191 int period; 00192 00193 int (*post)(struct event *); 00194 void (*dtor)(struct event *); 00195 00196 // F follows 00197 } *_event; 00198 00199 // Event attributes 00200 template <typename F> 00201 static int event_post(struct event *e) { 00202 typedef EventQueue::context00<F> C; 00203 void *p = equeue_alloc(e->equeue, sizeof(C)); 00204 if (!p) { 00205 return 0; 00206 } 00207 00208 new (p) C(*(F*)(e + 1)); 00209 equeue_event_delay(p, e->delay); 00210 equeue_event_period(p, e->period); 00211 equeue_event_dtor(p, &EventQueue::function_dtor<C>); 00212 return equeue_post(e->equeue, &EventQueue::function_call<C>, p); 00213 } 00214 00215 template <typename F> 00216 static void event_dtor(struct event *e) { 00217 ((F*)(e + 1))->~F(); 00218 } 00219 00220 public: 00221 /** Create an event 00222 * @param q Event queue to dispatch on 00223 * @param f Function to execute when the event is dispatched 00224 * @param c0 Argument to bind to the callback, these arguments are 00225 * allocated on an irq-safe allocator from the event queue's 00226 * memory pool. Must be type-compatible with b0, the 00227 * arguments to the underlying callback. 00228 */ 00229 template <typename F, typename C0> 00230 Event(EventQueue *q, F f, C0 c0) { 00231 new (this) Event(q, EventQueue::context10<F, C0>(f, c0)); 00232 } 00233 00234 /** Create an event 00235 * @param q Event queue to dispatch on 00236 * @param f Function to execute when the event is dispatched 00237 * @param c0,c1 Arguments to bind to the callback, these arguments are 00238 * allocated on an irq-safe allocator from the event queue's 00239 * memory pool. Must be type-compatible with b0..b1, the 00240 * arguments to the underlying callback. 00241 */ 00242 template <typename F, typename C0, typename C1> 00243 Event(EventQueue *q, F f, C0 c0, C1 c1) { 00244 new (this) Event(q, EventQueue::context20<F, C0, C1>(f, c0, c1)); 00245 } 00246 00247 /** Create an event 00248 * @param q Event queue to dispatch on 00249 * @param f Function to execute when the event is dispatched 00250 * @param c0,c1,c2 Arguments to bind to the callback, these arguments are 00251 * allocated on an irq-safe allocator from the event queue's 00252 * memory pool. Must be type-compatible with b0..b2, the 00253 * arguments to the underlying callback. 00254 */ 00255 template <typename F, typename C0, typename C1, typename C2> 00256 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2) { 00257 new (this) Event(q, EventQueue::context30<F, C0, C1, C2>(f, c0, c1, c2)); 00258 } 00259 00260 /** Create an event 00261 * @param q Event queue to dispatch on 00262 * @param f Function to execute when the event is dispatched 00263 * @param c0,c1,c2,c3 Arguments to bind to the callback, these arguments are 00264 * allocated on an irq-safe allocator from the event queue's 00265 * memory pool. Must be type-compatible with b0..b3, the 00266 * arguments to the underlying callback. 00267 */ 00268 template <typename F, typename C0, typename C1, typename C2, typename C3> 00269 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3) { 00270 new (this) Event(q, EventQueue::context40<F, C0, C1, C2, C3>(f, c0, c1, c2, c3)); 00271 } 00272 00273 /** Create an event 00274 * @param q Event queue to dispatch on 00275 * @param f Function to execute when the event is dispatched 00276 * @param c0,c1,c2,c3,c4 Arguments to bind to the callback, these arguments are 00277 * allocated on an irq-safe allocator from the event queue's 00278 * memory pool. Must be type-compatible with b0..b4, the 00279 * arguments to the underlying callback. 00280 */ 00281 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4> 00282 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) { 00283 new (this) Event(q, EventQueue::context50<F, C0, C1, C2, C3, C4>(f, c0, c1, c2, c3, c4)); 00284 } 00285 00286 /** Create an event 00287 * @see Event::Event 00288 */ 00289 template <typename T, typename R, typename B0> 00290 Event(EventQueue *q, T *obj, R (T::*method)(B0), B0 b0) { 00291 new (this) Event(q, mbed::callback(obj, method), b0); 00292 } 00293 00294 /** Create an event 00295 * @see Event::Event 00296 */ 00297 template <typename T, typename R, typename B0> 00298 Event(EventQueue *q, const T *obj, R (T::*method)(B0) const, B0 b0) { 00299 new (this) Event(q, mbed::callback(obj, method), b0); 00300 } 00301 00302 /** Create an event 00303 * @see Event::Event 00304 */ 00305 template <typename T, typename R, typename B0> 00306 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0) volatile, B0 b0) { 00307 new (this) Event(q, mbed::callback(obj, method), b0); 00308 } 00309 00310 /** Create an event 00311 * @see Event::Event 00312 */ 00313 template <typename T, typename R, typename B0> 00314 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0) const volatile, B0 b0) { 00315 new (this) Event(q, mbed::callback(obj, method), b0); 00316 } 00317 00318 /** Create an event 00319 * @see Event::Event 00320 */ 00321 template <typename T, typename R, typename B0, typename B1> 00322 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1), B0 b0, B1 b1) { 00323 new (this) Event(q, mbed::callback(obj, method), b0, b1); 00324 } 00325 00326 /** Create an event 00327 * @see Event::Event 00328 */ 00329 template <typename T, typename R, typename B0, typename B1> 00330 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1) const, B0 b0, B1 b1) { 00331 new (this) Event(q, mbed::callback(obj, method), b0, b1); 00332 } 00333 00334 /** Create an event 00335 * @see Event::Event 00336 */ 00337 template <typename T, typename R, typename B0, typename B1> 00338 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1) volatile, B0 b0, B1 b1) { 00339 new (this) Event(q, mbed::callback(obj, method), b0, b1); 00340 } 00341 00342 /** Create an event 00343 * @see Event::Event 00344 */ 00345 template <typename T, typename R, typename B0, typename B1> 00346 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1) const volatile, B0 b0, B1 b1) { 00347 new (this) Event(q, mbed::callback(obj, method), b0, b1); 00348 } 00349 00350 /** Create an event 00351 * @see Event::Event 00352 */ 00353 template <typename T, typename R, typename B0, typename B1, typename B2> 00354 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2), B0 b0, B1 b1, B2 b2) { 00355 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2); 00356 } 00357 00358 /** Create an event 00359 * @see Event::Event 00360 */ 00361 template <typename T, typename R, typename B0, typename B1, typename B2> 00362 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, B2) const, B0 b0, B1 b1, B2 b2) { 00363 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2); 00364 } 00365 00366 /** Create an event 00367 * @see Event::Event 00368 */ 00369 template <typename T, typename R, typename B0, typename B1, typename B2> 00370 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, B2) volatile, B0 b0, B1 b1, B2 b2) { 00371 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2); 00372 } 00373 00374 /** Create an event 00375 * @see Event::Event 00376 */ 00377 template <typename T, typename R, typename B0, typename B1, typename B2> 00378 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, B2) const volatile, B0 b0, B1 b1, B2 b2) { 00379 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2); 00380 } 00381 00382 /** Create an event 00383 * @see Event::Event 00384 */ 00385 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3> 00386 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, B3), B0 b0, B1 b1, B2 b2, B3 b3) { 00387 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3); 00388 } 00389 00390 /** Create an event 00391 * @see Event::Event 00392 */ 00393 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3> 00394 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, B2, B3) const, B0 b0, B1 b1, B2 b2, B3 b3) { 00395 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3); 00396 } 00397 00398 /** Create an event 00399 * @see Event::Event 00400 */ 00401 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3> 00402 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, B2, B3) volatile, B0 b0, B1 b1, B2 b2, B3 b3) { 00403 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3); 00404 } 00405 00406 /** Create an event 00407 * @see Event::Event 00408 */ 00409 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3> 00410 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, B2, B3) const volatile, B0 b0, B1 b1, B2 b2, B3 b3) { 00411 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3); 00412 } 00413 00414 /** Create an event 00415 * @see Event::Event 00416 */ 00417 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4> 00418 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, B3, B4), B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) { 00419 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4); 00420 } 00421 00422 /** Create an event 00423 * @see Event::Event 00424 */ 00425 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4> 00426 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, B2, B3, B4) const, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) { 00427 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4); 00428 } 00429 00430 /** Create an event 00431 * @see Event::Event 00432 */ 00433 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4> 00434 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4) volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) { 00435 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4); 00436 } 00437 00438 /** Create an event 00439 * @see Event::Event 00440 */ 00441 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4> 00442 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4) const volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) { 00443 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4); 00444 } 00445 }; 00446 00447 /** Event 00448 * 00449 * Representation of an event for fine-grain dispatch control 00450 * @ingroup events 00451 */ 00452 template <typename A0> 00453 class Event<void(A0)> { 00454 public: 00455 /** Create an event 00456 * 00457 * Constructs an event bound to the specified event queue. The specified 00458 * callback acts as the target for the event and is executed in the 00459 * context of the event queue's dispatch loop once posted. 00460 * 00461 * @param q Event queue to dispatch on 00462 * @param f Function to execute when the event is dispatched 00463 */ 00464 template <typename F> 00465 Event(EventQueue *q, F f) { 00466 _event = static_cast<struct event *>( 00467 equeue_alloc(&q->_equeue, sizeof(struct event) + sizeof(F))); 00468 00469 if (_event) { 00470 _event->equeue = &q->_equeue; 00471 _event->id = 0; 00472 _event->delay = 0; 00473 _event->period = -1; 00474 00475 _event->post = &Event::event_post<F>; 00476 _event->dtor = &Event::event_dtor<F>; 00477 00478 new (_event+1) F(f); 00479 00480 _event->ref = 1; 00481 } 00482 } 00483 00484 /** Copy constructor for events 00485 */ 00486 Event(const Event &e) { 00487 _event = 0; 00488 if (e._event) { 00489 _event = e._event; 00490 _event->ref += 1; 00491 } 00492 } 00493 00494 /** Assignment operator for events 00495 */ 00496 Event &operator=(const Event &that) { 00497 if (this != &that) { 00498 this->~Event(); 00499 new (this) Event(that); 00500 } 00501 00502 return *this; 00503 } 00504 00505 /** Destructor for events 00506 */ 00507 ~Event() { 00508 if (_event) { 00509 _event->ref -= 1; 00510 if (_event->ref == 0) { 00511 _event->dtor(_event); 00512 equeue_dealloc(_event->equeue, _event); 00513 } 00514 } 00515 } 00516 00517 /** Configure the delay of an event 00518 * 00519 * @param delay Millisecond delay before dispatching the event 00520 */ 00521 void delay(int delay) { 00522 if (_event) { 00523 _event->delay = delay; 00524 } 00525 } 00526 00527 /** Configure the period of an event 00528 * 00529 * @param period Millisecond period for repeatedly dispatching an event 00530 */ 00531 void period(int period) { 00532 if (_event) { 00533 _event->period = period; 00534 } 00535 } 00536 00537 /** Posts an event onto the underlying event queue 00538 * 00539 * The event is posted to the underlying queue and is executed in the 00540 * context of the event queue's dispatch loop. 00541 * 00542 * The post function is irq safe and can act as a mechanism for moving 00543 * events out of irq contexts. 00544 * 00545 * @param a0 Argument to pass to the event 00546 * @return A unique id that represents the posted event and can 00547 * be passed to EventQueue::cancel, or an id of 0 if 00548 * there is not enough memory to allocate the event. 00549 */ 00550 int post(A0 a0) const { 00551 if (!_event) { 00552 return 0; 00553 } 00554 00555 _event->id = _event->post(_event, a0); 00556 return _event->id; 00557 } 00558 00559 /** Posts an event onto the underlying event queue, returning void 00560 * 00561 * @param a0 Argument to pass to the event 00562 */ 00563 void call(A0 a0) const { 00564 MBED_UNUSED int id = post(a0); 00565 MBED_ASSERT(id); 00566 } 00567 00568 /** Posts an event onto the underlying event queue, returning void 00569 * 00570 * @param a0 Argument to pass to the event 00571 */ 00572 void operator()(A0 a0) const { 00573 return call(a0); 00574 } 00575 00576 /** Static thunk for passing as C-style function 00577 * 00578 * @param func Event to call passed as a void pointer 00579 * @param a0 Argument to pass to the event 00580 */ 00581 static void thunk(void *func, A0 a0) { 00582 return static_cast<Event*>(func)->call(a0); 00583 } 00584 00585 /** Cancels the most recently posted event 00586 * 00587 * Attempts to cancel the most recently posted event. It is safe to call 00588 * cancel after an event has already been dispatched. 00589 * 00590 * The cancel function is irq safe. 00591 * 00592 * If called while the event queue's dispatch loop is active, the cancel 00593 * function does not garuntee that the event will not execute after it 00594 * returns, as the event may have already begun executing. 00595 */ 00596 void cancel() const { 00597 if (_event) { 00598 equeue_cancel(_event->equeue, _event->id); 00599 } 00600 } 00601 00602 private: 00603 struct event { 00604 unsigned ref; 00605 equeue_t *equeue; 00606 int id; 00607 00608 int delay; 00609 int period; 00610 00611 int (*post)(struct event *, A0 a0); 00612 void (*dtor)(struct event *); 00613 00614 // F follows 00615 } *_event; 00616 00617 // Event attributes 00618 template <typename F> 00619 static int event_post(struct event *e, A0 a0) { 00620 typedef EventQueue::context10<F, A0> C; 00621 void *p = equeue_alloc(e->equeue, sizeof(C)); 00622 if (!p) { 00623 return 0; 00624 } 00625 00626 new (p) C(*(F*)(e + 1), a0); 00627 equeue_event_delay(p, e->delay); 00628 equeue_event_period(p, e->period); 00629 equeue_event_dtor(p, &EventQueue::function_dtor<C>); 00630 return equeue_post(e->equeue, &EventQueue::function_call<C>, p); 00631 } 00632 00633 template <typename F> 00634 static void event_dtor(struct event *e) { 00635 ((F*)(e + 1))->~F(); 00636 } 00637 00638 public: 00639 /** Create an event 00640 * @param q Event queue to dispatch on 00641 * @param f Function to execute when the event is dispatched 00642 * @param c0 Argument to bind to the callback, these arguments are 00643 * allocated on an irq-safe allocator from the event queue's 00644 * memory pool. Must be type-compatible with b0, the 00645 * arguments to the underlying callback. 00646 */ 00647 template <typename F, typename C0> 00648 Event(EventQueue *q, F f, C0 c0) { 00649 new (this) Event(q, EventQueue::context11<F, C0, A0>(f, c0)); 00650 } 00651 00652 /** Create an event 00653 * @param q Event queue to dispatch on 00654 * @param f Function to execute when the event is dispatched 00655 * @param c0,c1 Arguments to bind to the callback, these arguments are 00656 * allocated on an irq-safe allocator from the event queue's 00657 * memory pool. Must be type-compatible with b0..b1, the 00658 * arguments to the underlying callback. 00659 */ 00660 template <typename F, typename C0, typename C1> 00661 Event(EventQueue *q, F f, C0 c0, C1 c1) { 00662 new (this) Event(q, EventQueue::context21<F, C0, C1, A0>(f, c0, c1)); 00663 } 00664 00665 /** Create an event 00666 * @param q Event queue to dispatch on 00667 * @param f Function to execute when the event is dispatched 00668 * @param c0,c1,c2 Arguments to bind to the callback, these arguments are 00669 * allocated on an irq-safe allocator from the event queue's 00670 * memory pool. Must be type-compatible with b0..b2, the 00671 * arguments to the underlying callback. 00672 */ 00673 template <typename F, typename C0, typename C1, typename C2> 00674 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2) { 00675 new (this) Event(q, EventQueue::context31<F, C0, C1, C2, A0>(f, c0, c1, c2)); 00676 } 00677 00678 /** Create an event 00679 * @param q Event queue to dispatch on 00680 * @param f Function to execute when the event is dispatched 00681 * @param c0,c1,c2,c3 Arguments to bind to the callback, these arguments are 00682 * allocated on an irq-safe allocator from the event queue's 00683 * memory pool. Must be type-compatible with b0..b3, the 00684 * arguments to the underlying callback. 00685 */ 00686 template <typename F, typename C0, typename C1, typename C2, typename C3> 00687 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3) { 00688 new (this) Event(q, EventQueue::context41<F, C0, C1, C2, C3, A0>(f, c0, c1, c2, c3)); 00689 } 00690 00691 /** Create an event 00692 * @param q Event queue to dispatch on 00693 * @param f Function to execute when the event is dispatched 00694 * @param c0,c1,c2,c3,c4 Arguments to bind to the callback, these arguments are 00695 * allocated on an irq-safe allocator from the event queue's 00696 * memory pool. Must be type-compatible with b0..b4, the 00697 * arguments to the underlying callback. 00698 */ 00699 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4> 00700 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) { 00701 new (this) Event(q, EventQueue::context51<F, C0, C1, C2, C3, C4, A0>(f, c0, c1, c2, c3, c4)); 00702 } 00703 00704 /** Create an event 00705 * @see Event::Event 00706 */ 00707 template <typename T, typename R, typename B0> 00708 Event(EventQueue *q, T *obj, R (T::*method)(B0, A0), B0 b0) { 00709 new (this) Event(q, mbed::callback(obj, method), b0); 00710 } 00711 00712 /** Create an event 00713 * @see Event::Event 00714 */ 00715 template <typename T, typename R, typename B0> 00716 Event(EventQueue *q, const T *obj, R (T::*method)(B0, A0) const, B0 b0) { 00717 new (this) Event(q, mbed::callback(obj, method), b0); 00718 } 00719 00720 /** Create an event 00721 * @see Event::Event 00722 */ 00723 template <typename T, typename R, typename B0> 00724 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, A0) volatile, B0 b0) { 00725 new (this) Event(q, mbed::callback(obj, method), b0); 00726 } 00727 00728 /** Create an event 00729 * @see Event::Event 00730 */ 00731 template <typename T, typename R, typename B0> 00732 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, A0) const volatile, B0 b0) { 00733 new (this) Event(q, mbed::callback(obj, method), b0); 00734 } 00735 00736 /** Create an event 00737 * @see Event::Event 00738 */ 00739 template <typename T, typename R, typename B0, typename B1> 00740 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, A0), B0 b0, B1 b1) { 00741 new (this) Event(q, mbed::callback(obj, method), b0, b1); 00742 } 00743 00744 /** Create an event 00745 * @see Event::Event 00746 */ 00747 template <typename T, typename R, typename B0, typename B1> 00748 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, A0) const, B0 b0, B1 b1) { 00749 new (this) Event(q, mbed::callback(obj, method), b0, b1); 00750 } 00751 00752 /** Create an event 00753 * @see Event::Event 00754 */ 00755 template <typename T, typename R, typename B0, typename B1> 00756 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, A0) volatile, B0 b0, B1 b1) { 00757 new (this) Event(q, mbed::callback(obj, method), b0, b1); 00758 } 00759 00760 /** Create an event 00761 * @see Event::Event 00762 */ 00763 template <typename T, typename R, typename B0, typename B1> 00764 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, A0) const volatile, B0 b0, B1 b1) { 00765 new (this) Event(q, mbed::callback(obj, method), b0, b1); 00766 } 00767 00768 /** Create an event 00769 * @see Event::Event 00770 */ 00771 template <typename T, typename R, typename B0, typename B1, typename B2> 00772 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, A0), B0 b0, B1 b1, B2 b2) { 00773 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2); 00774 } 00775 00776 /** Create an event 00777 * @see Event::Event 00778 */ 00779 template <typename T, typename R, typename B0, typename B1, typename B2> 00780 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, B2, A0) const, B0 b0, B1 b1, B2 b2) { 00781 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2); 00782 } 00783 00784 /** Create an event 00785 * @see Event::Event 00786 */ 00787 template <typename T, typename R, typename B0, typename B1, typename B2> 00788 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, B2, A0) volatile, B0 b0, B1 b1, B2 b2) { 00789 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2); 00790 } 00791 00792 /** Create an event 00793 * @see Event::Event 00794 */ 00795 template <typename T, typename R, typename B0, typename B1, typename B2> 00796 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, B2, A0) const volatile, B0 b0, B1 b1, B2 b2) { 00797 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2); 00798 } 00799 00800 /** Create an event 00801 * @see Event::Event 00802 */ 00803 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3> 00804 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, B3, A0), B0 b0, B1 b1, B2 b2, B3 b3) { 00805 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3); 00806 } 00807 00808 /** Create an event 00809 * @see Event::Event 00810 */ 00811 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3> 00812 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, B2, B3, A0) const, B0 b0, B1 b1, B2 b2, B3 b3) { 00813 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3); 00814 } 00815 00816 /** Create an event 00817 * @see Event::Event 00818 */ 00819 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3> 00820 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0) volatile, B0 b0, B1 b1, B2 b2, B3 b3) { 00821 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3); 00822 } 00823 00824 /** Create an event 00825 * @see Event::Event 00826 */ 00827 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3> 00828 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0) const volatile, B0 b0, B1 b1, B2 b2, B3 b3) { 00829 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3); 00830 } 00831 00832 /** Create an event 00833 * @see Event::Event 00834 */ 00835 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4> 00836 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0), B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) { 00837 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4); 00838 } 00839 00840 /** Create an event 00841 * @see Event::Event 00842 */ 00843 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4> 00844 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0) const, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) { 00845 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4); 00846 } 00847 00848 /** Create an event 00849 * @see Event::Event 00850 */ 00851 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4> 00852 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0) volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) { 00853 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4); 00854 } 00855 00856 /** Create an event 00857 * @see Event::Event 00858 */ 00859 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4> 00860 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0) const volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) { 00861 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4); 00862 } 00863 }; 00864 00865 /** Event 00866 * 00867 * Representation of an event for fine-grain dispatch control 00868 * @ingroup events 00869 */ 00870 template <typename A0, typename A1> 00871 class Event<void(A0, A1)> { 00872 public: 00873 /** Create an event 00874 * 00875 * Constructs an event bound to the specified event queue. The specified 00876 * callback acts as the target for the event and is executed in the 00877 * context of the event queue's dispatch loop once posted. 00878 * 00879 * @param q Event queue to dispatch on 00880 * @param f Function to execute when the event is dispatched 00881 */ 00882 template <typename F> 00883 Event(EventQueue *q, F f) { 00884 _event = static_cast<struct event *>( 00885 equeue_alloc(&q->_equeue, sizeof(struct event) + sizeof(F))); 00886 00887 if (_event) { 00888 _event->equeue = &q->_equeue; 00889 _event->id = 0; 00890 _event->delay = 0; 00891 _event->period = -1; 00892 00893 _event->post = &Event::event_post<F>; 00894 _event->dtor = &Event::event_dtor<F>; 00895 00896 new (_event+1) F(f); 00897 00898 _event->ref = 1; 00899 } 00900 } 00901 00902 /** Copy constructor for events 00903 */ 00904 Event(const Event &e) { 00905 _event = 0; 00906 if (e._event) { 00907 _event = e._event; 00908 _event->ref += 1; 00909 } 00910 } 00911 00912 /** Assignment operator for events 00913 */ 00914 Event &operator=(const Event &that) { 00915 if (this != &that) { 00916 this->~Event(); 00917 new (this) Event(that); 00918 } 00919 00920 return *this; 00921 } 00922 00923 /** Destructor for events 00924 */ 00925 ~Event() { 00926 if (_event) { 00927 _event->ref -= 1; 00928 if (_event->ref == 0) { 00929 _event->dtor(_event); 00930 equeue_dealloc(_event->equeue, _event); 00931 } 00932 } 00933 } 00934 00935 /** Configure the delay of an event 00936 * 00937 * @param delay Millisecond delay before dispatching the event 00938 */ 00939 void delay(int delay) { 00940 if (_event) { 00941 _event->delay = delay; 00942 } 00943 } 00944 00945 /** Configure the period of an event 00946 * 00947 * @param period Millisecond period for repeatedly dispatching an event 00948 */ 00949 void period(int period) { 00950 if (_event) { 00951 _event->period = period; 00952 } 00953 } 00954 00955 /** Posts an event onto the underlying event queue 00956 * 00957 * The event is posted to the underlying queue and is executed in the 00958 * context of the event queue's dispatch loop. 00959 * 00960 * The post function is irq safe and can act as a mechanism for moving 00961 * events out of irq contexts. 00962 * 00963 * @param a0,a1 Arguments to pass to the event 00964 * @return A unique id that represents the posted event and can 00965 * be passed to EventQueue::cancel, or an id of 0 if 00966 * there is not enough memory to allocate the event. 00967 */ 00968 int post(A0 a0, A1 a1) const { 00969 if (!_event) { 00970 return 0; 00971 } 00972 00973 _event->id = _event->post(_event, a0, a1); 00974 return _event->id; 00975 } 00976 00977 /** Posts an event onto the underlying event queue, returning void 00978 * 00979 * @param a0,a1 Arguments to pass to the event 00980 */ 00981 void call(A0 a0, A1 a1) const { 00982 MBED_UNUSED int id = post(a0, a1); 00983 MBED_ASSERT(id); 00984 } 00985 00986 /** Posts an event onto the underlying event queue, returning void 00987 * 00988 * @param a0,a1 Arguments to pass to the event 00989 */ 00990 void operator()(A0 a0, A1 a1) const { 00991 return call(a0, a1); 00992 } 00993 00994 /** Static thunk for passing as C-style function 00995 * 00996 * @param func Event to call passed as a void pointer 00997 * @param a0,a1 Arguments to pass to the event 00998 */ 00999 static void thunk(void *func, A0 a0, A1 a1) { 01000 return static_cast<Event*>(func)->call(a0, a1); 01001 } 01002 01003 /** Cancels the most recently posted event 01004 * 01005 * Attempts to cancel the most recently posted event. It is safe to call 01006 * cancel after an event has already been dispatched. 01007 * 01008 * The cancel function is irq safe. 01009 * 01010 * If called while the event queue's dispatch loop is active, the cancel 01011 * function does not garuntee that the event will not execute after it 01012 * returns, as the event may have already begun executing. 01013 */ 01014 void cancel() const { 01015 if (_event) { 01016 equeue_cancel(_event->equeue, _event->id); 01017 } 01018 } 01019 01020 private: 01021 struct event { 01022 unsigned ref; 01023 equeue_t *equeue; 01024 int id; 01025 01026 int delay; 01027 int period; 01028 01029 int (*post)(struct event *, A0 a0, A1 a1); 01030 void (*dtor)(struct event *); 01031 01032 // F follows 01033 } *_event; 01034 01035 // Event attributes 01036 template <typename F> 01037 static int event_post(struct event *e, A0 a0, A1 a1) { 01038 typedef EventQueue::context20<F, A0, A1> C; 01039 void *p = equeue_alloc(e->equeue, sizeof(C)); 01040 if (!p) { 01041 return 0; 01042 } 01043 01044 new (p) C(*(F*)(e + 1), a0, a1); 01045 equeue_event_delay(p, e->delay); 01046 equeue_event_period(p, e->period); 01047 equeue_event_dtor(p, &EventQueue::function_dtor<C>); 01048 return equeue_post(e->equeue, &EventQueue::function_call<C>, p); 01049 } 01050 01051 template <typename F> 01052 static void event_dtor(struct event *e) { 01053 ((F*)(e + 1))->~F(); 01054 } 01055 01056 public: 01057 /** Create an event 01058 * @param q Event queue to dispatch on 01059 * @param f Function to execute when the event is dispatched 01060 * @param c0 Argument to bind to the callback, these arguments are 01061 * allocated on an irq-safe allocator from the event queue's 01062 * memory pool. Must be type-compatible with b0, the 01063 * arguments to the underlying callback. 01064 */ 01065 template <typename F, typename C0> 01066 Event(EventQueue *q, F f, C0 c0) { 01067 new (this) Event(q, EventQueue::context12<F, C0, A0, A1>(f, c0)); 01068 } 01069 01070 /** Create an event 01071 * @param q Event queue to dispatch on 01072 * @param f Function to execute when the event is dispatched 01073 * @param c0,c1 Arguments to bind to the callback, these arguments are 01074 * allocated on an irq-safe allocator from the event queue's 01075 * memory pool. Must be type-compatible with b0..b1, the 01076 * arguments to the underlying callback. 01077 */ 01078 template <typename F, typename C0, typename C1> 01079 Event(EventQueue *q, F f, C0 c0, C1 c1) { 01080 new (this) Event(q, EventQueue::context22<F, C0, C1, A0, A1>(f, c0, c1)); 01081 } 01082 01083 /** Create an event 01084 * @param q Event queue to dispatch on 01085 * @param f Function to execute when the event is dispatched 01086 * @param c0,c1,c2 Arguments to bind to the callback, these arguments are 01087 * allocated on an irq-safe allocator from the event queue's 01088 * memory pool. Must be type-compatible with b0..b2, the 01089 * arguments to the underlying callback. 01090 */ 01091 template <typename F, typename C0, typename C1, typename C2> 01092 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2) { 01093 new (this) Event(q, EventQueue::context32<F, C0, C1, C2, A0, A1>(f, c0, c1, c2)); 01094 } 01095 01096 /** Create an event 01097 * @param q Event queue to dispatch on 01098 * @param f Function to execute when the event is dispatched 01099 * @param c0,c1,c2,c3 Arguments to bind to the callback, these arguments are 01100 * allocated on an irq-safe allocator from the event queue's 01101 * memory pool. Must be type-compatible with b0..b3, the 01102 * arguments to the underlying callback. 01103 */ 01104 template <typename F, typename C0, typename C1, typename C2, typename C3> 01105 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3) { 01106 new (this) Event(q, EventQueue::context42<F, C0, C1, C2, C3, A0, A1>(f, c0, c1, c2, c3)); 01107 } 01108 01109 /** Create an event 01110 * @param q Event queue to dispatch on 01111 * @param f Function to execute when the event is dispatched 01112 * @param c0,c1,c2,c3,c4 Arguments to bind to the callback, these arguments are 01113 * allocated on an irq-safe allocator from the event queue's 01114 * memory pool. Must be type-compatible with b0..b4, the 01115 * arguments to the underlying callback. 01116 */ 01117 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4> 01118 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) { 01119 new (this) Event(q, EventQueue::context52<F, C0, C1, C2, C3, C4, A0, A1>(f, c0, c1, c2, c3, c4)); 01120 } 01121 01122 /** Create an event 01123 * @see Event::Event 01124 */ 01125 template <typename T, typename R, typename B0> 01126 Event(EventQueue *q, T *obj, R (T::*method)(B0, A0, A1), B0 b0) { 01127 new (this) Event(q, mbed::callback(obj, method), b0); 01128 } 01129 01130 /** Create an event 01131 * @see Event::Event 01132 */ 01133 template <typename T, typename R, typename B0> 01134 Event(EventQueue *q, const T *obj, R (T::*method)(B0, A0, A1) const, B0 b0) { 01135 new (this) Event(q, mbed::callback(obj, method), b0); 01136 } 01137 01138 /** Create an event 01139 * @see Event::Event 01140 */ 01141 template <typename T, typename R, typename B0> 01142 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, A0, A1) volatile, B0 b0) { 01143 new (this) Event(q, mbed::callback(obj, method), b0); 01144 } 01145 01146 /** Create an event 01147 * @see Event::Event 01148 */ 01149 template <typename T, typename R, typename B0> 01150 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, A0, A1) const volatile, B0 b0) { 01151 new (this) Event(q, mbed::callback(obj, method), b0); 01152 } 01153 01154 /** Create an event 01155 * @see Event::Event 01156 */ 01157 template <typename T, typename R, typename B0, typename B1> 01158 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, A0, A1), B0 b0, B1 b1) { 01159 new (this) Event(q, mbed::callback(obj, method), b0, b1); 01160 } 01161 01162 /** Create an event 01163 * @see Event::Event 01164 */ 01165 template <typename T, typename R, typename B0, typename B1> 01166 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, A0, A1) const, B0 b0, B1 b1) { 01167 new (this) Event(q, mbed::callback(obj, method), b0, b1); 01168 } 01169 01170 /** Create an event 01171 * @see Event::Event 01172 */ 01173 template <typename T, typename R, typename B0, typename B1> 01174 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, A0, A1) volatile, B0 b0, B1 b1) { 01175 new (this) Event(q, mbed::callback(obj, method), b0, b1); 01176 } 01177 01178 /** Create an event 01179 * @see Event::Event 01180 */ 01181 template <typename T, typename R, typename B0, typename B1> 01182 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, A0, A1) const volatile, B0 b0, B1 b1) { 01183 new (this) Event(q, mbed::callback(obj, method), b0, b1); 01184 } 01185 01186 /** Create an event 01187 * @see Event::Event 01188 */ 01189 template <typename T, typename R, typename B0, typename B1, typename B2> 01190 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, A0, A1), B0 b0, B1 b1, B2 b2) { 01191 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2); 01192 } 01193 01194 /** Create an event 01195 * @see Event::Event 01196 */ 01197 template <typename T, typename R, typename B0, typename B1, typename B2> 01198 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, B2, A0, A1) const, B0 b0, B1 b1, B2 b2) { 01199 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2); 01200 } 01201 01202 /** Create an event 01203 * @see Event::Event 01204 */ 01205 template <typename T, typename R, typename B0, typename B1, typename B2> 01206 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1) volatile, B0 b0, B1 b1, B2 b2) { 01207 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2); 01208 } 01209 01210 /** Create an event 01211 * @see Event::Event 01212 */ 01213 template <typename T, typename R, typename B0, typename B1, typename B2> 01214 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1) const volatile, B0 b0, B1 b1, B2 b2) { 01215 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2); 01216 } 01217 01218 /** Create an event 01219 * @see Event::Event 01220 */ 01221 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3> 01222 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1), B0 b0, B1 b1, B2 b2, B3 b3) { 01223 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3); 01224 } 01225 01226 /** Create an event 01227 * @see Event::Event 01228 */ 01229 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3> 01230 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1) const, B0 b0, B1 b1, B2 b2, B3 b3) { 01231 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3); 01232 } 01233 01234 /** Create an event 01235 * @see Event::Event 01236 */ 01237 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3> 01238 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1) volatile, B0 b0, B1 b1, B2 b2, B3 b3) { 01239 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3); 01240 } 01241 01242 /** Create an event 01243 * @see Event::Event 01244 */ 01245 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3> 01246 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1) const volatile, B0 b0, B1 b1, B2 b2, B3 b3) { 01247 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3); 01248 } 01249 01250 /** Create an event 01251 * @see Event::Event 01252 */ 01253 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4> 01254 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1), B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) { 01255 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4); 01256 } 01257 01258 /** Create an event 01259 * @see Event::Event 01260 */ 01261 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4> 01262 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1) const, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) { 01263 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4); 01264 } 01265 01266 /** Create an event 01267 * @see Event::Event 01268 */ 01269 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4> 01270 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1) volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) { 01271 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4); 01272 } 01273 01274 /** Create an event 01275 * @see Event::Event 01276 */ 01277 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4> 01278 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1) const volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) { 01279 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4); 01280 } 01281 }; 01282 01283 /** Event 01284 * 01285 * Representation of an event for fine-grain dispatch control 01286 * @ingroup events 01287 */ 01288 template <typename A0, typename A1, typename A2> 01289 class Event<void(A0, A1, A2)> { 01290 public: 01291 /** Create an event 01292 * 01293 * Constructs an event bound to the specified event queue. The specified 01294 * callback acts as the target for the event and is executed in the 01295 * context of the event queue's dispatch loop once posted. 01296 * 01297 * @param q Event queue to dispatch on 01298 * @param f Function to execute when the event is dispatched 01299 */ 01300 template <typename F> 01301 Event(EventQueue *q, F f) { 01302 _event = static_cast<struct event *>( 01303 equeue_alloc(&q->_equeue, sizeof(struct event) + sizeof(F))); 01304 01305 if (_event) { 01306 _event->equeue = &q->_equeue; 01307 _event->id = 0; 01308 _event->delay = 0; 01309 _event->period = -1; 01310 01311 _event->post = &Event::event_post<F>; 01312 _event->dtor = &Event::event_dtor<F>; 01313 01314 new (_event+1) F(f); 01315 01316 _event->ref = 1; 01317 } 01318 } 01319 01320 /** Copy constructor for events 01321 */ 01322 Event(const Event &e) { 01323 _event = 0; 01324 if (e._event) { 01325 _event = e._event; 01326 _event->ref += 1; 01327 } 01328 } 01329 01330 /** Assignment operator for events 01331 */ 01332 Event &operator=(const Event &that) { 01333 if (this != &that) { 01334 this->~Event(); 01335 new (this) Event(that); 01336 } 01337 01338 return *this; 01339 } 01340 01341 /** Destructor for events 01342 */ 01343 ~Event() { 01344 if (_event) { 01345 _event->ref -= 1; 01346 if (_event->ref == 0) { 01347 _event->dtor(_event); 01348 equeue_dealloc(_event->equeue, _event); 01349 } 01350 } 01351 } 01352 01353 /** Configure the delay of an event 01354 * 01355 * @param delay Millisecond delay before dispatching the event 01356 */ 01357 void delay(int delay) { 01358 if (_event) { 01359 _event->delay = delay; 01360 } 01361 } 01362 01363 /** Configure the period of an event 01364 * 01365 * @param period Millisecond period for repeatedly dispatching an event 01366 */ 01367 void period(int period) { 01368 if (_event) { 01369 _event->period = period; 01370 } 01371 } 01372 01373 /** Posts an event onto the underlying event queue 01374 * 01375 * The event is posted to the underlying queue and is executed in the 01376 * context of the event queue's dispatch loop. 01377 * 01378 * The post function is irq safe and can act as a mechanism for moving 01379 * events out of irq contexts. 01380 * 01381 * @param a0,a1,a2 Arguments to pass to the event 01382 * @return A unique id that represents the posted event and can 01383 * be passed to EventQueue::cancel, or an id of 0 if 01384 * there is not enough memory to allocate the event. 01385 */ 01386 int post(A0 a0, A1 a1, A2 a2) const { 01387 if (!_event) { 01388 return 0; 01389 } 01390 01391 _event->id = _event->post(_event, a0, a1, a2); 01392 return _event->id; 01393 } 01394 01395 /** Posts an event onto the underlying event queue, returning void 01396 * 01397 * @param a0,a1,a2 Arguments to pass to the event 01398 */ 01399 void call(A0 a0, A1 a1, A2 a2) const { 01400 MBED_UNUSED int id = post(a0, a1, a2); 01401 MBED_ASSERT(id); 01402 } 01403 01404 /** Posts an event onto the underlying event queue, returning void 01405 * 01406 * @param a0,a1,a2 Arguments to pass to the event 01407 */ 01408 void operator()(A0 a0, A1 a1, A2 a2) const { 01409 return call(a0, a1, a2); 01410 } 01411 01412 /** Static thunk for passing as C-style function 01413 * 01414 * @param func Event to call passed as a void pointer 01415 * @param a0,a1,a2 Arguments to pass to the event 01416 */ 01417 static void thunk(void *func, A0 a0, A1 a1, A2 a2) { 01418 return static_cast<Event*>(func)->call(a0, a1, a2); 01419 } 01420 01421 /** Cancels the most recently posted event 01422 * 01423 * Attempts to cancel the most recently posted event. It is safe to call 01424 * cancel after an event has already been dispatched. 01425 * 01426 * The cancel function is irq safe. 01427 * 01428 * If called while the event queue's dispatch loop is active, the cancel 01429 * function does not garuntee that the event will not execute after it 01430 * returns, as the event may have already begun executing. 01431 */ 01432 void cancel() const { 01433 if (_event) { 01434 equeue_cancel(_event->equeue, _event->id); 01435 } 01436 } 01437 01438 private: 01439 struct event { 01440 unsigned ref; 01441 equeue_t *equeue; 01442 int id; 01443 01444 int delay; 01445 int period; 01446 01447 int (*post)(struct event *, A0 a0, A1 a1, A2 a2); 01448 void (*dtor)(struct event *); 01449 01450 // F follows 01451 } *_event; 01452 01453 // Event attributes 01454 template <typename F> 01455 static int event_post(struct event *e, A0 a0, A1 a1, A2 a2) { 01456 typedef EventQueue::context30<F, A0, A1, A2> C; 01457 void *p = equeue_alloc(e->equeue, sizeof(C)); 01458 if (!p) { 01459 return 0; 01460 } 01461 01462 new (p) C(*(F*)(e + 1), a0, a1, a2); 01463 equeue_event_delay(p, e->delay); 01464 equeue_event_period(p, e->period); 01465 equeue_event_dtor(p, &EventQueue::function_dtor<C>); 01466 return equeue_post(e->equeue, &EventQueue::function_call<C>, p); 01467 } 01468 01469 template <typename F> 01470 static void event_dtor(struct event *e) { 01471 ((F*)(e + 1))->~F(); 01472 } 01473 01474 public: 01475 /** Create an event 01476 * @param q Event queue to dispatch on 01477 * @param f Function to execute when the event is dispatched 01478 * @param c0 Argument to bind to the callback, these arguments are 01479 * allocated on an irq-safe allocator from the event queue's 01480 * memory pool. Must be type-compatible with b0, the 01481 * arguments to the underlying callback. 01482 */ 01483 template <typename F, typename C0> 01484 Event(EventQueue *q, F f, C0 c0) { 01485 new (this) Event(q, EventQueue::context13<F, C0, A0, A1, A2>(f, c0)); 01486 } 01487 01488 /** Create an event 01489 * @param q Event queue to dispatch on 01490 * @param f Function to execute when the event is dispatched 01491 * @param c0,c1 Arguments to bind to the callback, these arguments are 01492 * allocated on an irq-safe allocator from the event queue's 01493 * memory pool. Must be type-compatible with b0..b1, the 01494 * arguments to the underlying callback. 01495 */ 01496 template <typename F, typename C0, typename C1> 01497 Event(EventQueue *q, F f, C0 c0, C1 c1) { 01498 new (this) Event(q, EventQueue::context23<F, C0, C1, A0, A1, A2>(f, c0, c1)); 01499 } 01500 01501 /** Create an event 01502 * @param q Event queue to dispatch on 01503 * @param f Function to execute when the event is dispatched 01504 * @param c0,c1,c2 Arguments to bind to the callback, these arguments are 01505 * allocated on an irq-safe allocator from the event queue's 01506 * memory pool. Must be type-compatible with b0..b2, the 01507 * arguments to the underlying callback. 01508 */ 01509 template <typename F, typename C0, typename C1, typename C2> 01510 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2) { 01511 new (this) Event(q, EventQueue::context33<F, C0, C1, C2, A0, A1, A2>(f, c0, c1, c2)); 01512 } 01513 01514 /** Create an event 01515 * @param q Event queue to dispatch on 01516 * @param f Function to execute when the event is dispatched 01517 * @param c0,c1,c2,c3 Arguments to bind to the callback, these arguments are 01518 * allocated on an irq-safe allocator from the event queue's 01519 * memory pool. Must be type-compatible with b0..b3, the 01520 * arguments to the underlying callback. 01521 */ 01522 template <typename F, typename C0, typename C1, typename C2, typename C3> 01523 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3) { 01524 new (this) Event(q, EventQueue::context43<F, C0, C1, C2, C3, A0, A1, A2>(f, c0, c1, c2, c3)); 01525 } 01526 01527 /** Create an event 01528 * @param q Event queue to dispatch on 01529 * @param f Function to execute when the event is dispatched 01530 * @param c0,c1,c2,c3,c4 Arguments to bind to the callback, these arguments are 01531 * allocated on an irq-safe allocator from the event queue's 01532 * memory pool. Must be type-compatible with b0..b4, the 01533 * arguments to the underlying callback. 01534 */ 01535 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4> 01536 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) { 01537 new (this) Event(q, EventQueue::context53<F, C0, C1, C2, C3, C4, A0, A1, A2>(f, c0, c1, c2, c3, c4)); 01538 } 01539 01540 /** Create an event 01541 * @see Event::Event 01542 */ 01543 template <typename T, typename R, typename B0> 01544 Event(EventQueue *q, T *obj, R (T::*method)(B0, A0, A1, A2), B0 b0) { 01545 new (this) Event(q, mbed::callback(obj, method), b0); 01546 } 01547 01548 /** Create an event 01549 * @see Event::Event 01550 */ 01551 template <typename T, typename R, typename B0> 01552 Event(EventQueue *q, const T *obj, R (T::*method)(B0, A0, A1, A2) const, B0 b0) { 01553 new (this) Event(q, mbed::callback(obj, method), b0); 01554 } 01555 01556 /** Create an event 01557 * @see Event::Event 01558 */ 01559 template <typename T, typename R, typename B0> 01560 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, A0, A1, A2) volatile, B0 b0) { 01561 new (this) Event(q, mbed::callback(obj, method), b0); 01562 } 01563 01564 /** Create an event 01565 * @see Event::Event 01566 */ 01567 template <typename T, typename R, typename B0> 01568 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, A0, A1, A2) const volatile, B0 b0) { 01569 new (this) Event(q, mbed::callback(obj, method), b0); 01570 } 01571 01572 /** Create an event 01573 * @see Event::Event 01574 */ 01575 template <typename T, typename R, typename B0, typename B1> 01576 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, A0, A1, A2), B0 b0, B1 b1) { 01577 new (this) Event(q, mbed::callback(obj, method), b0, b1); 01578 } 01579 01580 /** Create an event 01581 * @see Event::Event 01582 */ 01583 template <typename T, typename R, typename B0, typename B1> 01584 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, A0, A1, A2) const, B0 b0, B1 b1) { 01585 new (this) Event(q, mbed::callback(obj, method), b0, b1); 01586 } 01587 01588 /** Create an event 01589 * @see Event::Event 01590 */ 01591 template <typename T, typename R, typename B0, typename B1> 01592 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2) volatile, B0 b0, B1 b1) { 01593 new (this) Event(q, mbed::callback(obj, method), b0, b1); 01594 } 01595 01596 /** Create an event 01597 * @see Event::Event 01598 */ 01599 template <typename T, typename R, typename B0, typename B1> 01600 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2) const volatile, B0 b0, B1 b1) { 01601 new (this) Event(q, mbed::callback(obj, method), b0, b1); 01602 } 01603 01604 /** Create an event 01605 * @see Event::Event 01606 */ 01607 template <typename T, typename R, typename B0, typename B1, typename B2> 01608 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2), B0 b0, B1 b1, B2 b2) { 01609 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2); 01610 } 01611 01612 /** Create an event 01613 * @see Event::Event 01614 */ 01615 template <typename T, typename R, typename B0, typename B1, typename B2> 01616 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2) const, B0 b0, B1 b1, B2 b2) { 01617 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2); 01618 } 01619 01620 /** Create an event 01621 * @see Event::Event 01622 */ 01623 template <typename T, typename R, typename B0, typename B1, typename B2> 01624 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2) volatile, B0 b0, B1 b1, B2 b2) { 01625 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2); 01626 } 01627 01628 /** Create an event 01629 * @see Event::Event 01630 */ 01631 template <typename T, typename R, typename B0, typename B1, typename B2> 01632 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2) const volatile, B0 b0, B1 b1, B2 b2) { 01633 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2); 01634 } 01635 01636 /** Create an event 01637 * @see Event::Event 01638 */ 01639 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3> 01640 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2), B0 b0, B1 b1, B2 b2, B3 b3) { 01641 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3); 01642 } 01643 01644 /** Create an event 01645 * @see Event::Event 01646 */ 01647 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3> 01648 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2) const, B0 b0, B1 b1, B2 b2, B3 b3) { 01649 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3); 01650 } 01651 01652 /** Create an event 01653 * @see Event::Event 01654 */ 01655 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3> 01656 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2) volatile, B0 b0, B1 b1, B2 b2, B3 b3) { 01657 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3); 01658 } 01659 01660 /** Create an event 01661 * @see Event::Event 01662 */ 01663 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3> 01664 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2) const volatile, B0 b0, B1 b1, B2 b2, B3 b3) { 01665 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3); 01666 } 01667 01668 /** Create an event 01669 * @see Event::Event 01670 */ 01671 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4> 01672 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2), B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) { 01673 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4); 01674 } 01675 01676 /** Create an event 01677 * @see Event::Event 01678 */ 01679 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4> 01680 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2) const, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) { 01681 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4); 01682 } 01683 01684 /** Create an event 01685 * @see Event::Event 01686 */ 01687 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4> 01688 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2) volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) { 01689 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4); 01690 } 01691 01692 /** Create an event 01693 * @see Event::Event 01694 */ 01695 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4> 01696 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2) const volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) { 01697 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4); 01698 } 01699 }; 01700 01701 /** Event 01702 * 01703 * Representation of an event for fine-grain dispatch control 01704 * @ingroup events 01705 */ 01706 template <typename A0, typename A1, typename A2, typename A3> 01707 class Event<void(A0, A1, A2, A3)> { 01708 public: 01709 /** Create an event 01710 * 01711 * Constructs an event bound to the specified event queue. The specified 01712 * callback acts as the target for the event and is executed in the 01713 * context of the event queue's dispatch loop once posted. 01714 * 01715 * @param q Event queue to dispatch on 01716 * @param f Function to execute when the event is dispatched 01717 */ 01718 template <typename F> 01719 Event(EventQueue *q, F f) { 01720 _event = static_cast<struct event *>( 01721 equeue_alloc(&q->_equeue, sizeof(struct event) + sizeof(F))); 01722 01723 if (_event) { 01724 _event->equeue = &q->_equeue; 01725 _event->id = 0; 01726 _event->delay = 0; 01727 _event->period = -1; 01728 01729 _event->post = &Event::event_post<F>; 01730 _event->dtor = &Event::event_dtor<F>; 01731 01732 new (_event+1) F(f); 01733 01734 _event->ref = 1; 01735 } 01736 } 01737 01738 /** Copy constructor for events 01739 */ 01740 Event(const Event &e) { 01741 _event = 0; 01742 if (e._event) { 01743 _event = e._event; 01744 _event->ref += 1; 01745 } 01746 } 01747 01748 /** Assignment operator for events 01749 */ 01750 Event &operator=(const Event &that) { 01751 if (this != &that) { 01752 this->~Event(); 01753 new (this) Event(that); 01754 } 01755 01756 return *this; 01757 } 01758 01759 /** Destructor for events 01760 */ 01761 ~Event() { 01762 if (_event) { 01763 _event->ref -= 1; 01764 if (_event->ref == 0) { 01765 _event->dtor(_event); 01766 equeue_dealloc(_event->equeue, _event); 01767 } 01768 } 01769 } 01770 01771 /** Configure the delay of an event 01772 * 01773 * @param delay Millisecond delay before dispatching the event 01774 */ 01775 void delay(int delay) { 01776 if (_event) { 01777 _event->delay = delay; 01778 } 01779 } 01780 01781 /** Configure the period of an event 01782 * 01783 * @param period Millisecond period for repeatedly dispatching an event 01784 */ 01785 void period(int period) { 01786 if (_event) { 01787 _event->period = period; 01788 } 01789 } 01790 01791 /** Posts an event onto the underlying event queue 01792 * 01793 * The event is posted to the underlying queue and is executed in the 01794 * context of the event queue's dispatch loop. 01795 * 01796 * The post function is irq safe and can act as a mechanism for moving 01797 * events out of irq contexts. 01798 * 01799 * @param a0,a1,a2,a3 Arguments to pass to the event 01800 * @return A unique id that represents the posted event and can 01801 * be passed to EventQueue::cancel, or an id of 0 if 01802 * there is not enough memory to allocate the event. 01803 */ 01804 int post(A0 a0, A1 a1, A2 a2, A3 a3) const { 01805 if (!_event) { 01806 return 0; 01807 } 01808 01809 _event->id = _event->post(_event, a0, a1, a2, a3); 01810 return _event->id; 01811 } 01812 01813 /** Posts an event onto the underlying event queue, returning void 01814 * 01815 * @param a0,a1,a2,a3 Arguments to pass to the event 01816 */ 01817 void call(A0 a0, A1 a1, A2 a2, A3 a3) const { 01818 MBED_UNUSED int id = post(a0, a1, a2, a3); 01819 MBED_ASSERT(id); 01820 } 01821 01822 /** Posts an event onto the underlying event queue, returning void 01823 * 01824 * @param a0,a1,a2,a3 Arguments to pass to the event 01825 */ 01826 void operator()(A0 a0, A1 a1, A2 a2, A3 a3) const { 01827 return call(a0, a1, a2, a3); 01828 } 01829 01830 /** Static thunk for passing as C-style function 01831 * 01832 * @param func Event to call passed as a void pointer 01833 * @param a0,a1,a2,a3 Arguments to pass to the event 01834 */ 01835 static void thunk(void *func, A0 a0, A1 a1, A2 a2, A3 a3) { 01836 return static_cast<Event*>(func)->call(a0, a1, a2, a3); 01837 } 01838 01839 /** Cancels the most recently posted event 01840 * 01841 * Attempts to cancel the most recently posted event. It is safe to call 01842 * cancel after an event has already been dispatched. 01843 * 01844 * The cancel function is irq safe. 01845 * 01846 * If called while the event queue's dispatch loop is active, the cancel 01847 * function does not garuntee that the event will not execute after it 01848 * returns, as the event may have already begun executing. 01849 */ 01850 void cancel() const { 01851 if (_event) { 01852 equeue_cancel(_event->equeue, _event->id); 01853 } 01854 } 01855 01856 private: 01857 struct event { 01858 unsigned ref; 01859 equeue_t *equeue; 01860 int id; 01861 01862 int delay; 01863 int period; 01864 01865 int (*post)(struct event *, A0 a0, A1 a1, A2 a2, A3 a3); 01866 void (*dtor)(struct event *); 01867 01868 // F follows 01869 } *_event; 01870 01871 // Event attributes 01872 template <typename F> 01873 static int event_post(struct event *e, A0 a0, A1 a1, A2 a2, A3 a3) { 01874 typedef EventQueue::context40<F, A0, A1, A2, A3> C; 01875 void *p = equeue_alloc(e->equeue, sizeof(C)); 01876 if (!p) { 01877 return 0; 01878 } 01879 01880 new (p) C(*(F*)(e + 1), a0, a1, a2, a3); 01881 equeue_event_delay(p, e->delay); 01882 equeue_event_period(p, e->period); 01883 equeue_event_dtor(p, &EventQueue::function_dtor<C>); 01884 return equeue_post(e->equeue, &EventQueue::function_call<C>, p); 01885 } 01886 01887 template <typename F> 01888 static void event_dtor(struct event *e) { 01889 ((F*)(e + 1))->~F(); 01890 } 01891 01892 public: 01893 /** Create an event 01894 * @param q Event queue to dispatch on 01895 * @param f Function to execute when the event is dispatched 01896 * @param c0 Argument to bind to the callback, these arguments are 01897 * allocated on an irq-safe allocator from the event queue's 01898 * memory pool. Must be type-compatible with b0, the 01899 * arguments to the underlying callback. 01900 */ 01901 template <typename F, typename C0> 01902 Event(EventQueue *q, F f, C0 c0) { 01903 new (this) Event(q, EventQueue::context14<F, C0, A0, A1, A2, A3>(f, c0)); 01904 } 01905 01906 /** Create an event 01907 * @param q Event queue to dispatch on 01908 * @param f Function to execute when the event is dispatched 01909 * @param c0,c1 Arguments to bind to the callback, these arguments are 01910 * allocated on an irq-safe allocator from the event queue's 01911 * memory pool. Must be type-compatible with b0..b1, the 01912 * arguments to the underlying callback. 01913 */ 01914 template <typename F, typename C0, typename C1> 01915 Event(EventQueue *q, F f, C0 c0, C1 c1) { 01916 new (this) Event(q, EventQueue::context24<F, C0, C1, A0, A1, A2, A3>(f, c0, c1)); 01917 } 01918 01919 /** Create an event 01920 * @param q Event queue to dispatch on 01921 * @param f Function to execute when the event is dispatched 01922 * @param c0,c1,c2 Arguments to bind to the callback, these arguments are 01923 * allocated on an irq-safe allocator from the event queue's 01924 * memory pool. Must be type-compatible with b0..b2, the 01925 * arguments to the underlying callback. 01926 */ 01927 template <typename F, typename C0, typename C1, typename C2> 01928 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2) { 01929 new (this) Event(q, EventQueue::context34<F, C0, C1, C2, A0, A1, A2, A3>(f, c0, c1, c2)); 01930 } 01931 01932 /** Create an event 01933 * @param q Event queue to dispatch on 01934 * @param f Function to execute when the event is dispatched 01935 * @param c0,c1,c2,c3 Arguments to bind to the callback, these arguments are 01936 * allocated on an irq-safe allocator from the event queue's 01937 * memory pool. Must be type-compatible with b0..b3, the 01938 * arguments to the underlying callback. 01939 */ 01940 template <typename F, typename C0, typename C1, typename C2, typename C3> 01941 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3) { 01942 new (this) Event(q, EventQueue::context44<F, C0, C1, C2, C3, A0, A1, A2, A3>(f, c0, c1, c2, c3)); 01943 } 01944 01945 /** Create an event 01946 * @param q Event queue to dispatch on 01947 * @param f Function to execute when the event is dispatched 01948 * @param c0,c1,c2,c3,c4 Arguments to bind to the callback, these arguments are 01949 * allocated on an irq-safe allocator from the event queue's 01950 * memory pool. Must be type-compatible with b0..b4, the 01951 * arguments to the underlying callback. 01952 */ 01953 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4> 01954 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) { 01955 new (this) Event(q, EventQueue::context54<F, C0, C1, C2, C3, C4, A0, A1, A2, A3>(f, c0, c1, c2, c3, c4)); 01956 } 01957 01958 /** Create an event 01959 * @see Event::Event 01960 */ 01961 template <typename T, typename R, typename B0> 01962 Event(EventQueue *q, T *obj, R (T::*method)(B0, A0, A1, A2, A3), B0 b0) { 01963 new (this) Event(q, mbed::callback(obj, method), b0); 01964 } 01965 01966 /** Create an event 01967 * @see Event::Event 01968 */ 01969 template <typename T, typename R, typename B0> 01970 Event(EventQueue *q, const T *obj, R (T::*method)(B0, A0, A1, A2, A3) const, B0 b0) { 01971 new (this) Event(q, mbed::callback(obj, method), b0); 01972 } 01973 01974 /** Create an event 01975 * @see Event::Event 01976 */ 01977 template <typename T, typename R, typename B0> 01978 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3) volatile, B0 b0) { 01979 new (this) Event(q, mbed::callback(obj, method), b0); 01980 } 01981 01982 /** Create an event 01983 * @see Event::Event 01984 */ 01985 template <typename T, typename R, typename B0> 01986 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3) const volatile, B0 b0) { 01987 new (this) Event(q, mbed::callback(obj, method), b0); 01988 } 01989 01990 /** Create an event 01991 * @see Event::Event 01992 */ 01993 template <typename T, typename R, typename B0, typename B1> 01994 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3), B0 b0, B1 b1) { 01995 new (this) Event(q, mbed::callback(obj, method), b0, b1); 01996 } 01997 01998 /** Create an event 01999 * @see Event::Event 02000 */ 02001 template <typename T, typename R, typename B0, typename B1> 02002 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3) const, B0 b0, B1 b1) { 02003 new (this) Event(q, mbed::callback(obj, method), b0, b1); 02004 } 02005 02006 /** Create an event 02007 * @see Event::Event 02008 */ 02009 template <typename T, typename R, typename B0, typename B1> 02010 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3) volatile, B0 b0, B1 b1) { 02011 new (this) Event(q, mbed::callback(obj, method), b0, b1); 02012 } 02013 02014 /** Create an event 02015 * @see Event::Event 02016 */ 02017 template <typename T, typename R, typename B0, typename B1> 02018 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3) const volatile, B0 b0, B1 b1) { 02019 new (this) Event(q, mbed::callback(obj, method), b0, b1); 02020 } 02021 02022 /** Create an event 02023 * @see Event::Event 02024 */ 02025 template <typename T, typename R, typename B0, typename B1, typename B2> 02026 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3), B0 b0, B1 b1, B2 b2) { 02027 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2); 02028 } 02029 02030 /** Create an event 02031 * @see Event::Event 02032 */ 02033 template <typename T, typename R, typename B0, typename B1, typename B2> 02034 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3) const, B0 b0, B1 b1, B2 b2) { 02035 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2); 02036 } 02037 02038 /** Create an event 02039 * @see Event::Event 02040 */ 02041 template <typename T, typename R, typename B0, typename B1, typename B2> 02042 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3) volatile, B0 b0, B1 b1, B2 b2) { 02043 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2); 02044 } 02045 02046 /** Create an event 02047 * @see Event::Event 02048 */ 02049 template <typename T, typename R, typename B0, typename B1, typename B2> 02050 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3) const volatile, B0 b0, B1 b1, B2 b2) { 02051 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2); 02052 } 02053 02054 /** Create an event 02055 * @see Event::Event 02056 */ 02057 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3> 02058 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3), B0 b0, B1 b1, B2 b2, B3 b3) { 02059 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3); 02060 } 02061 02062 /** Create an event 02063 * @see Event::Event 02064 */ 02065 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3> 02066 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3) const, B0 b0, B1 b1, B2 b2, B3 b3) { 02067 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3); 02068 } 02069 02070 /** Create an event 02071 * @see Event::Event 02072 */ 02073 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3> 02074 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3) volatile, B0 b0, B1 b1, B2 b2, B3 b3) { 02075 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3); 02076 } 02077 02078 /** Create an event 02079 * @see Event::Event 02080 */ 02081 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3> 02082 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3) const volatile, B0 b0, B1 b1, B2 b2, B3 b3) { 02083 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3); 02084 } 02085 02086 /** Create an event 02087 * @see Event::Event 02088 */ 02089 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4> 02090 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3), B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) { 02091 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4); 02092 } 02093 02094 /** Create an event 02095 * @see Event::Event 02096 */ 02097 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4> 02098 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3) const, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) { 02099 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4); 02100 } 02101 02102 /** Create an event 02103 * @see Event::Event 02104 */ 02105 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4> 02106 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3) volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) { 02107 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4); 02108 } 02109 02110 /** Create an event 02111 * @see Event::Event 02112 */ 02113 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4> 02114 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3) const volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) { 02115 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4); 02116 } 02117 }; 02118 02119 /** Event 02120 * 02121 * Representation of an event for fine-grain dispatch control 02122 * @ingroup events 02123 */ 02124 template <typename A0, typename A1, typename A2, typename A3, typename A4> 02125 class Event<void(A0, A1, A2, A3, A4)> { 02126 public: 02127 /** Create an event 02128 * 02129 * Constructs an event bound to the specified event queue. The specified 02130 * callback acts as the target for the event and is executed in the 02131 * context of the event queue's dispatch loop once posted. 02132 * 02133 * @param q Event queue to dispatch on 02134 * @param f Function to execute when the event is dispatched 02135 */ 02136 template <typename F> 02137 Event(EventQueue *q, F f) { 02138 _event = static_cast<struct event *>( 02139 equeue_alloc(&q->_equeue, sizeof(struct event) + sizeof(F))); 02140 02141 if (_event) { 02142 _event->equeue = &q->_equeue; 02143 _event->id = 0; 02144 _event->delay = 0; 02145 _event->period = -1; 02146 02147 _event->post = &Event::event_post<F>; 02148 _event->dtor = &Event::event_dtor<F>; 02149 02150 new (_event+1) F(f); 02151 02152 _event->ref = 1; 02153 } 02154 } 02155 02156 /** Copy constructor for events 02157 */ 02158 Event(const Event &e) { 02159 _event = 0; 02160 if (e._event) { 02161 _event = e._event; 02162 _event->ref += 1; 02163 } 02164 } 02165 02166 /** Assignment operator for events 02167 */ 02168 Event &operator=(const Event &that) { 02169 if (this != &that) { 02170 this->~Event(); 02171 new (this) Event(that); 02172 } 02173 02174 return *this; 02175 } 02176 02177 /** Destructor for events 02178 */ 02179 ~Event() { 02180 if (_event) { 02181 _event->ref -= 1; 02182 if (_event->ref == 0) { 02183 _event->dtor(_event); 02184 equeue_dealloc(_event->equeue, _event); 02185 } 02186 } 02187 } 02188 02189 /** Configure the delay of an event 02190 * 02191 * @param delay Millisecond delay before dispatching the event 02192 */ 02193 void delay(int delay) { 02194 if (_event) { 02195 _event->delay = delay; 02196 } 02197 } 02198 02199 /** Configure the period of an event 02200 * 02201 * @param period Millisecond period for repeatedly dispatching an event 02202 */ 02203 void period(int period) { 02204 if (_event) { 02205 _event->period = period; 02206 } 02207 } 02208 02209 /** Posts an event onto the underlying event queue 02210 * 02211 * The event is posted to the underlying queue and is executed in the 02212 * context of the event queue's dispatch loop. 02213 * 02214 * The post function is irq safe and can act as a mechanism for moving 02215 * events out of irq contexts. 02216 * 02217 * @param a0,a1,a2,a3,a4 Arguments to pass to the event 02218 * @return A unique id that represents the posted event and can 02219 * be passed to EventQueue::cancel, or an id of 0 if 02220 * there is not enough memory to allocate the event. 02221 */ 02222 int post(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const { 02223 if (!_event) { 02224 return 0; 02225 } 02226 02227 _event->id = _event->post(_event, a0, a1, a2, a3, a4); 02228 return _event->id; 02229 } 02230 02231 /** Posts an event onto the underlying event queue, returning void 02232 * 02233 * @param a0,a1,a2,a3,a4 Arguments to pass to the event 02234 */ 02235 void call(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const { 02236 MBED_UNUSED int id = post(a0, a1, a2, a3, a4); 02237 MBED_ASSERT(id); 02238 } 02239 02240 /** Posts an event onto the underlying event queue, returning void 02241 * 02242 * @param a0,a1,a2,a3,a4 Arguments to pass to the event 02243 */ 02244 void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const { 02245 return call(a0, a1, a2, a3, a4); 02246 } 02247 02248 /** Static thunk for passing as C-style function 02249 * 02250 * @param func Event to call passed as a void pointer 02251 * @param a0,a1,a2,a3,a4 Arguments to pass to the event 02252 */ 02253 static void thunk(void *func, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 02254 return static_cast<Event*>(func)->call(a0, a1, a2, a3, a4); 02255 } 02256 02257 /** Cancels the most recently posted event 02258 * 02259 * Attempts to cancel the most recently posted event. It is safe to call 02260 * cancel after an event has already been dispatched. 02261 * 02262 * The cancel function is irq safe. 02263 * 02264 * If called while the event queue's dispatch loop is active, the cancel 02265 * function does not garuntee that the event will not execute after it 02266 * returns, as the event may have already begun executing. 02267 */ 02268 void cancel() const { 02269 if (_event) { 02270 equeue_cancel(_event->equeue, _event->id); 02271 } 02272 } 02273 02274 private: 02275 struct event { 02276 unsigned ref; 02277 equeue_t *equeue; 02278 int id; 02279 02280 int delay; 02281 int period; 02282 02283 int (*post)(struct event *, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4); 02284 void (*dtor)(struct event *); 02285 02286 // F follows 02287 } *_event; 02288 02289 // Event attributes 02290 template <typename F> 02291 static int event_post(struct event *e, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 02292 typedef EventQueue::context50<F, A0, A1, A2, A3, A4> C; 02293 void *p = equeue_alloc(e->equeue, sizeof(C)); 02294 if (!p) { 02295 return 0; 02296 } 02297 02298 new (p) C(*(F*)(e + 1), a0, a1, a2, a3, a4); 02299 equeue_event_delay(p, e->delay); 02300 equeue_event_period(p, e->period); 02301 equeue_event_dtor(p, &EventQueue::function_dtor<C>); 02302 return equeue_post(e->equeue, &EventQueue::function_call<C>, p); 02303 } 02304 02305 template <typename F> 02306 static void event_dtor(struct event *e) { 02307 ((F*)(e + 1))->~F(); 02308 } 02309 02310 public: 02311 /** Create an event 02312 * @param q Event queue to dispatch on 02313 * @param f Function to execute when the event is dispatched 02314 * @param c0 Argument to bind to the callback, these arguments are 02315 * allocated on an irq-safe allocator from the event queue's 02316 * memory pool. Must be type-compatible with b0, the 02317 * arguments to the underlying callback. 02318 */ 02319 template <typename F, typename C0> 02320 Event(EventQueue *q, F f, C0 c0) { 02321 new (this) Event(q, EventQueue::context15<F, C0, A0, A1, A2, A3, A4>(f, c0)); 02322 } 02323 02324 /** Create an event 02325 * @param q Event queue to dispatch on 02326 * @param f Function to execute when the event is dispatched 02327 * @param c0,c1 Arguments to bind to the callback, these arguments are 02328 * allocated on an irq-safe allocator from the event queue's 02329 * memory pool. Must be type-compatible with b0..b1, the 02330 * arguments to the underlying callback. 02331 */ 02332 template <typename F, typename C0, typename C1> 02333 Event(EventQueue *q, F f, C0 c0, C1 c1) { 02334 new (this) Event(q, EventQueue::context25<F, C0, C1, A0, A1, A2, A3, A4>(f, c0, c1)); 02335 } 02336 02337 /** Create an event 02338 * @param q Event queue to dispatch on 02339 * @param f Function to execute when the event is dispatched 02340 * @param c0,c1,c2 Arguments to bind to the callback, these arguments are 02341 * allocated on an irq-safe allocator from the event queue's 02342 * memory pool. Must be type-compatible with b0..b2, the 02343 * arguments to the underlying callback. 02344 */ 02345 template <typename F, typename C0, typename C1, typename C2> 02346 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2) { 02347 new (this) Event(q, EventQueue::context35<F, C0, C1, C2, A0, A1, A2, A3, A4>(f, c0, c1, c2)); 02348 } 02349 02350 /** Create an event 02351 * @param q Event queue to dispatch on 02352 * @param f Function to execute when the event is dispatched 02353 * @param c0,c1,c2,c3 Arguments to bind to the callback, these arguments are 02354 * allocated on an irq-safe allocator from the event queue's 02355 * memory pool. Must be type-compatible with b0..b3, the 02356 * arguments to the underlying callback. 02357 */ 02358 template <typename F, typename C0, typename C1, typename C2, typename C3> 02359 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3) { 02360 new (this) Event(q, EventQueue::context45<F, C0, C1, C2, C3, A0, A1, A2, A3, A4>(f, c0, c1, c2, c3)); 02361 } 02362 02363 /** Create an event 02364 * @param q Event queue to dispatch on 02365 * @param f Function to execute when the event is dispatched 02366 * @param c0,c1,c2,c3,c4 Arguments to bind to the callback, these arguments are 02367 * allocated on an irq-safe allocator from the event queue's 02368 * memory pool. Must be type-compatible with b0..b4, the 02369 * arguments to the underlying callback. 02370 */ 02371 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4> 02372 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) { 02373 new (this) Event(q, EventQueue::context55<F, C0, C1, C2, C3, C4, A0, A1, A2, A3, A4>(f, c0, c1, c2, c3, c4)); 02374 } 02375 02376 /** Create an event 02377 * @see Event::Event 02378 */ 02379 template <typename T, typename R, typename B0> 02380 Event(EventQueue *q, T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4), B0 b0) { 02381 new (this) Event(q, mbed::callback(obj, method), b0); 02382 } 02383 02384 /** Create an event 02385 * @see Event::Event 02386 */ 02387 template <typename T, typename R, typename B0> 02388 Event(EventQueue *q, const T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4) const, B0 b0) { 02389 new (this) Event(q, mbed::callback(obj, method), b0); 02390 } 02391 02392 /** Create an event 02393 * @see Event::Event 02394 */ 02395 template <typename T, typename R, typename B0> 02396 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4) volatile, B0 b0) { 02397 new (this) Event(q, mbed::callback(obj, method), b0); 02398 } 02399 02400 /** Create an event 02401 * @see Event::Event 02402 */ 02403 template <typename T, typename R, typename B0> 02404 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4) const volatile, B0 b0) { 02405 new (this) Event(q, mbed::callback(obj, method), b0); 02406 } 02407 02408 /** Create an event 02409 * @see Event::Event 02410 */ 02411 template <typename T, typename R, typename B0, typename B1> 02412 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3, A4), B0 b0, B1 b1) { 02413 new (this) Event(q, mbed::callback(obj, method), b0, b1); 02414 } 02415 02416 /** Create an event 02417 * @see Event::Event 02418 */ 02419 template <typename T, typename R, typename B0, typename B1> 02420 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3, A4) const, B0 b0, B1 b1) { 02421 new (this) Event(q, mbed::callback(obj, method), b0, b1); 02422 } 02423 02424 /** Create an event 02425 * @see Event::Event 02426 */ 02427 template <typename T, typename R, typename B0, typename B1> 02428 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3, A4) volatile, B0 b0, B1 b1) { 02429 new (this) Event(q, mbed::callback(obj, method), b0, b1); 02430 } 02431 02432 /** Create an event 02433 * @see Event::Event 02434 */ 02435 template <typename T, typename R, typename B0, typename B1> 02436 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3, A4) const volatile, B0 b0, B1 b1) { 02437 new (this) Event(q, mbed::callback(obj, method), b0, b1); 02438 } 02439 02440 /** Create an event 02441 * @see Event::Event 02442 */ 02443 template <typename T, typename R, typename B0, typename B1, typename B2> 02444 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3, A4), B0 b0, B1 b1, B2 b2) { 02445 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2); 02446 } 02447 02448 /** Create an event 02449 * @see Event::Event 02450 */ 02451 template <typename T, typename R, typename B0, typename B1, typename B2> 02452 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3, A4) const, B0 b0, B1 b1, B2 b2) { 02453 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2); 02454 } 02455 02456 /** Create an event 02457 * @see Event::Event 02458 */ 02459 template <typename T, typename R, typename B0, typename B1, typename B2> 02460 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3, A4) volatile, B0 b0, B1 b1, B2 b2) { 02461 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2); 02462 } 02463 02464 /** Create an event 02465 * @see Event::Event 02466 */ 02467 template <typename T, typename R, typename B0, typename B1, typename B2> 02468 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3, A4) const volatile, B0 b0, B1 b1, B2 b2) { 02469 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2); 02470 } 02471 02472 /** Create an event 02473 * @see Event::Event 02474 */ 02475 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3> 02476 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3, A4), B0 b0, B1 b1, B2 b2, B3 b3) { 02477 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3); 02478 } 02479 02480 /** Create an event 02481 * @see Event::Event 02482 */ 02483 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3> 02484 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3, A4) const, B0 b0, B1 b1, B2 b2, B3 b3) { 02485 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3); 02486 } 02487 02488 /** Create an event 02489 * @see Event::Event 02490 */ 02491 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3> 02492 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3, A4) volatile, B0 b0, B1 b1, B2 b2, B3 b3) { 02493 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3); 02494 } 02495 02496 /** Create an event 02497 * @see Event::Event 02498 */ 02499 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3> 02500 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3, A4) const volatile, B0 b0, B1 b1, B2 b2, B3 b3) { 02501 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3); 02502 } 02503 02504 /** Create an event 02505 * @see Event::Event 02506 */ 02507 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4> 02508 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4), B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) { 02509 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4); 02510 } 02511 02512 /** Create an event 02513 * @see Event::Event 02514 */ 02515 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4> 02516 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4) const, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) { 02517 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4); 02518 } 02519 02520 /** Create an event 02521 * @see Event::Event 02522 */ 02523 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4> 02524 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4) volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) { 02525 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4); 02526 } 02527 02528 /** Create an event 02529 * @see Event::Event 02530 */ 02531 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4> 02532 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4) const volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) { 02533 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4); 02534 } 02535 }; 02536 02537 02538 /** \addtogroup events */ 02539 /** @{ */ 02540 02541 // Convenience functions declared here to avoid cyclic 02542 // dependency between Event and EventQueue 02543 template <typename R> 02544 Event<void()> EventQueue::event(R (*func)()) { 02545 return Event<void()>(this, func); 02546 } 02547 02548 template <typename T, typename R> 02549 Event<void()> EventQueue::event(T *obj, R (T::*method)()) { 02550 return Event<void()>(this, mbed::callback(obj, method)); 02551 } 02552 02553 template <typename T, typename R> 02554 Event<void()> EventQueue::event(const T *obj, R (T::*method)() const) { 02555 return Event<void()>(this, mbed::callback(obj, method)); 02556 } 02557 02558 template <typename T, typename R> 02559 Event<void()> EventQueue::event(volatile T *obj, R (T::*method)() volatile) { 02560 return Event<void()>(this, mbed::callback(obj, method)); 02561 } 02562 02563 template <typename T, typename R> 02564 Event<void()> EventQueue::event(const volatile T *obj, R (T::*method)() const volatile) { 02565 return Event<void()>(this, mbed::callback(obj, method)); 02566 } 02567 02568 template <typename R> 02569 Event<void()> EventQueue::event(mbed::Callback<R()> cb) { 02570 return Event<void()>(this, cb); 02571 } 02572 02573 template <typename R, typename B0, typename C0> 02574 Event<void()> EventQueue::event(R (*func)(B0), C0 c0) { 02575 return Event<void()>(this, func, c0); 02576 } 02577 02578 template <typename T, typename R, typename B0, typename C0> 02579 Event<void()> EventQueue::event(T *obj, R (T::*method)(B0), C0 c0) { 02580 return Event<void()>(this, mbed::callback(obj, method), c0); 02581 } 02582 02583 template <typename T, typename R, typename B0, typename C0> 02584 Event<void()> EventQueue::event(const T *obj, R (T::*method)(B0) const, C0 c0) { 02585 return Event<void()>(this, mbed::callback(obj, method), c0); 02586 } 02587 02588 template <typename T, typename R, typename B0, typename C0> 02589 Event<void()> EventQueue::event(volatile T *obj, R (T::*method)(B0) volatile, C0 c0) { 02590 return Event<void()>(this, mbed::callback(obj, method), c0); 02591 } 02592 02593 template <typename T, typename R, typename B0, typename C0> 02594 Event<void()> EventQueue::event(const volatile T *obj, R (T::*method)(B0) const volatile, C0 c0) { 02595 return Event<void()>(this, mbed::callback(obj, method), c0); 02596 } 02597 02598 template <typename R, typename B0, typename C0> 02599 Event<void()> EventQueue::event(mbed::Callback<R(B0)> cb, C0 c0) { 02600 return Event<void()>(this, cb, c0); 02601 } 02602 02603 template <typename R, typename B0, typename B1, typename C0, typename C1> 02604 Event<void()> EventQueue::event(R (*func)(B0, B1), C0 c0, C1 c1) { 02605 return Event<void()>(this, func, c0, c1); 02606 } 02607 02608 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1> 02609 Event<void()> EventQueue::event(T *obj, R (T::*method)(B0, B1), C0 c0, C1 c1) { 02610 return Event<void()>(this, mbed::callback(obj, method), c0, c1); 02611 } 02612 02613 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1> 02614 Event<void()> EventQueue::event(const T *obj, R (T::*method)(B0, B1) const, C0 c0, C1 c1) { 02615 return Event<void()>(this, mbed::callback(obj, method), c0, c1); 02616 } 02617 02618 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1> 02619 Event<void()> EventQueue::event(volatile T *obj, R (T::*method)(B0, B1) volatile, C0 c0, C1 c1) { 02620 return Event<void()>(this, mbed::callback(obj, method), c0, c1); 02621 } 02622 02623 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1> 02624 Event<void()> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1) const volatile, C0 c0, C1 c1) { 02625 return Event<void()>(this, mbed::callback(obj, method), c0, c1); 02626 } 02627 02628 template <typename R, typename B0, typename B1, typename C0, typename C1> 02629 Event<void()> EventQueue::event(mbed::Callback<R(B0, B1)> cb, C0 c0, C1 c1) { 02630 return Event<void()>(this, cb, c0, c1); 02631 } 02632 02633 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2> 02634 Event<void()> EventQueue::event(R (*func)(B0, B1, B2), C0 c0, C1 c1, C2 c2) { 02635 return Event<void()>(this, func, c0, c1, c2); 02636 } 02637 02638 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2> 02639 Event<void()> EventQueue::event(T *obj, R (T::*method)(B0, B1, B2), C0 c0, C1 c1, C2 c2) { 02640 return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2); 02641 } 02642 02643 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2> 02644 Event<void()> EventQueue::event(const T *obj, R (T::*method)(B0, B1, B2) const, C0 c0, C1 c1, C2 c2) { 02645 return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2); 02646 } 02647 02648 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2> 02649 Event<void()> EventQueue::event(volatile T *obj, R (T::*method)(B0, B1, B2) volatile, C0 c0, C1 c1, C2 c2) { 02650 return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2); 02651 } 02652 02653 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2> 02654 Event<void()> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1, B2) const volatile, C0 c0, C1 c1, C2 c2) { 02655 return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2); 02656 } 02657 02658 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2> 02659 Event<void()> EventQueue::event(mbed::Callback<R(B0, B1, B2)> cb, C0 c0, C1 c1, C2 c2) { 02660 return Event<void()>(this, cb, c0, c1, c2); 02661 } 02662 02663 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3> 02664 Event<void()> EventQueue::event(R (*func)(B0, B1, B2, B3), C0 c0, C1 c1, C2 c2, C3 c3) { 02665 return Event<void()>(this, func, c0, c1, c2, c3); 02666 } 02667 02668 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3> 02669 Event<void()> EventQueue::event(T *obj, R (T::*method)(B0, B1, B2, B3), C0 c0, C1 c1, C2 c2, C3 c3) { 02670 return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2, c3); 02671 } 02672 02673 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3> 02674 Event<void()> EventQueue::event(const T *obj, R (T::*method)(B0, B1, B2, B3) const, C0 c0, C1 c1, C2 c2, C3 c3) { 02675 return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2, c3); 02676 } 02677 02678 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3> 02679 Event<void()> EventQueue::event(volatile T *obj, R (T::*method)(B0, B1, B2, B3) volatile, C0 c0, C1 c1, C2 c2, C3 c3) { 02680 return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2, c3); 02681 } 02682 02683 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3> 02684 Event<void()> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3) const volatile, C0 c0, C1 c1, C2 c2, C3 c3) { 02685 return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2, c3); 02686 } 02687 02688 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3> 02689 Event<void()> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3)> cb, C0 c0, C1 c1, C2 c2, C3 c3) { 02690 return Event<void()>(this, cb, c0, c1, c2, c3); 02691 } 02692 02693 template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4> 02694 Event<void()> EventQueue::event(R (*func)(B0, B1, B2, B3, B4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) { 02695 return Event<void()>(this, func, c0, c1, c2, c3, c4); 02696 } 02697 02698 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> 02699 Event<void()> EventQueue::event(T *obj, R (T::*method)(B0, B1, B2, B3, B4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) { 02700 return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4); 02701 } 02702 02703 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> 02704 Event<void()> EventQueue::event(const T *obj, R (T::*method)(B0, B1, B2, B3, B4) const, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) { 02705 return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4); 02706 } 02707 02708 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> 02709 Event<void()> EventQueue::event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4) volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) { 02710 return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4); 02711 } 02712 02713 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> 02714 Event<void()> EventQueue::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) { 02715 return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4); 02716 } 02717 02718 template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4> 02719 Event<void()> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, B4)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) { 02720 return Event<void()>(this, cb, c0, c1, c2, c3, c4); 02721 } 02722 02723 template <typename R, typename A0> 02724 Event<void(A0)> EventQueue::event(R (*func)(A0)) { 02725 return Event<void(A0)>(this, func); 02726 } 02727 02728 template <typename T, typename R, typename A0> 02729 Event<void(A0)> EventQueue::event(T *obj, R (T::*method)(A0)) { 02730 return Event<void(A0)>(this, mbed::callback(obj, method)); 02731 } 02732 02733 template <typename T, typename R, typename A0> 02734 Event<void(A0)> EventQueue::event(const T *obj, R (T::*method)(A0) const) { 02735 return Event<void(A0)>(this, mbed::callback(obj, method)); 02736 } 02737 02738 template <typename T, typename R, typename A0> 02739 Event<void(A0)> EventQueue::event(volatile T *obj, R (T::*method)(A0) volatile) { 02740 return Event<void(A0)>(this, mbed::callback(obj, method)); 02741 } 02742 02743 template <typename T, typename R, typename A0> 02744 Event<void(A0)> EventQueue::event(const volatile T *obj, R (T::*method)(A0) const volatile) { 02745 return Event<void(A0)>(this, mbed::callback(obj, method)); 02746 } 02747 02748 template <typename R, typename A0> 02749 Event<void(A0)> EventQueue::event(mbed::Callback<R(A0)> cb) { 02750 return Event<void(A0)>(this, cb); 02751 } 02752 02753 template <typename R, typename B0, typename C0, typename A0> 02754 Event<void(A0)> EventQueue::event(R (*func)(B0, A0), C0 c0) { 02755 return Event<void(A0)>(this, func, c0); 02756 } 02757 02758 template <typename T, typename R, typename B0, typename C0, typename A0> 02759 Event<void(A0)> EventQueue::event(T *obj, R (T::*method)(B0, A0), C0 c0) { 02760 return Event<void(A0)>(this, mbed::callback(obj, method), c0); 02761 } 02762 02763 template <typename T, typename R, typename B0, typename C0, typename A0> 02764 Event<void(A0)> EventQueue::event(const T *obj, R (T::*method)(B0, A0) const, C0 c0) { 02765 return Event<void(A0)>(this, mbed::callback(obj, method), c0); 02766 } 02767 02768 template <typename T, typename R, typename B0, typename C0, typename A0> 02769 Event<void(A0)> EventQueue::event(volatile T *obj, R (T::*method)(B0, A0) volatile, C0 c0) { 02770 return Event<void(A0)>(this, mbed::callback(obj, method), c0); 02771 } 02772 02773 template <typename T, typename R, typename B0, typename C0, typename A0> 02774 Event<void(A0)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, A0) const volatile, C0 c0) { 02775 return Event<void(A0)>(this, mbed::callback(obj, method), c0); 02776 } 02777 02778 template <typename R, typename B0, typename C0, typename A0> 02779 Event<void(A0)> EventQueue::event(mbed::Callback<R(B0, A0)> cb, C0 c0) { 02780 return Event<void(A0)>(this, cb, c0); 02781 } 02782 02783 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0> 02784 Event<void(A0)> EventQueue::event(R (*func)(B0, B1, A0), C0 c0, C1 c1) { 02785 return Event<void(A0)>(this, func, c0, c1); 02786 } 02787 02788 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0> 02789 Event<void(A0)> EventQueue::event(T *obj, R (T::*method)(B0, B1, A0), C0 c0, C1 c1) { 02790 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1); 02791 } 02792 02793 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0> 02794 Event<void(A0)> EventQueue::event(const T *obj, R (T::*method)(B0, B1, A0) const, C0 c0, C1 c1) { 02795 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1); 02796 } 02797 02798 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0> 02799 Event<void(A0)> EventQueue::event(volatile T *obj, R (T::*method)(B0, B1, A0) volatile, C0 c0, C1 c1) { 02800 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1); 02801 } 02802 02803 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0> 02804 Event<void(A0)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1, A0) const volatile, C0 c0, C1 c1) { 02805 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1); 02806 } 02807 02808 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0> 02809 Event<void(A0)> EventQueue::event(mbed::Callback<R(B0, B1, A0)> cb, C0 c0, C1 c1) { 02810 return Event<void(A0)>(this, cb, c0, c1); 02811 } 02812 02813 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0> 02814 Event<void(A0)> EventQueue::event(R (*func)(B0, B1, B2, A0), C0 c0, C1 c1, C2 c2) { 02815 return Event<void(A0)>(this, func, c0, c1, c2); 02816 } 02817 02818 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0> 02819 Event<void(A0)> EventQueue::event(T *obj, R (T::*method)(B0, B1, B2, A0), C0 c0, C1 c1, C2 c2) { 02820 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2); 02821 } 02822 02823 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0> 02824 Event<void(A0)> EventQueue::event(const T *obj, R (T::*method)(B0, B1, B2, A0) const, C0 c0, C1 c1, C2 c2) { 02825 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2); 02826 } 02827 02828 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0> 02829 Event<void(A0)> EventQueue::event(volatile T *obj, R (T::*method)(B0, B1, B2, A0) volatile, C0 c0, C1 c1, C2 c2) { 02830 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2); 02831 } 02832 02833 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0> 02834 Event<void(A0)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1, B2, A0) const volatile, C0 c0, C1 c1, C2 c2) { 02835 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2); 02836 } 02837 02838 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0> 02839 Event<void(A0)> EventQueue::event(mbed::Callback<R(B0, B1, B2, A0)> cb, C0 c0, C1 c1, C2 c2) { 02840 return Event<void(A0)>(this, cb, c0, c1, c2); 02841 } 02842 02843 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0> 02844 Event<void(A0)> EventQueue::event(R (*func)(B0, B1, B2, B3, A0), C0 c0, C1 c1, C2 c2, C3 c3) { 02845 return Event<void(A0)>(this, func, c0, c1, c2, c3); 02846 } 02847 02848 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0> 02849 Event<void(A0)> EventQueue::event(T *obj, R (T::*method)(B0, B1, B2, B3, A0), C0 c0, C1 c1, C2 c2, C3 c3) { 02850 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2, c3); 02851 } 02852 02853 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0> 02854 Event<void(A0)> EventQueue::event(const T *obj, R (T::*method)(B0, B1, B2, B3, A0) const, C0 c0, C1 c1, C2 c2, C3 c3) { 02855 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2, c3); 02856 } 02857 02858 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0> 02859 Event<void(A0)> EventQueue::event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0) volatile, C0 c0, C1 c1, C2 c2, C3 c3) { 02860 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2, c3); 02861 } 02862 02863 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0> 02864 Event<void(A0)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0) const volatile, C0 c0, C1 c1, C2 c2, C3 c3) { 02865 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2, c3); 02866 } 02867 02868 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0> 02869 Event<void(A0)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, A0)> cb, C0 c0, C1 c1, C2 c2, C3 c3) { 02870 return Event<void(A0)>(this, cb, c0, c1, c2, c3); 02871 } 02872 02873 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> 02874 Event<void(A0)> EventQueue::event(R (*func)(B0, B1, B2, B3, B4, A0), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) { 02875 return Event<void(A0)>(this, func, c0, c1, c2, c3, c4); 02876 } 02877 02878 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> 02879 Event<void(A0)> EventQueue::event(T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) { 02880 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4); 02881 } 02882 02883 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> 02884 Event<void(A0)> EventQueue::event(const T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0) const, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) { 02885 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4); 02886 } 02887 02888 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> 02889 Event<void(A0)> EventQueue::event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0) volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) { 02890 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4); 02891 } 02892 02893 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> 02894 Event<void(A0)> EventQueue::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) { 02895 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4); 02896 } 02897 02898 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> 02899 Event<void(A0)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, B4, A0)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) { 02900 return Event<void(A0)>(this, cb, c0, c1, c2, c3, c4); 02901 } 02902 02903 template <typename R, typename A0, typename A1> 02904 Event<void(A0, A1)> EventQueue::event(R (*func)(A0, A1)) { 02905 return Event<void(A0, A1)>(this, func); 02906 } 02907 02908 template <typename T, typename R, typename A0, typename A1> 02909 Event<void(A0, A1)> EventQueue::event(T *obj, R (T::*method)(A0, A1)) { 02910 return Event<void(A0, A1)>(this, mbed::callback(obj, method)); 02911 } 02912 02913 template <typename T, typename R, typename A0, typename A1> 02914 Event<void(A0, A1)> EventQueue::event(const T *obj, R (T::*method)(A0, A1) const) { 02915 return Event<void(A0, A1)>(this, mbed::callback(obj, method)); 02916 } 02917 02918 template <typename T, typename R, typename A0, typename A1> 02919 Event<void(A0, A1)> EventQueue::event(volatile T *obj, R (T::*method)(A0, A1) volatile) { 02920 return Event<void(A0, A1)>(this, mbed::callback(obj, method)); 02921 } 02922 02923 template <typename T, typename R, typename A0, typename A1> 02924 Event<void(A0, A1)> EventQueue::event(const volatile T *obj, R (T::*method)(A0, A1) const volatile) { 02925 return Event<void(A0, A1)>(this, mbed::callback(obj, method)); 02926 } 02927 02928 template <typename R, typename A0, typename A1> 02929 Event<void(A0, A1)> EventQueue::event(mbed::Callback<R(A0, A1)> cb) { 02930 return Event<void(A0, A1)>(this, cb); 02931 } 02932 02933 template <typename R, typename B0, typename C0, typename A0, typename A1> 02934 Event<void(A0, A1)> EventQueue::event(R (*func)(B0, A0, A1), C0 c0) { 02935 return Event<void(A0, A1)>(this, func, c0); 02936 } 02937 02938 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1> 02939 Event<void(A0, A1)> EventQueue::event(T *obj, R (T::*method)(B0, A0, A1), C0 c0) { 02940 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0); 02941 } 02942 02943 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1> 02944 Event<void(A0, A1)> EventQueue::event(const T *obj, R (T::*method)(B0, A0, A1) const, C0 c0) { 02945 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0); 02946 } 02947 02948 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1> 02949 Event<void(A0, A1)> EventQueue::event(volatile T *obj, R (T::*method)(B0, A0, A1) volatile, C0 c0) { 02950 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0); 02951 } 02952 02953 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1> 02954 Event<void(A0, A1)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, A0, A1) const volatile, C0 c0) { 02955 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0); 02956 } 02957 02958 template <typename R, typename B0, typename C0, typename A0, typename A1> 02959 Event<void(A0, A1)> EventQueue::event(mbed::Callback<R(B0, A0, A1)> cb, C0 c0) { 02960 return Event<void(A0, A1)>(this, cb, c0); 02961 } 02962 02963 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1> 02964 Event<void(A0, A1)> EventQueue::event(R (*func)(B0, B1, A0, A1), C0 c0, C1 c1) { 02965 return Event<void(A0, A1)>(this, func, c0, c1); 02966 } 02967 02968 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1> 02969 Event<void(A0, A1)> EventQueue::event(T *obj, R (T::*method)(B0, B1, A0, A1), C0 c0, C1 c1) { 02970 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1); 02971 } 02972 02973 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1> 02974 Event<void(A0, A1)> EventQueue::event(const T *obj, R (T::*method)(B0, B1, A0, A1) const, C0 c0, C1 c1) { 02975 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1); 02976 } 02977 02978 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1> 02979 Event<void(A0, A1)> EventQueue::event(volatile T *obj, R (T::*method)(B0, B1, A0, A1) volatile, C0 c0, C1 c1) { 02980 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1); 02981 } 02982 02983 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1> 02984 Event<void(A0, A1)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1, A0, A1) const volatile, C0 c0, C1 c1) { 02985 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1); 02986 } 02987 02988 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1> 02989 Event<void(A0, A1)> EventQueue::event(mbed::Callback<R(B0, B1, A0, A1)> cb, C0 c0, C1 c1) { 02990 return Event<void(A0, A1)>(this, cb, c0, c1); 02991 } 02992 02993 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1> 02994 Event<void(A0, A1)> EventQueue::event(R (*func)(B0, B1, B2, A0, A1), C0 c0, C1 c1, C2 c2) { 02995 return Event<void(A0, A1)>(this, func, c0, c1, c2); 02996 } 02997 02998 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1> 02999 Event<void(A0, A1)> EventQueue::event(T *obj, R (T::*method)(B0, B1, B2, A0, A1), C0 c0, C1 c1, C2 c2) { 03000 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2); 03001 } 03002 03003 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1> 03004 Event<void(A0, A1)> EventQueue::event(const T *obj, R (T::*method)(B0, B1, B2, A0, A1) const, C0 c0, C1 c1, C2 c2) { 03005 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2); 03006 } 03007 03008 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1> 03009 Event<void(A0, A1)> EventQueue::event(volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1) volatile, C0 c0, C1 c1, C2 c2) { 03010 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2); 03011 } 03012 03013 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1> 03014 Event<void(A0, A1)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1) const volatile, C0 c0, C1 c1, C2 c2) { 03015 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2); 03016 } 03017 03018 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1> 03019 Event<void(A0, A1)> EventQueue::event(mbed::Callback<R(B0, B1, B2, A0, A1)> cb, C0 c0, C1 c1, C2 c2) { 03020 return Event<void(A0, A1)>(this, cb, c0, c1, c2); 03021 } 03022 03023 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1> 03024 Event<void(A0, A1)> EventQueue::event(R (*func)(B0, B1, B2, B3, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3) { 03025 return Event<void(A0, A1)>(this, func, c0, c1, c2, c3); 03026 } 03027 03028 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> 03029 Event<void(A0, A1)> EventQueue::event(T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3) { 03030 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2, c3); 03031 } 03032 03033 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> 03034 Event<void(A0, A1)> EventQueue::event(const T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1) const, C0 c0, C1 c1, C2 c2, C3 c3) { 03035 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2, c3); 03036 } 03037 03038 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> 03039 Event<void(A0, A1)> EventQueue::event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1) volatile, C0 c0, C1 c1, C2 c2, C3 c3) { 03040 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2, c3); 03041 } 03042 03043 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> 03044 Event<void(A0, A1)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1) const volatile, C0 c0, C1 c1, C2 c2, C3 c3) { 03045 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2, c3); 03046 } 03047 03048 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1> 03049 Event<void(A0, A1)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, A0, A1)> cb, C0 c0, C1 c1, C2 c2, C3 c3) { 03050 return Event<void(A0, A1)>(this, cb, c0, c1, c2, c3); 03051 } 03052 03053 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> 03054 Event<void(A0, A1)> EventQueue::event(R (*func)(B0, B1, B2, B3, B4, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) { 03055 return Event<void(A0, A1)>(this, func, c0, c1, c2, c3, c4); 03056 } 03057 03058 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> 03059 Event<void(A0, A1)> EventQueue::event(T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) { 03060 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4); 03061 } 03062 03063 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> 03064 Event<void(A0, A1)> EventQueue::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) { 03065 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4); 03066 } 03067 03068 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> 03069 Event<void(A0, A1)> EventQueue::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) { 03070 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4); 03071 } 03072 03073 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> 03074 Event<void(A0, A1)> EventQueue::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) { 03075 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4); 03076 } 03077 03078 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> 03079 Event<void(A0, A1)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, B4, A0, A1)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) { 03080 return Event<void(A0, A1)>(this, cb, c0, c1, c2, c3, c4); 03081 } 03082 03083 template <typename R, typename A0, typename A1, typename A2> 03084 Event<void(A0, A1, A2)> EventQueue::event(R (*func)(A0, A1, A2)) { 03085 return Event<void(A0, A1, A2)>(this, func); 03086 } 03087 03088 template <typename T, typename R, typename A0, typename A1, typename A2> 03089 Event<void(A0, A1, A2)> EventQueue::event(T *obj, R (T::*method)(A0, A1, A2)) { 03090 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method)); 03091 } 03092 03093 template <typename T, typename R, typename A0, typename A1, typename A2> 03094 Event<void(A0, A1, A2)> EventQueue::event(const T *obj, R (T::*method)(A0, A1, A2) const) { 03095 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method)); 03096 } 03097 03098 template <typename T, typename R, typename A0, typename A1, typename A2> 03099 Event<void(A0, A1, A2)> EventQueue::event(volatile T *obj, R (T::*method)(A0, A1, A2) volatile) { 03100 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method)); 03101 } 03102 03103 template <typename T, typename R, typename A0, typename A1, typename A2> 03104 Event<void(A0, A1, A2)> EventQueue::event(const volatile T *obj, R (T::*method)(A0, A1, A2) const volatile) { 03105 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method)); 03106 } 03107 03108 template <typename R, typename A0, typename A1, typename A2> 03109 Event<void(A0, A1, A2)> EventQueue::event(mbed::Callback<R(A0, A1, A2)> cb) { 03110 return Event<void(A0, A1, A2)>(this, cb); 03111 } 03112 03113 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2> 03114 Event<void(A0, A1, A2)> EventQueue::event(R (*func)(B0, A0, A1, A2), C0 c0) { 03115 return Event<void(A0, A1, A2)>(this, func, c0); 03116 } 03117 03118 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2> 03119 Event<void(A0, A1, A2)> EventQueue::event(T *obj, R (T::*method)(B0, A0, A1, A2), C0 c0) { 03120 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0); 03121 } 03122 03123 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2> 03124 Event<void(A0, A1, A2)> EventQueue::event(const T *obj, R (T::*method)(B0, A0, A1, A2) const, C0 c0) { 03125 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0); 03126 } 03127 03128 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2> 03129 Event<void(A0, A1, A2)> EventQueue::event(volatile T *obj, R (T::*method)(B0, A0, A1, A2) volatile, C0 c0) { 03130 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0); 03131 } 03132 03133 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2> 03134 Event<void(A0, A1, A2)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, A0, A1, A2) const volatile, C0 c0) { 03135 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0); 03136 } 03137 03138 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2> 03139 Event<void(A0, A1, A2)> EventQueue::event(mbed::Callback<R(B0, A0, A1, A2)> cb, C0 c0) { 03140 return Event<void(A0, A1, A2)>(this, cb, c0); 03141 } 03142 03143 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2> 03144 Event<void(A0, A1, A2)> EventQueue::event(R (*func)(B0, B1, A0, A1, A2), C0 c0, C1 c1) { 03145 return Event<void(A0, A1, A2)>(this, func, c0, c1); 03146 } 03147 03148 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2> 03149 Event<void(A0, A1, A2)> EventQueue::event(T *obj, R (T::*method)(B0, B1, A0, A1, A2), C0 c0, C1 c1) { 03150 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1); 03151 } 03152 03153 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2> 03154 Event<void(A0, A1, A2)> EventQueue::event(const T *obj, R (T::*method)(B0, B1, A0, A1, A2) const, C0 c0, C1 c1) { 03155 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1); 03156 } 03157 03158 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2> 03159 Event<void(A0, A1, A2)> EventQueue::event(volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2) volatile, C0 c0, C1 c1) { 03160 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1); 03161 } 03162 03163 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2> 03164 Event<void(A0, A1, A2)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2) const volatile, C0 c0, C1 c1) { 03165 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1); 03166 } 03167 03168 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2> 03169 Event<void(A0, A1, A2)> EventQueue::event(mbed::Callback<R(B0, B1, A0, A1, A2)> cb, C0 c0, C1 c1) { 03170 return Event<void(A0, A1, A2)>(this, cb, c0, c1); 03171 } 03172 03173 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2> 03174 Event<void(A0, A1, A2)> EventQueue::event(R (*func)(B0, B1, B2, A0, A1, A2), C0 c0, C1 c1, C2 c2) { 03175 return Event<void(A0, A1, A2)>(this, func, c0, c1, c2); 03176 } 03177 03178 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2> 03179 Event<void(A0, A1, A2)> EventQueue::event(T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2), C0 c0, C1 c1, C2 c2) { 03180 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2); 03181 } 03182 03183 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2> 03184 Event<void(A0, A1, A2)> EventQueue::event(const T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2) const, C0 c0, C1 c1, C2 c2) { 03185 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2); 03186 } 03187 03188 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2> 03189 Event<void(A0, A1, A2)> EventQueue::event(volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2) volatile, C0 c0, C1 c1, C2 c2) { 03190 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2); 03191 } 03192 03193 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2> 03194 Event<void(A0, A1, A2)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2) const volatile, C0 c0, C1 c1, C2 c2) { 03195 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2); 03196 } 03197 03198 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2> 03199 Event<void(A0, A1, A2)> EventQueue::event(mbed::Callback<R(B0, B1, B2, A0, A1, A2)> cb, C0 c0, C1 c1, C2 c2) { 03200 return Event<void(A0, A1, A2)>(this, cb, c0, c1, c2); 03201 } 03202 03203 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> 03204 Event<void(A0, A1, A2)> EventQueue::event(R (*func)(B0, B1, B2, B3, A0, A1, A2), C0 c0, C1 c1, C2 c2, C3 c3) { 03205 return Event<void(A0, A1, A2)>(this, func, c0, c1, c2, c3); 03206 } 03207 03208 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> 03209 Event<void(A0, A1, A2)> EventQueue::event(T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2), C0 c0, C1 c1, C2 c2, C3 c3) { 03210 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2, c3); 03211 } 03212 03213 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> 03214 Event<void(A0, A1, A2)> EventQueue::event(const T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2) const, C0 c0, C1 c1, C2 c2, C3 c3) { 03215 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2, c3); 03216 } 03217 03218 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> 03219 Event<void(A0, A1, A2)> EventQueue::event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2) volatile, C0 c0, C1 c1, C2 c2, C3 c3) { 03220 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2, c3); 03221 } 03222 03223 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> 03224 Event<void(A0, A1, A2)> EventQueue::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) { 03225 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2, c3); 03226 } 03227 03228 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> 03229 Event<void(A0, A1, A2)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, A0, A1, A2)> cb, C0 c0, C1 c1, C2 c2, C3 c3) { 03230 return Event<void(A0, A1, A2)>(this, cb, c0, c1, c2, c3); 03231 } 03232 03233 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> 03234 Event<void(A0, A1, A2)> EventQueue::event(R (*func)(B0, B1, B2, B3, B4, A0, A1, A2), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) { 03235 return Event<void(A0, A1, A2)>(this, func, c0, c1, c2, c3, c4); 03236 } 03237 03238 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> 03239 Event<void(A0, A1, A2)> EventQueue::event(T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) { 03240 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4); 03241 } 03242 03243 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> 03244 Event<void(A0, A1, A2)> EventQueue::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) { 03245 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4); 03246 } 03247 03248 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> 03249 Event<void(A0, A1, A2)> EventQueue::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) { 03250 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4); 03251 } 03252 03253 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> 03254 Event<void(A0, A1, A2)> EventQueue::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) { 03255 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4); 03256 } 03257 03258 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> 03259 Event<void(A0, A1, A2)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, B4, A0, A1, A2)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) { 03260 return Event<void(A0, A1, A2)>(this, cb, c0, c1, c2, c3, c4); 03261 } 03262 03263 template <typename R, typename A0, typename A1, typename A2, typename A3> 03264 Event<void(A0, A1, A2, A3)> EventQueue::event(R (*func)(A0, A1, A2, A3)) { 03265 return Event<void(A0, A1, A2, A3)>(this, func); 03266 } 03267 03268 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 03269 Event<void(A0, A1, A2, A3)> EventQueue::event(T *obj, R (T::*method)(A0, A1, A2, A3)) { 03270 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method)); 03271 } 03272 03273 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 03274 Event<void(A0, A1, A2, A3)> EventQueue::event(const T *obj, R (T::*method)(A0, A1, A2, A3) const) { 03275 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method)); 03276 } 03277 03278 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 03279 Event<void(A0, A1, A2, A3)> EventQueue::event(volatile T *obj, R (T::*method)(A0, A1, A2, A3) volatile) { 03280 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method)); 03281 } 03282 03283 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3> 03284 Event<void(A0, A1, A2, A3)> EventQueue::event(const volatile T *obj, R (T::*method)(A0, A1, A2, A3) const volatile) { 03285 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method)); 03286 } 03287 03288 template <typename R, typename A0, typename A1, typename A2, typename A3> 03289 Event<void(A0, A1, A2, A3)> EventQueue::event(mbed::Callback<R(A0, A1, A2, A3)> cb) { 03290 return Event<void(A0, A1, A2, A3)>(this, cb); 03291 } 03292 03293 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3> 03294 Event<void(A0, A1, A2, A3)> EventQueue::event(R (*func)(B0, A0, A1, A2, A3), C0 c0) { 03295 return Event<void(A0, A1, A2, A3)>(this, func, c0); 03296 } 03297 03298 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3> 03299 Event<void(A0, A1, A2, A3)> EventQueue::event(T *obj, R (T::*method)(B0, A0, A1, A2, A3), C0 c0) { 03300 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0); 03301 } 03302 03303 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3> 03304 Event<void(A0, A1, A2, A3)> EventQueue::event(const T *obj, R (T::*method)(B0, A0, A1, A2, A3) const, C0 c0) { 03305 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0); 03306 } 03307 03308 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3> 03309 Event<void(A0, A1, A2, A3)> EventQueue::event(volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3) volatile, C0 c0) { 03310 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0); 03311 } 03312 03313 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3> 03314 Event<void(A0, A1, A2, A3)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3) const volatile, C0 c0) { 03315 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0); 03316 } 03317 03318 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3> 03319 Event<void(A0, A1, A2, A3)> EventQueue::event(mbed::Callback<R(B0, A0, A1, A2, A3)> cb, C0 c0) { 03320 return Event<void(A0, A1, A2, A3)>(this, cb, c0); 03321 } 03322 03323 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3> 03324 Event<void(A0, A1, A2, A3)> EventQueue::event(R (*func)(B0, B1, A0, A1, A2, A3), C0 c0, C1 c1) { 03325 return Event<void(A0, A1, A2, A3)>(this, func, c0, c1); 03326 } 03327 03328 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3> 03329 Event<void(A0, A1, A2, A3)> EventQueue::event(T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3), C0 c0, C1 c1) { 03330 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1); 03331 } 03332 03333 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3> 03334 Event<void(A0, A1, A2, A3)> EventQueue::event(const T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3) const, C0 c0, C1 c1) { 03335 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1); 03336 } 03337 03338 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3> 03339 Event<void(A0, A1, A2, A3)> EventQueue::event(volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3) volatile, C0 c0, C1 c1) { 03340 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1); 03341 } 03342 03343 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3> 03344 Event<void(A0, A1, A2, A3)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3) const volatile, C0 c0, C1 c1) { 03345 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1); 03346 } 03347 03348 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3> 03349 Event<void(A0, A1, A2, A3)> EventQueue::event(mbed::Callback<R(B0, B1, A0, A1, A2, A3)> cb, C0 c0, C1 c1) { 03350 return Event<void(A0, A1, A2, A3)>(this, cb, c0, c1); 03351 } 03352 03353 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3> 03354 Event<void(A0, A1, A2, A3)> EventQueue::event(R (*func)(B0, B1, B2, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2) { 03355 return Event<void(A0, A1, A2, A3)>(this, func, c0, c1, c2); 03356 } 03357 03358 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> 03359 Event<void(A0, A1, A2, A3)> EventQueue::event(T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2) { 03360 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2); 03361 } 03362 03363 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> 03364 Event<void(A0, A1, A2, A3)> EventQueue::event(const T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3) const, C0 c0, C1 c1, C2 c2) { 03365 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2); 03366 } 03367 03368 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> 03369 Event<void(A0, A1, A2, A3)> EventQueue::event(volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3) volatile, C0 c0, C1 c1, C2 c2) { 03370 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2); 03371 } 03372 03373 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> 03374 Event<void(A0, A1, A2, A3)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3) const volatile, C0 c0, C1 c1, C2 c2) { 03375 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2); 03376 } 03377 03378 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3> 03379 Event<void(A0, A1, A2, A3)> EventQueue::event(mbed::Callback<R(B0, B1, B2, A0, A1, A2, A3)> cb, C0 c0, C1 c1, C2 c2) { 03380 return Event<void(A0, A1, A2, A3)>(this, cb, c0, c1, c2); 03381 } 03382 03383 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> 03384 Event<void(A0, A1, A2, A3)> EventQueue::event(R (*func)(B0, B1, B2, B3, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2, C3 c3) { 03385 return Event<void(A0, A1, A2, A3)>(this, func, c0, c1, c2, c3); 03386 } 03387 03388 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> 03389 Event<void(A0, A1, A2, A3)> EventQueue::event(T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2, C3 c3) { 03390 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2, c3); 03391 } 03392 03393 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> 03394 Event<void(A0, A1, A2, A3)> EventQueue::event(const T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3) const, C0 c0, C1 c1, C2 c2, C3 c3) { 03395 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2, c3); 03396 } 03397 03398 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> 03399 Event<void(A0, A1, A2, A3)> EventQueue::event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3) volatile, C0 c0, C1 c1, C2 c2, C3 c3) { 03400 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2, c3); 03401 } 03402 03403 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> 03404 Event<void(A0, A1, A2, A3)> EventQueue::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) { 03405 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2, c3); 03406 } 03407 03408 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> 03409 Event<void(A0, A1, A2, A3)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, A0, A1, A2, A3)> cb, C0 c0, C1 c1, C2 c2, C3 c3) { 03410 return Event<void(A0, A1, A2, A3)>(this, cb, c0, c1, c2, c3); 03411 } 03412 03413 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> 03414 Event<void(A0, A1, A2, A3)> EventQueue::event(R (*func)(B0, B1, B2, B3, B4, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) { 03415 return Event<void(A0, A1, A2, A3)>(this, func, c0, c1, c2, c3, c4); 03416 } 03417 03418 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> 03419 Event<void(A0, A1, A2, A3)> EventQueue::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) { 03420 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4); 03421 } 03422 03423 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> 03424 Event<void(A0, A1, A2, A3)> EventQueue::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) { 03425 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4); 03426 } 03427 03428 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> 03429 Event<void(A0, A1, A2, A3)> EventQueue::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) { 03430 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4); 03431 } 03432 03433 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> 03434 Event<void(A0, A1, A2, A3)> EventQueue::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) { 03435 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4); 03436 } 03437 03438 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> 03439 Event<void(A0, A1, A2, A3)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, B4, A0, A1, A2, A3)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) { 03440 return Event<void(A0, A1, A2, A3)>(this, cb, c0, c1, c2, c3, c4); 03441 } 03442 03443 template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 03444 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(R (*func)(A0, A1, A2, A3, A4)) { 03445 return Event<void(A0, A1, A2, A3, A4)>(this, func); 03446 } 03447 03448 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 03449 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(T *obj, R (T::*method)(A0, A1, A2, A3, A4)) { 03450 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method)); 03451 } 03452 03453 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 03454 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(const T *obj, R (T::*method)(A0, A1, A2, A3, A4) const) { 03455 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method)); 03456 } 03457 03458 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 03459 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) volatile) { 03460 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method)); 03461 } 03462 03463 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 03464 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(const volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) const volatile) { 03465 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method)); 03466 } 03467 03468 template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4> 03469 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(mbed::Callback<R(A0, A1, A2, A3, A4)> cb) { 03470 return Event<void(A0, A1, A2, A3, A4)>(this, cb); 03471 } 03472 03473 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4> 03474 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(R (*func)(B0, A0, A1, A2, A3, A4), C0 c0) { 03475 return Event<void(A0, A1, A2, A3, A4)>(this, func, c0); 03476 } 03477 03478 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4> 03479 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4), C0 c0) { 03480 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0); 03481 } 03482 03483 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4> 03484 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(const T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4) const, C0 c0) { 03485 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0); 03486 } 03487 03488 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4> 03489 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4) volatile, C0 c0) { 03490 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0); 03491 } 03492 03493 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4> 03494 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4) const volatile, C0 c0) { 03495 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0); 03496 } 03497 03498 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4> 03499 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(mbed::Callback<R(B0, A0, A1, A2, A3, A4)> cb, C0 c0) { 03500 return Event<void(A0, A1, A2, A3, A4)>(this, cb, c0); 03501 } 03502 03503 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4> 03504 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(R (*func)(B0, B1, A0, A1, A2, A3, A4), C0 c0, C1 c1) { 03505 return Event<void(A0, A1, A2, A3, A4)>(this, func, c0, c1); 03506 } 03507 03508 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4> 03509 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3, A4), C0 c0, C1 c1) { 03510 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1); 03511 } 03512 03513 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4> 03514 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(const T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3, A4) const, C0 c0, C1 c1) { 03515 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1); 03516 } 03517 03518 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4> 03519 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3, A4) volatile, C0 c0, C1 c1) { 03520 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1); 03521 } 03522 03523 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4> 03524 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3, A4) const volatile, C0 c0, C1 c1) { 03525 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1); 03526 } 03527 03528 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4> 03529 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(mbed::Callback<R(B0, B1, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1) { 03530 return Event<void(A0, A1, A2, A3, A4)>(this, cb, c0, c1); 03531 } 03532 03533 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> 03534 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(R (*func)(B0, B1, B2, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2) { 03535 return Event<void(A0, A1, A2, A3, A4)>(this, func, c0, c1, c2); 03536 } 03537 03538 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> 03539 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2) { 03540 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2); 03541 } 03542 03543 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> 03544 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(const T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3, A4) const, C0 c0, C1 c1, C2 c2) { 03545 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2); 03546 } 03547 03548 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> 03549 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3, A4) volatile, C0 c0, C1 c1, C2 c2) { 03550 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2); 03551 } 03552 03553 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> 03554 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3, A4) const volatile, C0 c0, C1 c1, C2 c2) { 03555 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2); 03556 } 03557 03558 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> 03559 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(mbed::Callback<R(B0, B1, B2, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1, C2 c2) { 03560 return Event<void(A0, A1, A2, A3, A4)>(this, cb, c0, c1, c2); 03561 } 03562 03563 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> 03564 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(R (*func)(B0, B1, B2, B3, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2, C3 c3) { 03565 return Event<void(A0, A1, A2, A3, A4)>(this, func, c0, c1, c2, c3); 03566 } 03567 03568 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> 03569 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2, C3 c3) { 03570 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2, c3); 03571 } 03572 03573 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> 03574 Event<void(A0, A1, A2, A3, A4)> EventQueue::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) { 03575 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2, c3); 03576 } 03577 03578 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> 03579 Event<void(A0, A1, A2, A3, A4)> EventQueue::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) { 03580 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2, c3); 03581 } 03582 03583 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> 03584 Event<void(A0, A1, A2, A3, A4)> EventQueue::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) { 03585 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2, c3); 03586 } 03587 03588 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> 03589 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1, C2 c2, C3 c3) { 03590 return Event<void(A0, A1, A2, A3, A4)>(this, cb, c0, c1, c2, c3); 03591 } 03592 03593 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> 03594 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(R (*func)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) { 03595 return Event<void(A0, A1, A2, A3, A4)>(this, func, c0, c1, c2, c3, c4); 03596 } 03597 03598 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> 03599 Event<void(A0, A1, A2, A3, A4)> EventQueue::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) { 03600 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4); 03601 } 03602 03603 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> 03604 Event<void(A0, A1, A2, A3, A4)> EventQueue::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) { 03605 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4); 03606 } 03607 03608 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> 03609 Event<void(A0, A1, A2, A3, A4)> EventQueue::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) { 03610 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4); 03611 } 03612 03613 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> 03614 Event<void(A0, A1, A2, A3, A4)> EventQueue::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) { 03615 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4); 03616 } 03617 03618 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> 03619 Event<void(A0, A1, A2, A3, A4)> EventQueue::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) { 03620 return Event<void(A0, A1, A2, A3, A4)>(this, cb, c0, c1, c2, c3, c4); 03621 } 03622 03623 } 03624 03625 #endif 03626 03627 /** @}*/
Generated on Sun Jul 17 2022 08:25:22 by
1.7.2