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