├── .mbedignore ├── .travis.yml ├── Event.h ├── EventQueue.cpp ├── EventQueue.h ├── LICENSE ├── README.md ├── TESTS └── events │ └── queue │ └── main.cpp ├── equeue ├── .travis.yml ├── LICENSE.md ├── Makefile ├── README.md ├── equeue.c ├── equeue.h ├── equeue_freertos.c ├── equeue_mbed.cpp ├── equeue_platform.h ├── equeue_posix.c ├── equeue_windows.c └── tests │ ├── prof.c │ └── tests.c └── mbed_events.h /.mbedignore: -------------------------------------------------------------------------------- 1 | equeue/tests/ 2 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | script: 2 | - cd equeue 3 | 4 | # Strict compilation of library 5 | - CFLAGS='-pedantic -Werror' make 6 | 7 | # Runtime tests 8 | - make test 9 | 10 | # Relative profiling with current master 11 | - if ( git clone https://github.com/armmbed/mbed-events tests/master && 12 | make -s -C tests/master/$(basename $(pwd)) prof | tee tests/results.txt ) ; 13 | then 14 | cat tests/results.txt | make prof ; 15 | else 16 | make prof ; 17 | fi 18 | -------------------------------------------------------------------------------- /EventQueue.cpp: -------------------------------------------------------------------------------- 1 | #include "EventQueue.h" 2 | 3 | #include "mbed_events.h" 4 | #include "mbed.h" 5 | 6 | 7 | EventQueue::EventQueue(unsigned event_size, unsigned char *event_pointer) { 8 | if (!event_pointer) { 9 | equeue_create(&_equeue, event_size); 10 | } else { 11 | equeue_create_inplace(&_equeue, event_size, event_pointer); 12 | } 13 | } 14 | 15 | EventQueue::~EventQueue() { 16 | equeue_destroy(&_equeue); 17 | } 18 | 19 | void EventQueue::dispatch(int ms) { 20 | return equeue_dispatch(&_equeue, ms); 21 | } 22 | 23 | void EventQueue::break_dispatch() { 24 | return equeue_break(&_equeue); 25 | } 26 | 27 | unsigned EventQueue::tick() { 28 | return equeue_tick(); 29 | } 30 | 31 | void EventQueue::cancel(int id) { 32 | return equeue_cancel(&_equeue, id); 33 | } 34 | 35 | void EventQueue::background(Callback update) { 36 | _update = update; 37 | 38 | if (_update) { 39 | equeue_background(&_equeue, &Callback::thunk, &_update); 40 | } else { 41 | equeue_background(&_equeue, 0, 0); 42 | } 43 | } 44 | 45 | void EventQueue::chain(EventQueue *target) { 46 | if (target) { 47 | equeue_chain(&_equeue, &target->_equeue); 48 | } else { 49 | equeue_chain(&_equeue, 0); 50 | } 51 | } 52 | -------------------------------------------------------------------------------- /EventQueue.h: -------------------------------------------------------------------------------- 1 | /* events 2 | * Copyright (c) 2006-2013 ARM Limited 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | 17 | #ifndef EVENT_QUEUE_H 18 | #define EVENT_QUEUE_H 19 | 20 | #include "equeue/equeue.h" 21 | #include "Callback.h" 22 | #include 23 | #include 24 | 25 | namespace events { 26 | 27 | /** EVENTS_EVENT_SIZE 28 | * Minimum size of an event 29 | * This size fits a Callback at minimum 30 | */ 31 | #define EVENTS_EVENT_SIZE \ 32 | (EQUEUE_EVENT_SIZE - 2*sizeof(void*) + sizeof(mbed::Callback)) 33 | 34 | /** EVENTS_QUEUE_SIZE 35 | * Default size of buffer for events 36 | */ 37 | #define EVENTS_QUEUE_SIZE (32*EVENTS_EVENT_SIZE) 38 | 39 | // Predeclared classes 40 | template 41 | class Event; 42 | 43 | 44 | /** EventQueue 45 | * 46 | * Flexible event queue for dispatching events 47 | */ 48 | class EventQueue { 49 | public: 50 | /** Create an EventQueue 51 | * 52 | * Create an event queue. The event queue either allocates a buffer of 53 | * the specified size with malloc or uses the user provided buffer. 54 | * 55 | * @param size Size of buffer to use for events in bytes 56 | * (default to EVENTS_QUEUE_SIZE) 57 | * @param buffer Pointer to buffer to use for events 58 | * (default to NULL) 59 | */ 60 | EventQueue(unsigned size=EVENTS_QUEUE_SIZE, unsigned char *buffer=NULL); 61 | 62 | /** Destroy an EventQueue 63 | */ 64 | ~EventQueue(); 65 | 66 | /** Dispatch events 67 | * 68 | * Executes events until the specified milliseconds have passed. 69 | * If ms is negative, the dispatch function will dispatch events 70 | * indefinitely or until break_dispatch is called on this queue. 71 | * 72 | * When called with a finite timeout, the dispatch function is guaranteed 73 | * to terminate. When called with a timeout of 0, the dispatch function 74 | * does not wait and is irq safe. 75 | * 76 | * @param ms Time to wait for events in milliseconds, a negative 77 | * value will dispatch events indefinitely 78 | * (default to -1) 79 | */ 80 | void dispatch(int ms=-1); 81 | 82 | /** Dispatch events without a timeout 83 | * 84 | * This is equivalent to EventQueue::dispatch with no arguments, but 85 | * avoids overload ambiguities when passed as a callback. 86 | * 87 | * @see EventQueue::dispatch 88 | */ 89 | void dispatch_forever() { dispatch(); } 90 | 91 | /** Break out of a running event loop 92 | * 93 | * Forces the specified event queue's dispatch loop to terminate. Pending 94 | * events may finish executing, but no new events will be executed. 95 | */ 96 | void break_dispatch(); 97 | 98 | /** Millisecond counter 99 | * 100 | * Returns the underlying tick of the event queue represented as the 101 | * number of milliseconds that have passed since an arbitrary point in 102 | * time. Intentionally overflows to 0 after 2^32-1. 103 | * 104 | * @return The underlying tick of the event queue in milliseconds 105 | */ 106 | unsigned tick(); 107 | 108 | /** Cancel an in-flight event 109 | * 110 | * Attempts to cancel an event referenced by the unique id returned from 111 | * one of the call functions. It is safe to call cancel after an event 112 | * has already been dispatched. 113 | * 114 | * The cancel function is irq safe. 115 | * 116 | * If called while the event queue's dispatch loop is active, the cancel 117 | * function does not garuntee that the event will not execute after it 118 | * returns, as the event may have already begun executing. 119 | * 120 | * @param id Unique id of the event 121 | */ 122 | void cancel(int id); 123 | 124 | /** Background an event queue onto a single-shot timer-interrupt 125 | * 126 | * When updated, the event queue will call the provided update function 127 | * with a timeout indicating when the queue should be dispatched. A 128 | * negative timeout will be passed to the update function when the 129 | * timer-interrupt is no longer needed. 130 | * 131 | * Passing a null function disables the existing update function. 132 | * 133 | * The background function allows an event queue to take advantage of 134 | * hardware timers or other event loops, allowing an event queue to be 135 | * ran in the background without consuming the foreground thread. 136 | * 137 | * @param update Function called to indicate when the queue should be 138 | * dispatched 139 | */ 140 | void background(mbed::Callback update); 141 | 142 | /** Chain an event queue onto another event queue 143 | * 144 | * After chaining a queue to a target, calling dispatch on the target 145 | * queue will also dispatch events from this queue. The queues use 146 | * their own buffers and events must be handled independently. 147 | * 148 | * A null queue as the target will unchain the existing queue. 149 | * 150 | * The chain function allows multiple event queues to be composed, 151 | * sharing the context of a dispatch loop while still being managed 152 | * independently 153 | * 154 | * @param target Queue that will dispatch this queue's events as a 155 | * part of its dispatch loop 156 | */ 157 | void chain(EventQueue *target); 158 | 159 | /** Calls an event on the queue 160 | * 161 | * The specified callback will be executed in the context of the event 162 | * queue's dispatch loop. 163 | * 164 | * The call function is irq safe and can act as a mechanism for moving 165 | * events out of irq contexts. 166 | * 167 | * @param f Function to execute in the context of the dispatch loop 168 | * @param a0..a4 Arguments to pass to the callback 169 | * @return A unique id that represents the posted event and can 170 | * be passed to cancel, or an id of 0 if there is not 171 | * enough memory to allocate the event. 172 | */ 173 | template 174 | int call(F f) { 175 | struct local { 176 | static void call(void *p) { (*static_cast(p))(); } 177 | static void dtor(void *p) { static_cast(p)->~F(); } 178 | }; 179 | 180 | void *p = equeue_alloc(&_equeue, sizeof(F)); 181 | if (!p) { 182 | return 0; 183 | } 184 | 185 | F *e = new (p) F(f); 186 | equeue_event_dtor(e, &local::dtor); 187 | return equeue_post(&_equeue, &local::call, e); 188 | } 189 | 190 | /** Calls an event on the queue 191 | * @see EventQueue::call 192 | */ 193 | template 194 | int call(F f, A0 a0) { 195 | return call(context10(f, a0)); 196 | } 197 | 198 | /** Calls an event on the queue 199 | * @see EventQueue::call 200 | */ 201 | template 202 | int call(F f, A0 a0, A1 a1) { 203 | return call(context20(f, a0, a1)); 204 | } 205 | 206 | /** Calls an event on the queue 207 | * @see EventQueue::call 208 | */ 209 | template 210 | int call(F f, A0 a0, A1 a1, A2 a2) { 211 | return call(context30(f, a0, a1, a2)); 212 | } 213 | 214 | /** Calls an event on the queue 215 | * @see EventQueue::call 216 | */ 217 | template 218 | int call(F f, A0 a0, A1 a1, A2 a2, A3 a3) { 219 | return call(context40(f, a0, a1, a2, a3)); 220 | } 221 | 222 | /** Calls an event on the queue 223 | * @see EventQueue::call 224 | */ 225 | template 226 | int call(F f, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 227 | return call(context50(f, a0, a1, a2, a3, a4)); 228 | } 229 | 230 | /** Calls an event on the queue 231 | * @see EventQueue::call 232 | */ 233 | template 234 | int call(T *obj, R (T::*method)()) { 235 | return call(mbed::Callback(obj, method)); 236 | } 237 | 238 | /** Calls an event on the queue 239 | * @see EventQueue::call 240 | */ 241 | template 242 | int call(const T *obj, R (T::*method)() const) { 243 | return call(mbed::Callback(obj, method)); 244 | } 245 | 246 | /** Calls an event on the queue 247 | * @see EventQueue::call 248 | */ 249 | template 250 | int call(volatile T *obj, R (T::*method)() volatile) { 251 | return call(mbed::Callback(obj, method)); 252 | } 253 | 254 | /** Calls an event on the queue 255 | * @see EventQueue::call 256 | */ 257 | template 258 | int call(const volatile T *obj, R (T::*method)() const volatile) { 259 | return call(mbed::Callback(obj, method)); 260 | } 261 | 262 | /** Calls an event on the queue 263 | * @see EventQueue::call 264 | */ 265 | template 266 | int call(T *obj, R (T::*method)(A0), A0 a0) { 267 | return call(mbed::Callback(obj, method), a0); 268 | } 269 | 270 | /** Calls an event on the queue 271 | * @see EventQueue::call 272 | */ 273 | template 274 | int call(const T *obj, R (T::*method)(A0) const, A0 a0) { 275 | return call(mbed::Callback(obj, method), a0); 276 | } 277 | 278 | /** Calls an event on the queue 279 | * @see EventQueue::call 280 | */ 281 | template 282 | int call(volatile T *obj, R (T::*method)(A0) volatile, A0 a0) { 283 | return call(mbed::Callback(obj, method), a0); 284 | } 285 | 286 | /** Calls an event on the queue 287 | * @see EventQueue::call 288 | */ 289 | template 290 | int call(const volatile T *obj, R (T::*method)(A0) const volatile, A0 a0) { 291 | return call(mbed::Callback(obj, method), a0); 292 | } 293 | 294 | /** Calls an event on the queue 295 | * @see EventQueue::call 296 | */ 297 | template 298 | int call(T *obj, R (T::*method)(A0, A1), A0 a0, A1 a1) { 299 | return call(mbed::Callback(obj, method), a0, a1); 300 | } 301 | 302 | /** Calls an event on the queue 303 | * @see EventQueue::call 304 | */ 305 | template 306 | int call(const T *obj, R (T::*method)(A0, A1) const, A0 a0, A1 a1) { 307 | return call(mbed::Callback(obj, method), a0, a1); 308 | } 309 | 310 | /** Calls an event on the queue 311 | * @see EventQueue::call 312 | */ 313 | template 314 | int call(volatile T *obj, R (T::*method)(A0, A1) volatile, A0 a0, A1 a1) { 315 | return call(mbed::Callback(obj, method), a0, a1); 316 | } 317 | 318 | /** Calls an event on the queue 319 | * @see EventQueue::call 320 | */ 321 | template 322 | int call(const volatile T *obj, R (T::*method)(A0, A1) const volatile, A0 a0, A1 a1) { 323 | return call(mbed::Callback(obj, method), a0, a1); 324 | } 325 | 326 | /** Calls an event on the queue 327 | * @see EventQueue::call 328 | */ 329 | template 330 | int call(T *obj, R (T::*method)(A0, A1, A2), A0 a0, A1 a1, A2 a2) { 331 | return call(mbed::Callback(obj, method), a0, a1, a2); 332 | } 333 | 334 | /** Calls an event on the queue 335 | * @see EventQueue::call 336 | */ 337 | template 338 | int call(const T *obj, R (T::*method)(A0, A1, A2) const, A0 a0, A1 a1, A2 a2) { 339 | return call(mbed::Callback(obj, method), a0, a1, a2); 340 | } 341 | 342 | /** Calls an event on the queue 343 | * @see EventQueue::call 344 | */ 345 | template 346 | int call(volatile T *obj, R (T::*method)(A0, A1, A2) volatile, A0 a0, A1 a1, A2 a2) { 347 | return call(mbed::Callback(obj, method), a0, a1, a2); 348 | } 349 | 350 | /** Calls an event on the queue 351 | * @see EventQueue::call 352 | */ 353 | template 354 | int call(const volatile T *obj, R (T::*method)(A0, A1, A2) const volatile, A0 a0, A1 a1, A2 a2) { 355 | return call(mbed::Callback(obj, method), a0, a1, a2); 356 | } 357 | 358 | /** Calls an event on the queue 359 | * @see EventQueue::call 360 | */ 361 | template 362 | int call(T *obj, R (T::*method)(A0, A1, A2, A3), A0 a0, A1 a1, A2 a2, A3 a3) { 363 | return call(mbed::Callback(obj, method), a0, a1, a2, a3); 364 | } 365 | 366 | /** Calls an event on the queue 367 | * @see EventQueue::call 368 | */ 369 | template 370 | int call(const T *obj, R (T::*method)(A0, A1, A2, A3) const, A0 a0, A1 a1, A2 a2, A3 a3) { 371 | return call(mbed::Callback(obj, method), a0, a1, a2, a3); 372 | } 373 | 374 | /** Calls an event on the queue 375 | * @see EventQueue::call 376 | */ 377 | template 378 | int call(volatile T *obj, R (T::*method)(A0, A1, A2, A3) volatile, A0 a0, A1 a1, A2 a2, A3 a3) { 379 | return call(mbed::Callback(obj, method), a0, a1, a2, a3); 380 | } 381 | 382 | /** Calls an event on the queue 383 | * @see EventQueue::call 384 | */ 385 | template 386 | int call(const volatile T *obj, R (T::*method)(A0, A1, A2, A3) const volatile, A0 a0, A1 a1, A2 a2, A3 a3) { 387 | return call(mbed::Callback(obj, method), a0, a1, a2, a3); 388 | } 389 | 390 | /** Calls an event on the queue 391 | * @see EventQueue::call 392 | */ 393 | template 394 | int call(T *obj, R (T::*method)(A0, A1, A2, A3, A4), A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 395 | return call(mbed::Callback(obj, method), a0, a1, a2, a3, a4); 396 | } 397 | 398 | /** Calls an event on the queue 399 | * @see EventQueue::call 400 | */ 401 | template 402 | int call(const T *obj, R (T::*method)(A0, A1, A2, A3, A4) const, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 403 | return call(mbed::Callback(obj, method), a0, a1, a2, a3, a4); 404 | } 405 | 406 | /** Calls an event on the queue 407 | * @see EventQueue::call 408 | */ 409 | template 410 | int call(volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) volatile, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 411 | return call(mbed::Callback(obj, method), a0, a1, a2, a3, a4); 412 | } 413 | 414 | /** Calls an event on the queue 415 | * @see EventQueue::call 416 | */ 417 | template 418 | int call(const volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) const volatile, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 419 | return call(mbed::Callback(obj, method), a0, a1, a2, a3, a4); 420 | } 421 | 422 | /** Calls an event on the queue after a specified delay 423 | * 424 | * The specified callback will be executed in the context of the event 425 | * queue's dispatch loop. 426 | * 427 | * The call_in function is irq safe and can act as a mechanism for moving 428 | * events out of irq contexts. 429 | * 430 | * @param f Function to execute in the context of the dispatch loop 431 | * @param a0..a4 Arguments to pass to the callback 432 | * @param ms Time to delay in milliseconds 433 | * @return A unique id that represents the posted event and can 434 | * be passed to cancel, or an id of 0 if there is not 435 | * enough memory to allocate the event. 436 | */ 437 | template 438 | int call_in(int ms, F f) { 439 | struct local { 440 | static void call(void *p) { (*static_cast(p))(); } 441 | static void dtor(void *p) { static_cast(p)->~F(); } 442 | }; 443 | 444 | void *p = equeue_alloc(&_equeue, sizeof(F)); 445 | if (!p) { 446 | return 0; 447 | } 448 | 449 | F *e = new (p) F(f); 450 | equeue_event_delay(e, ms); 451 | equeue_event_dtor(e, &local::dtor); 452 | return equeue_post(&_equeue, &local::call, e); 453 | } 454 | 455 | /** Calls an event on the queue after a specified delay 456 | * @see EventQueue::call_in 457 | */ 458 | template 459 | int call_in(int ms, F f, A0 a0) { 460 | return call_in(ms, context10(f, a0)); 461 | } 462 | 463 | /** Calls an event on the queue after a specified delay 464 | * @see EventQueue::call_in 465 | */ 466 | template 467 | int call_in(int ms, F f, A0 a0, A1 a1) { 468 | return call_in(ms, context20(f, a0, a1)); 469 | } 470 | 471 | /** Calls an event on the queue after a specified delay 472 | * @see EventQueue::call_in 473 | */ 474 | template 475 | int call_in(int ms, F f, A0 a0, A1 a1, A2 a2) { 476 | return call_in(ms, context30(f, a0, a1, a2)); 477 | } 478 | 479 | /** Calls an event on the queue after a specified delay 480 | * @see EventQueue::call_in 481 | */ 482 | template 483 | int call_in(int ms, F f, A0 a0, A1 a1, A2 a2, A3 a3) { 484 | return call_in(ms, context40(f, a0, a1, a2, a3)); 485 | } 486 | 487 | /** Calls an event on the queue after a specified delay 488 | * @see EventQueue::call_in 489 | */ 490 | template 491 | int call_in(int ms, F f, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 492 | return call_in(ms, context50(f, a0, a1, a2, a3, a4)); 493 | } 494 | 495 | /** Calls an event on the queue after a specified delay 496 | * @see EventQueue::call_in 497 | */ 498 | template 499 | int call_in(int ms, T *obj, R (T::*method)()) { 500 | return call_in(ms, mbed::Callback(obj, method)); 501 | } 502 | 503 | /** Calls an event on the queue after a specified delay 504 | * @see EventQueue::call_in 505 | */ 506 | template 507 | int call_in(int ms, const T *obj, R (T::*method)() const) { 508 | return call_in(ms, mbed::Callback(obj, method)); 509 | } 510 | 511 | /** Calls an event on the queue after a specified delay 512 | * @see EventQueue::call_in 513 | */ 514 | template 515 | int call_in(int ms, volatile T *obj, R (T::*method)() volatile) { 516 | return call_in(ms, mbed::Callback(obj, method)); 517 | } 518 | 519 | /** Calls an event on the queue after a specified delay 520 | * @see EventQueue::call_in 521 | */ 522 | template 523 | int call_in(int ms, const volatile T *obj, R (T::*method)() const volatile) { 524 | return call_in(ms, mbed::Callback(obj, method)); 525 | } 526 | 527 | /** Calls an event on the queue after a specified delay 528 | * @see EventQueue::call_in 529 | */ 530 | template 531 | int call_in(int ms, T *obj, R (T::*method)(A0), A0 a0) { 532 | return call_in(ms, mbed::Callback(obj, method), a0); 533 | } 534 | 535 | /** Calls an event on the queue after a specified delay 536 | * @see EventQueue::call_in 537 | */ 538 | template 539 | int call_in(int ms, const T *obj, R (T::*method)(A0) const, A0 a0) { 540 | return call_in(ms, mbed::Callback(obj, method), a0); 541 | } 542 | 543 | /** Calls an event on the queue after a specified delay 544 | * @see EventQueue::call_in 545 | */ 546 | template 547 | int call_in(int ms, volatile T *obj, R (T::*method)(A0) volatile, A0 a0) { 548 | return call_in(ms, mbed::Callback(obj, method), a0); 549 | } 550 | 551 | /** Calls an event on the queue after a specified delay 552 | * @see EventQueue::call_in 553 | */ 554 | template 555 | int call_in(int ms, const volatile T *obj, R (T::*method)(A0) const volatile, A0 a0) { 556 | return call_in(ms, mbed::Callback(obj, method), a0); 557 | } 558 | 559 | /** Calls an event on the queue after a specified delay 560 | * @see EventQueue::call_in 561 | */ 562 | template 563 | int call_in(int ms, T *obj, R (T::*method)(A0, A1), A0 a0, A1 a1) { 564 | return call_in(ms, mbed::Callback(obj, method), a0, a1); 565 | } 566 | 567 | /** Calls an event on the queue after a specified delay 568 | * @see EventQueue::call_in 569 | */ 570 | template 571 | int call_in(int ms, const T *obj, R (T::*method)(A0, A1) const, A0 a0, A1 a1) { 572 | return call_in(ms, mbed::Callback(obj, method), a0, a1); 573 | } 574 | 575 | /** Calls an event on the queue after a specified delay 576 | * @see EventQueue::call_in 577 | */ 578 | template 579 | int call_in(int ms, volatile T *obj, R (T::*method)(A0, A1) volatile, A0 a0, A1 a1) { 580 | return call_in(ms, mbed::Callback(obj, method), a0, a1); 581 | } 582 | 583 | /** Calls an event on the queue after a specified delay 584 | * @see EventQueue::call_in 585 | */ 586 | template 587 | int call_in(int ms, const volatile T *obj, R (T::*method)(A0, A1) const volatile, A0 a0, A1 a1) { 588 | return call_in(ms, mbed::Callback(obj, method), a0, a1); 589 | } 590 | 591 | /** Calls an event on the queue after a specified delay 592 | * @see EventQueue::call_in 593 | */ 594 | template 595 | int call_in(int ms, T *obj, R (T::*method)(A0, A1, A2), A0 a0, A1 a1, A2 a2) { 596 | return call_in(ms, mbed::Callback(obj, method), a0, a1, a2); 597 | } 598 | 599 | /** Calls an event on the queue after a specified delay 600 | * @see EventQueue::call_in 601 | */ 602 | template 603 | int call_in(int ms, const T *obj, R (T::*method)(A0, A1, A2) const, A0 a0, A1 a1, A2 a2) { 604 | return call_in(ms, mbed::Callback(obj, method), a0, a1, a2); 605 | } 606 | 607 | /** Calls an event on the queue after a specified delay 608 | * @see EventQueue::call_in 609 | */ 610 | template 611 | int call_in(int ms, volatile T *obj, R (T::*method)(A0, A1, A2) volatile, A0 a0, A1 a1, A2 a2) { 612 | return call_in(ms, mbed::Callback(obj, method), a0, a1, a2); 613 | } 614 | 615 | /** Calls an event on the queue after a specified delay 616 | * @see EventQueue::call_in 617 | */ 618 | template 619 | int call_in(int ms, const volatile T *obj, R (T::*method)(A0, A1, A2) const volatile, A0 a0, A1 a1, A2 a2) { 620 | return call_in(ms, mbed::Callback(obj, method), a0, a1, a2); 621 | } 622 | 623 | /** Calls an event on the queue after a specified delay 624 | * @see EventQueue::call_in 625 | */ 626 | template 627 | int call_in(int ms, T *obj, R (T::*method)(A0, A1, A2, A3), A0 a0, A1 a1, A2 a2, A3 a3) { 628 | return call_in(ms, mbed::Callback(obj, method), a0, a1, a2, a3); 629 | } 630 | 631 | /** Calls an event on the queue after a specified delay 632 | * @see EventQueue::call_in 633 | */ 634 | template 635 | int call_in(int ms, const T *obj, R (T::*method)(A0, A1, A2, A3) const, A0 a0, A1 a1, A2 a2, A3 a3) { 636 | return call_in(ms, mbed::Callback(obj, method), a0, a1, a2, a3); 637 | } 638 | 639 | /** Calls an event on the queue after a specified delay 640 | * @see EventQueue::call_in 641 | */ 642 | template 643 | int call_in(int ms, volatile T *obj, R (T::*method)(A0, A1, A2, A3) volatile, A0 a0, A1 a1, A2 a2, A3 a3) { 644 | return call_in(ms, mbed::Callback(obj, method), a0, a1, a2, a3); 645 | } 646 | 647 | /** Calls an event on the queue after a specified delay 648 | * @see EventQueue::call_in 649 | */ 650 | template 651 | int call_in(int ms, const volatile T *obj, R (T::*method)(A0, A1, A2, A3) const volatile, A0 a0, A1 a1, A2 a2, A3 a3) { 652 | return call_in(ms, mbed::Callback(obj, method), a0, a1, a2, a3); 653 | } 654 | 655 | /** Calls an event on the queue after a specified delay 656 | * @see EventQueue::call_in 657 | */ 658 | template 659 | int call_in(int ms, T *obj, R (T::*method)(A0, A1, A2, A3, A4), A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 660 | return call_in(ms, mbed::Callback(obj, method), a0, a1, a2, a3, a4); 661 | } 662 | 663 | /** Calls an event on the queue after a specified delay 664 | * @see EventQueue::call_in 665 | */ 666 | template 667 | int call_in(int ms, const T *obj, R (T::*method)(A0, A1, A2, A3, A4) const, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 668 | return call_in(ms, mbed::Callback(obj, method), a0, a1, a2, a3, a4); 669 | } 670 | 671 | /** Calls an event on the queue after a specified delay 672 | * @see EventQueue::call_in 673 | */ 674 | template 675 | int call_in(int ms, volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) volatile, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 676 | return call_in(ms, mbed::Callback(obj, method), a0, a1, a2, a3, a4); 677 | } 678 | 679 | /** Calls an event on the queue after a specified delay 680 | * @see EventQueue::call_in 681 | */ 682 | template 683 | int call_in(int ms, const volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) const volatile, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 684 | return call_in(ms, mbed::Callback(obj, method), a0, a1, a2, a3, a4); 685 | } 686 | 687 | /** Calls an event on the queue periodically 688 | * 689 | * The specified callback will be executed in the context of the event 690 | * queue's dispatch loop. 691 | * 692 | * The call_every function is irq safe and can act as a mechanism for 693 | * moving events out of irq contexts. 694 | * 695 | * @param f Function to execute in the context of the dispatch loop 696 | * @param a0..a4 Arguments to pass to the callback 697 | * @param ms Period of the event in milliseconds 698 | * @return A unique id that represents the posted event and can 699 | * be passed to cancel, or an id of 0 if there is not 700 | * enough memory to allocate the event. 701 | */ 702 | template 703 | int call_every(int ms, F f) { 704 | struct local { 705 | static void call(void *p) { (*static_cast(p))(); } 706 | static void dtor(void *p) { static_cast(p)->~F(); } 707 | }; 708 | 709 | void *p = equeue_alloc(&_equeue, sizeof(F)); 710 | if (!p) { 711 | return 0; 712 | } 713 | 714 | F *e = new (p) F(f); 715 | equeue_event_delay(e, ms); 716 | equeue_event_period(e, ms); 717 | equeue_event_dtor(e, &local::dtor); 718 | return equeue_post(&_equeue, &local::call, e); 719 | } 720 | 721 | /** Calls an event on the queue periodically 722 | * @see EventQueue::call_every 723 | */ 724 | template 725 | int call_every(int ms, F f, A0 a0) { 726 | return call_every(ms, context10(f, a0)); 727 | } 728 | 729 | /** Calls an event on the queue periodically 730 | * @see EventQueue::call_every 731 | */ 732 | template 733 | int call_every(int ms, F f, A0 a0, A1 a1) { 734 | return call_every(ms, context20(f, a0, a1)); 735 | } 736 | 737 | /** Calls an event on the queue periodically 738 | * @see EventQueue::call_every 739 | */ 740 | template 741 | int call_every(int ms, F f, A0 a0, A1 a1, A2 a2) { 742 | return call_every(ms, context30(f, a0, a1, a2)); 743 | } 744 | 745 | /** Calls an event on the queue periodically 746 | * @see EventQueue::call_every 747 | */ 748 | template 749 | int call_every(int ms, F f, A0 a0, A1 a1, A2 a2, A3 a3) { 750 | return call_every(ms, context40(f, a0, a1, a2, a3)); 751 | } 752 | 753 | /** Calls an event on the queue periodically 754 | * @see EventQueue::call_every 755 | */ 756 | template 757 | int call_every(int ms, F f, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 758 | return call_every(ms, context50(f, a0, a1, a2, a3, a4)); 759 | } 760 | 761 | /** Calls an event on the queue periodically 762 | * @see EventQueue::call_every 763 | */ 764 | template 765 | int call_every(int ms, T *obj, R (T::*method)()) { 766 | return call_every(ms, mbed::Callback(obj, method)); 767 | } 768 | 769 | /** Calls an event on the queue periodically 770 | * @see EventQueue::call_every 771 | */ 772 | template 773 | int call_every(int ms, const T *obj, R (T::*method)() const) { 774 | return call_every(ms, mbed::Callback(obj, method)); 775 | } 776 | 777 | /** Calls an event on the queue periodically 778 | * @see EventQueue::call_every 779 | */ 780 | template 781 | int call_every(int ms, volatile T *obj, R (T::*method)() volatile) { 782 | return call_every(ms, mbed::Callback(obj, method)); 783 | } 784 | 785 | /** Calls an event on the queue periodically 786 | * @see EventQueue::call_every 787 | */ 788 | template 789 | int call_every(int ms, const volatile T *obj, R (T::*method)() const volatile) { 790 | return call_every(ms, mbed::Callback(obj, method)); 791 | } 792 | 793 | /** Calls an event on the queue periodically 794 | * @see EventQueue::call_every 795 | */ 796 | template 797 | int call_every(int ms, T *obj, R (T::*method)(A0), A0 a0) { 798 | return call_every(ms, mbed::Callback(obj, method), a0); 799 | } 800 | 801 | /** Calls an event on the queue periodically 802 | * @see EventQueue::call_every 803 | */ 804 | template 805 | int call_every(int ms, const T *obj, R (T::*method)(A0) const, A0 a0) { 806 | return call_every(ms, mbed::Callback(obj, method), a0); 807 | } 808 | 809 | /** Calls an event on the queue periodically 810 | * @see EventQueue::call_every 811 | */ 812 | template 813 | int call_every(int ms, volatile T *obj, R (T::*method)(A0) volatile, A0 a0) { 814 | return call_every(ms, mbed::Callback(obj, method), a0); 815 | } 816 | 817 | /** Calls an event on the queue periodically 818 | * @see EventQueue::call_every 819 | */ 820 | template 821 | int call_every(int ms, const volatile T *obj, R (T::*method)(A0) const volatile, A0 a0) { 822 | return call_every(ms, mbed::Callback(obj, method), a0); 823 | } 824 | 825 | /** Calls an event on the queue periodically 826 | * @see EventQueue::call_every 827 | */ 828 | template 829 | int call_every(int ms, T *obj, R (T::*method)(A0, A1), A0 a0, A1 a1) { 830 | return call_every(ms, mbed::Callback(obj, method), a0, a1); 831 | } 832 | 833 | /** Calls an event on the queue periodically 834 | * @see EventQueue::call_every 835 | */ 836 | template 837 | int call_every(int ms, const T *obj, R (T::*method)(A0, A1) const, A0 a0, A1 a1) { 838 | return call_every(ms, mbed::Callback(obj, method), a0, a1); 839 | } 840 | 841 | /** Calls an event on the queue periodically 842 | * @see EventQueue::call_every 843 | */ 844 | template 845 | int call_every(int ms, volatile T *obj, R (T::*method)(A0, A1) volatile, A0 a0, A1 a1) { 846 | return call_every(ms, mbed::Callback(obj, method), a0, a1); 847 | } 848 | 849 | /** Calls an event on the queue periodically 850 | * @see EventQueue::call_every 851 | */ 852 | template 853 | int call_every(int ms, const volatile T *obj, R (T::*method)(A0, A1) const volatile, A0 a0, A1 a1) { 854 | return call_every(ms, mbed::Callback(obj, method), a0, a1); 855 | } 856 | 857 | /** Calls an event on the queue periodically 858 | * @see EventQueue::call_every 859 | */ 860 | template 861 | int call_every(int ms, T *obj, R (T::*method)(A0, A1, A2), A0 a0, A1 a1, A2 a2) { 862 | return call_every(ms, mbed::Callback(obj, method), a0, a1, a2); 863 | } 864 | 865 | /** Calls an event on the queue periodically 866 | * @see EventQueue::call_every 867 | */ 868 | template 869 | int call_every(int ms, const T *obj, R (T::*method)(A0, A1, A2) const, A0 a0, A1 a1, A2 a2) { 870 | return call_every(ms, mbed::Callback(obj, method), a0, a1, a2); 871 | } 872 | 873 | /** Calls an event on the queue periodically 874 | * @see EventQueue::call_every 875 | */ 876 | template 877 | int call_every(int ms, volatile T *obj, R (T::*method)(A0, A1, A2) volatile, A0 a0, A1 a1, A2 a2) { 878 | return call_every(ms, mbed::Callback(obj, method), a0, a1, a2); 879 | } 880 | 881 | /** Calls an event on the queue periodically 882 | * @see EventQueue::call_every 883 | */ 884 | template 885 | int call_every(int ms, const volatile T *obj, R (T::*method)(A0, A1, A2) const volatile, A0 a0, A1 a1, A2 a2) { 886 | return call_every(ms, mbed::Callback(obj, method), a0, a1, a2); 887 | } 888 | 889 | /** Calls an event on the queue periodically 890 | * @see EventQueue::call_every 891 | */ 892 | template 893 | int call_every(int ms, T *obj, R (T::*method)(A0, A1, A2, A3), A0 a0, A1 a1, A2 a2, A3 a3) { 894 | return call_every(ms, mbed::Callback(obj, method), a0, a1, a2, a3); 895 | } 896 | 897 | /** Calls an event on the queue periodically 898 | * @see EventQueue::call_every 899 | */ 900 | template 901 | int call_every(int ms, const T *obj, R (T::*method)(A0, A1, A2, A3) const, A0 a0, A1 a1, A2 a2, A3 a3) { 902 | return call_every(ms, mbed::Callback(obj, method), a0, a1, a2, a3); 903 | } 904 | 905 | /** Calls an event on the queue periodically 906 | * @see EventQueue::call_every 907 | */ 908 | template 909 | int call_every(int ms, volatile T *obj, R (T::*method)(A0, A1, A2, A3) volatile, A0 a0, A1 a1, A2 a2, A3 a3) { 910 | return call_every(ms, mbed::Callback(obj, method), a0, a1, a2, a3); 911 | } 912 | 913 | /** Calls an event on the queue periodically 914 | * @see EventQueue::call_every 915 | */ 916 | template 917 | int call_every(int ms, const volatile T *obj, R (T::*method)(A0, A1, A2, A3) const volatile, A0 a0, A1 a1, A2 a2, A3 a3) { 918 | return call_every(ms, mbed::Callback(obj, method), a0, a1, a2, a3); 919 | } 920 | 921 | /** Calls an event on the queue periodically 922 | * @see EventQueue::call_every 923 | */ 924 | template 925 | int call_every(int ms, T *obj, R (T::*method)(A0, A1, A2, A3, A4), A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 926 | return call_every(ms, mbed::Callback(obj, method), a0, a1, a2, a3, a4); 927 | } 928 | 929 | /** Calls an event on the queue periodically 930 | * @see EventQueue::call_every 931 | */ 932 | template 933 | int call_every(int ms, const T *obj, R (T::*method)(A0, A1, A2, A3, A4) const, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 934 | return call_every(ms, mbed::Callback(obj, method), a0, a1, a2, a3, a4); 935 | } 936 | 937 | /** Calls an event on the queue periodically 938 | * @see EventQueue::call_every 939 | */ 940 | template 941 | int call_every(int ms, volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) volatile, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 942 | return call_every(ms, mbed::Callback(obj, method), a0, a1, a2, a3, a4); 943 | } 944 | 945 | /** Calls an event on the queue periodically 946 | * @see EventQueue::call_every 947 | */ 948 | template 949 | int call_every(int ms, const volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) const volatile, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) { 950 | return call_every(ms, mbed::Callback(obj, method), a0, a1, a2, a3, a4); 951 | } 952 | 953 | /** Creates an event bound to the event queue 954 | * 955 | * Constructs an event bound to the specified event queue. The specified 956 | * callback acts as the target for the event and is executed in the 957 | * context of the event queue's dispatch loop once posted. 958 | * 959 | * @param f Function to execute when the event is dispatched 960 | * @param a0..a4 Arguments to pass to the callback 961 | * @return Event that will dispatch on the specific queue 962 | */ 963 | template 964 | Event event(R (*func)()); 965 | 966 | /** Creates an event bound to the event queue 967 | * @see EventQueue::event 968 | */ 969 | template 970 | Event event(T *obj, R (T::*method)()); 971 | 972 | /** Creates an event bound to the event queue 973 | * @see EventQueue::event 974 | */ 975 | template 976 | Event event(const T *obj, R (T::*method)() const); 977 | 978 | /** Creates an event bound to the event queue 979 | * @see EventQueue::event 980 | */ 981 | template 982 | Event event(volatile T *obj, R (T::*method)() volatile); 983 | 984 | /** Creates an event bound to the event queue 985 | * @see EventQueue::event 986 | */ 987 | template 988 | Event event(const volatile T *obj, R (T::*method)() const volatile); 989 | 990 | /** Creates an event bound to the event queue 991 | * @see EventQueue::event 992 | */ 993 | template 994 | Event event(R (*func)(B0), C0 c0); 995 | 996 | /** Creates an event bound to the event queue 997 | * @see EventQueue::event 998 | */ 999 | template 1000 | Event event(T *obj, R (T::*method)(B0), C0 c0); 1001 | 1002 | /** Creates an event bound to the event queue 1003 | * @see EventQueue::event 1004 | */ 1005 | template 1006 | Event event(const T *obj, R (T::*method)(B0) const, C0 c0); 1007 | 1008 | /** Creates an event bound to the event queue 1009 | * @see EventQueue::event 1010 | */ 1011 | template 1012 | Event event(volatile T *obj, R (T::*method)(B0) volatile, C0 c0); 1013 | 1014 | /** Creates an event bound to the event queue 1015 | * @see EventQueue::event 1016 | */ 1017 | template 1018 | Event event(const volatile T *obj, R (T::*method)(B0) const volatile, C0 c0); 1019 | 1020 | /** Creates an event bound to the event queue 1021 | * @see EventQueue::event 1022 | */ 1023 | template 1024 | Event event(R (*func)(B0, B1), C0 c0, C1 c1); 1025 | 1026 | /** Creates an event bound to the event queue 1027 | * @see EventQueue::event 1028 | */ 1029 | template 1030 | Event event(T *obj, R (T::*method)(B0, B1), C0 c0, C1 c1); 1031 | 1032 | /** Creates an event bound to the event queue 1033 | * @see EventQueue::event 1034 | */ 1035 | template 1036 | Event event(const T *obj, R (T::*method)(B0, B1) const, C0 c0, C1 c1); 1037 | 1038 | /** Creates an event bound to the event queue 1039 | * @see EventQueue::event 1040 | */ 1041 | template 1042 | Event event(volatile T *obj, R (T::*method)(B0, B1) volatile, C0 c0, C1 c1); 1043 | 1044 | /** Creates an event bound to the event queue 1045 | * @see EventQueue::event 1046 | */ 1047 | template 1048 | Event event(const volatile T *obj, R (T::*method)(B0, B1) const volatile, C0 c0, C1 c1); 1049 | 1050 | /** Creates an event bound to the event queue 1051 | * @see EventQueue::event 1052 | */ 1053 | template 1054 | Event event(R (*func)(B0, B1, B2), C0 c0, C1 c1, C2 c2); 1055 | 1056 | /** Creates an event bound to the event queue 1057 | * @see EventQueue::event 1058 | */ 1059 | template 1060 | Event event(T *obj, R (T::*method)(B0, B1, B2), C0 c0, C1 c1, C2 c2); 1061 | 1062 | /** Creates an event bound to the event queue 1063 | * @see EventQueue::event 1064 | */ 1065 | template 1066 | Event event(const T *obj, R (T::*method)(B0, B1, B2) const, C0 c0, C1 c1, C2 c2); 1067 | 1068 | /** Creates an event bound to the event queue 1069 | * @see EventQueue::event 1070 | */ 1071 | template 1072 | Event event(volatile T *obj, R (T::*method)(B0, B1, B2) volatile, C0 c0, C1 c1, C2 c2); 1073 | 1074 | /** Creates an event bound to the event queue 1075 | * @see EventQueue::event 1076 | */ 1077 | template 1078 | Event event(const volatile T *obj, R (T::*method)(B0, B1, B2) const volatile, C0 c0, C1 c1, C2 c2); 1079 | 1080 | /** Creates an event bound to the event queue 1081 | * @see EventQueue::event 1082 | */ 1083 | template 1084 | Event event(R (*func)(B0, B1, B2, B3), C0 c0, C1 c1, C2 c2, C3 c3); 1085 | 1086 | /** Creates an event bound to the event queue 1087 | * @see EventQueue::event 1088 | */ 1089 | template 1090 | Event event(T *obj, R (T::*method)(B0, B1, B2, B3), C0 c0, C1 c1, C2 c2, C3 c3); 1091 | 1092 | /** Creates an event bound to the event queue 1093 | * @see EventQueue::event 1094 | */ 1095 | template 1096 | Event event(const T *obj, R (T::*method)(B0, B1, B2, B3) const, C0 c0, C1 c1, C2 c2, C3 c3); 1097 | 1098 | /** Creates an event bound to the event queue 1099 | * @see EventQueue::event 1100 | */ 1101 | template 1102 | Event event(volatile T *obj, R (T::*method)(B0, B1, B2, B3) volatile, C0 c0, C1 c1, C2 c2, C3 c3); 1103 | 1104 | /** Creates an event bound to the event queue 1105 | * @see EventQueue::event 1106 | */ 1107 | template 1108 | Event event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3) const volatile, C0 c0, C1 c1, C2 c2, C3 c3); 1109 | 1110 | /** Creates an event bound to the event queue 1111 | * @see EventQueue::event 1112 | */ 1113 | template 1114 | Event event(R (*func)(B0, B1, B2, B3, B4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4); 1115 | 1116 | /** Creates an event bound to the event queue 1117 | * @see EventQueue::event 1118 | */ 1119 | template 1120 | Event event(T *obj, R (T::*method)(B0, B1, B2, B3, B4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4); 1121 | 1122 | /** Creates an event bound to the event queue 1123 | * @see EventQueue::event 1124 | */ 1125 | template 1126 | Event event(const T *obj, R (T::*method)(B0, B1, B2, B3, B4) const, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4); 1127 | 1128 | /** Creates an event bound to the event queue 1129 | * @see EventQueue::event 1130 | */ 1131 | template 1132 | Event event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4) volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4); 1133 | 1134 | /** Creates an event bound to the event queue 1135 | * @see EventQueue::event 1136 | */ 1137 | template 1138 | Event 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); 1139 | 1140 | /** Creates an event bound to the event queue 1141 | * @see EventQueue::event 1142 | */ 1143 | template 1144 | Event event(R (*func)(A0)); 1145 | 1146 | /** Creates an event bound to the event queue 1147 | * @see EventQueue::event 1148 | */ 1149 | template 1150 | Event event(T *obj, R (T::*method)(A0)); 1151 | 1152 | /** Creates an event bound to the event queue 1153 | * @see EventQueue::event 1154 | */ 1155 | template 1156 | Event event(const T *obj, R (T::*method)(A0) const); 1157 | 1158 | /** Creates an event bound to the event queue 1159 | * @see EventQueue::event 1160 | */ 1161 | template 1162 | Event event(volatile T *obj, R (T::*method)(A0) volatile); 1163 | 1164 | /** Creates an event bound to the event queue 1165 | * @see EventQueue::event 1166 | */ 1167 | template 1168 | Event event(const volatile T *obj, R (T::*method)(A0) const volatile); 1169 | 1170 | /** Creates an event bound to the event queue 1171 | * @see EventQueue::event 1172 | */ 1173 | template 1174 | Event event(R (*func)(B0, A0), C0 c0); 1175 | 1176 | /** Creates an event bound to the event queue 1177 | * @see EventQueue::event 1178 | */ 1179 | template 1180 | Event event(T *obj, R (T::*method)(B0, A0), C0 c0); 1181 | 1182 | /** Creates an event bound to the event queue 1183 | * @see EventQueue::event 1184 | */ 1185 | template 1186 | Event event(const T *obj, R (T::*method)(B0, A0) const, C0 c0); 1187 | 1188 | /** Creates an event bound to the event queue 1189 | * @see EventQueue::event 1190 | */ 1191 | template 1192 | Event event(volatile T *obj, R (T::*method)(B0, A0) volatile, C0 c0); 1193 | 1194 | /** Creates an event bound to the event queue 1195 | * @see EventQueue::event 1196 | */ 1197 | template 1198 | Event event(const volatile T *obj, R (T::*method)(B0, A0) const volatile, C0 c0); 1199 | 1200 | /** Creates an event bound to the event queue 1201 | * @see EventQueue::event 1202 | */ 1203 | template 1204 | Event event(R (*func)(B0, B1, A0), C0 c0, C1 c1); 1205 | 1206 | /** Creates an event bound to the event queue 1207 | * @see EventQueue::event 1208 | */ 1209 | template 1210 | Event event(T *obj, R (T::*method)(B0, B1, A0), C0 c0, C1 c1); 1211 | 1212 | /** Creates an event bound to the event queue 1213 | * @see EventQueue::event 1214 | */ 1215 | template 1216 | Event event(const T *obj, R (T::*method)(B0, B1, A0) const, C0 c0, C1 c1); 1217 | 1218 | /** Creates an event bound to the event queue 1219 | * @see EventQueue::event 1220 | */ 1221 | template 1222 | Event event(volatile T *obj, R (T::*method)(B0, B1, A0) volatile, C0 c0, C1 c1); 1223 | 1224 | /** Creates an event bound to the event queue 1225 | * @see EventQueue::event 1226 | */ 1227 | template 1228 | Event event(const volatile T *obj, R (T::*method)(B0, B1, A0) const volatile, C0 c0, C1 c1); 1229 | 1230 | /** Creates an event bound to the event queue 1231 | * @see EventQueue::event 1232 | */ 1233 | template 1234 | Event event(R (*func)(B0, B1, B2, A0), C0 c0, C1 c1, C2 c2); 1235 | 1236 | /** Creates an event bound to the event queue 1237 | * @see EventQueue::event 1238 | */ 1239 | template 1240 | Event event(T *obj, R (T::*method)(B0, B1, B2, A0), C0 c0, C1 c1, C2 c2); 1241 | 1242 | /** Creates an event bound to the event queue 1243 | * @see EventQueue::event 1244 | */ 1245 | template 1246 | Event event(const T *obj, R (T::*method)(B0, B1, B2, A0) const, C0 c0, C1 c1, C2 c2); 1247 | 1248 | /** Creates an event bound to the event queue 1249 | * @see EventQueue::event 1250 | */ 1251 | template 1252 | Event event(volatile T *obj, R (T::*method)(B0, B1, B2, A0) volatile, C0 c0, C1 c1, C2 c2); 1253 | 1254 | /** Creates an event bound to the event queue 1255 | * @see EventQueue::event 1256 | */ 1257 | template 1258 | Event event(const volatile T *obj, R (T::*method)(B0, B1, B2, A0) const volatile, C0 c0, C1 c1, C2 c2); 1259 | 1260 | /** Creates an event bound to the event queue 1261 | * @see EventQueue::event 1262 | */ 1263 | template 1264 | Event event(R (*func)(B0, B1, B2, B3, A0), C0 c0, C1 c1, C2 c2, C3 c3); 1265 | 1266 | /** Creates an event bound to the event queue 1267 | * @see EventQueue::event 1268 | */ 1269 | template 1270 | Event event(T *obj, R (T::*method)(B0, B1, B2, B3, A0), C0 c0, C1 c1, C2 c2, C3 c3); 1271 | 1272 | /** Creates an event bound to the event queue 1273 | * @see EventQueue::event 1274 | */ 1275 | template 1276 | Event event(const T *obj, R (T::*method)(B0, B1, B2, B3, A0) const, C0 c0, C1 c1, C2 c2, C3 c3); 1277 | 1278 | /** Creates an event bound to the event queue 1279 | * @see EventQueue::event 1280 | */ 1281 | template 1282 | Event event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0) volatile, C0 c0, C1 c1, C2 c2, C3 c3); 1283 | 1284 | /** Creates an event bound to the event queue 1285 | * @see EventQueue::event 1286 | */ 1287 | template 1288 | Event event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0) const volatile, C0 c0, C1 c1, C2 c2, C3 c3); 1289 | 1290 | /** Creates an event bound to the event queue 1291 | * @see EventQueue::event 1292 | */ 1293 | template 1294 | Event event(R (*func)(B0, B1, B2, B3, B4, A0), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4); 1295 | 1296 | /** Creates an event bound to the event queue 1297 | * @see EventQueue::event 1298 | */ 1299 | template 1300 | Event event(T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4); 1301 | 1302 | /** Creates an event bound to the event queue 1303 | * @see EventQueue::event 1304 | */ 1305 | template 1306 | Event event(const T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0) const, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4); 1307 | 1308 | /** Creates an event bound to the event queue 1309 | * @see EventQueue::event 1310 | */ 1311 | template 1312 | Event event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0) volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4); 1313 | 1314 | /** Creates an event bound to the event queue 1315 | * @see EventQueue::event 1316 | */ 1317 | template 1318 | Event 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); 1319 | 1320 | /** Creates an event bound to the event queue 1321 | * @see EventQueue::event 1322 | */ 1323 | template 1324 | Event event(R (*func)(A0, A1)); 1325 | 1326 | /** Creates an event bound to the event queue 1327 | * @see EventQueue::event 1328 | */ 1329 | template 1330 | Event event(T *obj, R (T::*method)(A0, A1)); 1331 | 1332 | /** Creates an event bound to the event queue 1333 | * @see EventQueue::event 1334 | */ 1335 | template 1336 | Event event(const T *obj, R (T::*method)(A0, A1) const); 1337 | 1338 | /** Creates an event bound to the event queue 1339 | * @see EventQueue::event 1340 | */ 1341 | template 1342 | Event event(volatile T *obj, R (T::*method)(A0, A1) volatile); 1343 | 1344 | /** Creates an event bound to the event queue 1345 | * @see EventQueue::event 1346 | */ 1347 | template 1348 | Event event(const volatile T *obj, R (T::*method)(A0, A1) const volatile); 1349 | 1350 | /** Creates an event bound to the event queue 1351 | * @see EventQueue::event 1352 | */ 1353 | template 1354 | Event event(R (*func)(B0, A0, A1), C0 c0); 1355 | 1356 | /** Creates an event bound to the event queue 1357 | * @see EventQueue::event 1358 | */ 1359 | template 1360 | Event event(T *obj, R (T::*method)(B0, A0, A1), C0 c0); 1361 | 1362 | /** Creates an event bound to the event queue 1363 | * @see EventQueue::event 1364 | */ 1365 | template 1366 | Event event(const T *obj, R (T::*method)(B0, A0, A1) const, C0 c0); 1367 | 1368 | /** Creates an event bound to the event queue 1369 | * @see EventQueue::event 1370 | */ 1371 | template 1372 | Event event(volatile T *obj, R (T::*method)(B0, A0, A1) volatile, C0 c0); 1373 | 1374 | /** Creates an event bound to the event queue 1375 | * @see EventQueue::event 1376 | */ 1377 | template 1378 | Event event(const volatile T *obj, R (T::*method)(B0, A0, A1) const volatile, C0 c0); 1379 | 1380 | /** Creates an event bound to the event queue 1381 | * @see EventQueue::event 1382 | */ 1383 | template 1384 | Event event(R (*func)(B0, B1, A0, A1), C0 c0, C1 c1); 1385 | 1386 | /** Creates an event bound to the event queue 1387 | * @see EventQueue::event 1388 | */ 1389 | template 1390 | Event event(T *obj, R (T::*method)(B0, B1, A0, A1), C0 c0, C1 c1); 1391 | 1392 | /** Creates an event bound to the event queue 1393 | * @see EventQueue::event 1394 | */ 1395 | template 1396 | Event event(const T *obj, R (T::*method)(B0, B1, A0, A1) const, C0 c0, C1 c1); 1397 | 1398 | /** Creates an event bound to the event queue 1399 | * @see EventQueue::event 1400 | */ 1401 | template 1402 | Event event(volatile T *obj, R (T::*method)(B0, B1, A0, A1) volatile, C0 c0, C1 c1); 1403 | 1404 | /** Creates an event bound to the event queue 1405 | * @see EventQueue::event 1406 | */ 1407 | template 1408 | Event event(const volatile T *obj, R (T::*method)(B0, B1, A0, A1) const volatile, C0 c0, C1 c1); 1409 | 1410 | /** Creates an event bound to the event queue 1411 | * @see EventQueue::event 1412 | */ 1413 | template 1414 | Event event(R (*func)(B0, B1, B2, A0, A1), C0 c0, C1 c1, C2 c2); 1415 | 1416 | /** Creates an event bound to the event queue 1417 | * @see EventQueue::event 1418 | */ 1419 | template 1420 | Event event(T *obj, R (T::*method)(B0, B1, B2, A0, A1), C0 c0, C1 c1, C2 c2); 1421 | 1422 | /** Creates an event bound to the event queue 1423 | * @see EventQueue::event 1424 | */ 1425 | template 1426 | Event event(const T *obj, R (T::*method)(B0, B1, B2, A0, A1) const, C0 c0, C1 c1, C2 c2); 1427 | 1428 | /** Creates an event bound to the event queue 1429 | * @see EventQueue::event 1430 | */ 1431 | template 1432 | Event event(volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1) volatile, C0 c0, C1 c1, C2 c2); 1433 | 1434 | /** Creates an event bound to the event queue 1435 | * @see EventQueue::event 1436 | */ 1437 | template 1438 | Event event(const volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1) const volatile, C0 c0, C1 c1, C2 c2); 1439 | 1440 | /** Creates an event bound to the event queue 1441 | * @see EventQueue::event 1442 | */ 1443 | template 1444 | Event event(R (*func)(B0, B1, B2, B3, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3); 1445 | 1446 | /** Creates an event bound to the event queue 1447 | * @see EventQueue::event 1448 | */ 1449 | template 1450 | Event event(T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3); 1451 | 1452 | /** Creates an event bound to the event queue 1453 | * @see EventQueue::event 1454 | */ 1455 | template 1456 | Event event(const T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1) const, C0 c0, C1 c1, C2 c2, C3 c3); 1457 | 1458 | /** Creates an event bound to the event queue 1459 | * @see EventQueue::event 1460 | */ 1461 | template 1462 | Event event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1) volatile, C0 c0, C1 c1, C2 c2, C3 c3); 1463 | 1464 | /** Creates an event bound to the event queue 1465 | * @see EventQueue::event 1466 | */ 1467 | template 1468 | Event event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1) const volatile, C0 c0, C1 c1, C2 c2, C3 c3); 1469 | 1470 | /** Creates an event bound to the event queue 1471 | * @see EventQueue::event 1472 | */ 1473 | template 1474 | Event event(R (*func)(B0, B1, B2, B3, B4, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4); 1475 | 1476 | /** Creates an event bound to the event queue 1477 | * @see EventQueue::event 1478 | */ 1479 | template 1480 | Event event(T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4); 1481 | 1482 | /** Creates an event bound to the event queue 1483 | * @see EventQueue::event 1484 | */ 1485 | template 1486 | Event 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); 1487 | 1488 | /** Creates an event bound to the event queue 1489 | * @see EventQueue::event 1490 | */ 1491 | template 1492 | Event 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); 1493 | 1494 | /** Creates an event bound to the event queue 1495 | * @see EventQueue::event 1496 | */ 1497 | template 1498 | Event 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); 1499 | 1500 | /** Creates an event bound to the event queue 1501 | * @see EventQueue::event 1502 | */ 1503 | template 1504 | Event event(R (*func)(A0, A1, A2)); 1505 | 1506 | /** Creates an event bound to the event queue 1507 | * @see EventQueue::event 1508 | */ 1509 | template 1510 | Event event(T *obj, R (T::*method)(A0, A1, A2)); 1511 | 1512 | /** Creates an event bound to the event queue 1513 | * @see EventQueue::event 1514 | */ 1515 | template 1516 | Event event(const T *obj, R (T::*method)(A0, A1, A2) const); 1517 | 1518 | /** Creates an event bound to the event queue 1519 | * @see EventQueue::event 1520 | */ 1521 | template 1522 | Event event(volatile T *obj, R (T::*method)(A0, A1, A2) volatile); 1523 | 1524 | /** Creates an event bound to the event queue 1525 | * @see EventQueue::event 1526 | */ 1527 | template 1528 | Event event(const volatile T *obj, R (T::*method)(A0, A1, A2) const volatile); 1529 | 1530 | /** Creates an event bound to the event queue 1531 | * @see EventQueue::event 1532 | */ 1533 | template 1534 | Event event(R (*func)(B0, A0, A1, A2), C0 c0); 1535 | 1536 | /** Creates an event bound to the event queue 1537 | * @see EventQueue::event 1538 | */ 1539 | template 1540 | Event event(T *obj, R (T::*method)(B0, A0, A1, A2), C0 c0); 1541 | 1542 | /** Creates an event bound to the event queue 1543 | * @see EventQueue::event 1544 | */ 1545 | template 1546 | Event event(const T *obj, R (T::*method)(B0, A0, A1, A2) const, C0 c0); 1547 | 1548 | /** Creates an event bound to the event queue 1549 | * @see EventQueue::event 1550 | */ 1551 | template 1552 | Event event(volatile T *obj, R (T::*method)(B0, A0, A1, A2) volatile, C0 c0); 1553 | 1554 | /** Creates an event bound to the event queue 1555 | * @see EventQueue::event 1556 | */ 1557 | template 1558 | Event event(const volatile T *obj, R (T::*method)(B0, A0, A1, A2) const volatile, C0 c0); 1559 | 1560 | /** Creates an event bound to the event queue 1561 | * @see EventQueue::event 1562 | */ 1563 | template 1564 | Event event(R (*func)(B0, B1, A0, A1, A2), C0 c0, C1 c1); 1565 | 1566 | /** Creates an event bound to the event queue 1567 | * @see EventQueue::event 1568 | */ 1569 | template 1570 | Event event(T *obj, R (T::*method)(B0, B1, A0, A1, A2), C0 c0, C1 c1); 1571 | 1572 | /** Creates an event bound to the event queue 1573 | * @see EventQueue::event 1574 | */ 1575 | template 1576 | Event event(const T *obj, R (T::*method)(B0, B1, A0, A1, A2) const, C0 c0, C1 c1); 1577 | 1578 | /** Creates an event bound to the event queue 1579 | * @see EventQueue::event 1580 | */ 1581 | template 1582 | Event event(volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2) volatile, C0 c0, C1 c1); 1583 | 1584 | /** Creates an event bound to the event queue 1585 | * @see EventQueue::event 1586 | */ 1587 | template 1588 | Event