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