EventQueue.h

00001 /* events
00002  * Copyright (c) 2016 ARM Limited
00003  *
00004  * Licensed under the Apache License, Version 2.0 (the "License");
00005  * you may not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  *
00008  *     http://www.apache.org/licenses/LICENSE-2.0
00009  *
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an "AS IS" BASIS,
00012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015  */
00016 
00017 #ifndef EVENT_QUEUE_H
00018 #define EVENT_QUEUE_H
00019 
00020 #include "equeue/equeue.h"
00021 #include "platform/Callback.h"
00022 #include <cstddef>
00023 #include <new>
00024 
00025 namespace events {
00026 /** \addtogroup events */
00027 /** @{*/
00028 
00029 /** EVENTS_EVENT_SIZE
00030  *  Minimum size of an event
00031  *  This size fits a Callback<void()> at minimum
00032  */
00033 #define EVENTS_EVENT_SIZE \
00034     (EQUEUE_EVENT_SIZE - 2*sizeof(void*) + sizeof(mbed::Callback<void()>))
00035 
00036 /** EVENTS_QUEUE_SIZE
00037  *  Default size of buffer for events
00038  */
00039 #define EVENTS_QUEUE_SIZE (32*EVENTS_EVENT_SIZE)
00040 
00041 // Predeclared classes
00042 template <typename F>
00043 class Event;
00044 
00045 
00046 /** EventQueue
00047  *
00048  *  Flexible event queue for dispatching events
00049  */
00050 class EventQueue {
00051 public:
00052     /** Create an EventQueue
00053      *
00054      *  Create an event queue. The event queue either allocates a buffer of
00055      *  the specified size with malloc or uses the user provided buffer.
00056      *
00057      *  @param size     Size of buffer to use for events in bytes
00058      *                  (default to EVENTS_QUEUE_SIZE)
00059      *  @param buffer   Pointer to buffer to use for events
00060      *                  (default to NULL)
00061      */
00062     EventQueue(unsigned size=EVENTS_QUEUE_SIZE, unsigned char *buffer=NULL);
00063 
00064     /** Destroy an EventQueue
00065      */
00066     ~EventQueue();
00067 
00068     /** Dispatch events
00069      *
00070      *  Executes events until the specified milliseconds have passed.
00071      *  If ms is negative, the dispatch function will dispatch events
00072      *  indefinitely or until break_dispatch is called on this queue.
00073      *
00074      *  When called with a finite timeout, the dispatch function is guaranteed
00075      *  to terminate. When called with a timeout of 0, the dispatch function
00076      *  does not wait and is irq safe.
00077      *
00078      *  @param ms       Time to wait for events in milliseconds, a negative
00079      *                  value will dispatch events indefinitely
00080      *                  (default to -1)
00081      */
00082     void dispatch(int ms=-1);
00083 
00084     /** Dispatch events without a timeout
00085      *
00086      *  This is equivalent to EventQueue::dispatch with no arguments, but 
00087      *  avoids overload ambiguities when passed as a callback.
00088      *
00089      *  @see EventQueue::dispatch
00090      */
00091     void dispatch_forever() { dispatch(); }
00092 
00093     /** Break out of a running event loop
00094      *
00095      *  Forces the specified event queue's dispatch loop to terminate. Pending
00096      *  events may finish executing, but no new events will be executed.
00097      */
00098     void break_dispatch();
00099 
00100     /** Millisecond counter
00101      *
00102      *  Returns the underlying tick of the event queue represented as the 
00103      *  number of milliseconds that have passed since an arbitrary point in
00104      *  time. Intentionally overflows to 0 after 2^32-1.
00105      *
00106      *  @return         The underlying tick of the event queue in milliseconds
00107      */
00108     unsigned tick();
00109 
00110     /** Cancel an in-flight event
00111      *
00112      *  Attempts to cancel an event referenced by the unique id returned from
00113      *  one of the call functions. It is safe to call cancel after an event
00114      *  has already been dispatched.
00115      *
00116      *  The cancel function is irq safe.
00117      *
00118      *  If called while the event queue's dispatch loop is active, the cancel
00119      *  function does not garuntee that the event will not execute after it
00120      *  returns, as the event may have already begun executing.
00121      *
00122      *  @param id       Unique id of the event
00123      */
00124     void cancel(int id);
00125 
00126     /** Background an event queue onto a single-shot timer-interrupt
00127      *
00128      *  When updated, the event queue will call the provided update function
00129      *  with a timeout indicating when the queue should be dispatched. A
00130      *  negative timeout will be passed to the update function when the
00131      *  timer-interrupt is no longer needed.
00132      *
00133      *  Passing a null function disables the existing update function.
00134      *
00135      *  The background function allows an event queue to take advantage of
00136      *  hardware timers or other event loops, allowing an event queue to be
00137      *  ran in the background without consuming the foreground thread.
00138      *
00139      *  @param update   Function called to indicate when the queue should be
00140      *                  dispatched
00141      */
00142     void background(mbed::Callback<void(int)> update);
00143 
00144     /** Chain an event queue onto another event queue
00145      *
00146      *  After chaining a queue to a target, calling dispatch on the target
00147      *  queue will also dispatch events from this queue. The queues use
00148      *  their own buffers and events must be handled independently.
00149      *
00150      *  A null queue as the target will unchain the existing queue.
00151      *
00152      *  The chain function allows multiple event queues to be composed,
00153      *  sharing the context of a dispatch loop while still being managed
00154      *  independently
00155      *
00156      *  @param target   Queue that will dispatch this queue's events as a
00157      *                  part of its dispatch loop
00158      */
00159     void chain(EventQueue *target);
00160 
00161     /** Calls an event on the queue
00162      *
00163      *  The specified callback will be executed in the context of the event
00164      *  queue's dispatch loop.
00165      *
00166      *  The call function is irq safe and can act as a mechanism for moving
00167      *  events out of irq contexts.
00168      *
00169      *  @param f        Function to execute in the context of the dispatch loop
00170      *  @param a0..a4   Arguments to pass to the callback
00171      *  @return         A unique id that represents the posted event and can
00172      *                  be passed to cancel, or an id of 0 if there is not
00173      *                  enough memory to allocate the event.
00174      */
00175     template <typename F>
00176     int call(F f) {
00177         void *p = equeue_alloc(&_equeue, sizeof(F));
00178         if (!p) {
00179             return 0;
00180         }
00181 
00182         F *e = new (p) F(f);
00183         equeue_event_dtor(e, &EventQueue::function_dtor<F>);
00184         return equeue_post(&_equeue, &EventQueue::function_call<F>, e);
00185     }
00186 
00187     /** Calls an event on the queue
00188      *  @see EventQueue::call
00189      */
00190     template <typename F, typename A0>
00191     int call(F f, A0 a0) {
00192         return call(context10<F, A0>(f, a0));
00193     }
00194 
00195     /** Calls an event on the queue
00196      *  @see EventQueue::call
00197      */
00198     template <typename F, typename A0, typename A1>
00199     int call(F f, A0 a0, A1 a1) {
00200         return call(context20<F, A0, A1>(f, a0, a1));
00201     }
00202 
00203     /** Calls an event on the queue
00204      *  @see EventQueue::call
00205      */
00206     template <typename F, typename A0, typename A1, typename A2>
00207     int call(F f, A0 a0, A1 a1, A2 a2) {
00208         return call(context30<F, A0, A1, A2>(f, a0, a1, a2));
00209     }
00210 
00211     /** Calls an event on the queue
00212      *  @see EventQueue::call
00213      */
00214     template <typename F, typename A0, typename A1, typename A2, typename A3>
00215     int call(F f, A0 a0, A1 a1, A2 a2, A3 a3) {
00216         return call(context40<F, A0, A1, A2, A3>(f, a0, a1, a2, a3));
00217     }
00218 
00219     /** Calls an event on the queue
00220      *  @see EventQueue::call
00221      */
00222     template <typename F, typename A0, typename A1, typename A2, typename A3, typename A4>
00223     int call(F f, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
00224         return call(context50<F, A0, A1, A2, A3, A4>(f, a0, a1, a2, a3, a4));
00225     }
00226 
00227     /** Calls an event on the queue
00228      *  @see EventQueue::call
00229      */
00230     template <typename T, typename R>
00231     int call(T *obj, R (T::*method)()) {
00232         return call(mbed::callback(obj, method));
00233     }
00234 
00235     /** Calls an event on the queue
00236      *  @see EventQueue::call
00237      */
00238     template <typename T, typename R>
00239     int call(const T *obj, R (T::*method)() const) {
00240         return call(mbed::callback(obj, method));
00241     }
00242 
00243     /** Calls an event on the queue
00244      *  @see EventQueue::call
00245      */
00246     template <typename T, typename R>
00247     int call(volatile T *obj, R (T::*method)() volatile) {
00248         return call(mbed::callback(obj, method));
00249     }
00250 
00251     /** Calls an event on the queue
00252      *  @see EventQueue::call
00253      */
00254     template <typename T, typename R>
00255     int call(const volatile T *obj, R (T::*method)() const volatile) {
00256         return call(mbed::callback(obj, method));
00257     }
00258 
00259     /** Calls an event on the queue
00260      *  @see EventQueue::call
00261      */
00262     template <typename T, typename R, typename A0>
00263     int call(T *obj, R (T::*method)(A0), A0 a0) {
00264         return call(mbed::callback(obj, method), a0);
00265     }
00266 
00267     /** Calls an event on the queue
00268      *  @see EventQueue::call
00269      */
00270     template <typename T, typename R, typename A0>
00271     int call(const T *obj, R (T::*method)(A0) const, A0 a0) {
00272         return call(mbed::callback(obj, method), a0);
00273     }
00274 
00275     /** Calls an event on the queue
00276      *  @see EventQueue::call
00277      */
00278     template <typename T, typename R, typename A0>
00279     int call(volatile T *obj, R (T::*method)(A0) volatile, A0 a0) {
00280         return call(mbed::callback(obj, method), a0);
00281     }
00282 
00283     /** Calls an event on the queue
00284      *  @see EventQueue::call
00285      */
00286     template <typename T, typename R, typename A0>
00287     int call(const volatile T *obj, R (T::*method)(A0) const volatile, A0 a0) {
00288         return call(mbed::callback(obj, method), a0);
00289     }
00290 
00291     /** Calls an event on the queue
00292      *  @see EventQueue::call
00293      */
00294     template <typename T, typename R, typename A0, typename A1>
00295     int call(T *obj, R (T::*method)(A0, A1), A0 a0, A1 a1) {
00296         return call(mbed::callback(obj, method), a0, a1);
00297     }
00298 
00299     /** Calls an event on the queue
00300      *  @see EventQueue::call
00301      */
00302     template <typename T, typename R, typename A0, typename A1>
00303     int call(const T *obj, R (T::*method)(A0, A1) const, A0 a0, A1 a1) {
00304         return call(mbed::callback(obj, method), a0, a1);
00305     }
00306 
00307     /** Calls an event on the queue
00308      *  @see EventQueue::call
00309      */
00310     template <typename T, typename R, typename A0, typename A1>
00311     int call(volatile T *obj, R (T::*method)(A0, A1) volatile, A0 a0, A1 a1) {
00312         return call(mbed::callback(obj, method), a0, a1);
00313     }
00314 
00315     /** Calls an event on the queue
00316      *  @see EventQueue::call
00317      */
00318     template <typename T, typename R, typename A0, typename A1>
00319     int call(const volatile T *obj, R (T::*method)(A0, A1) const volatile, A0 a0, A1 a1) {
00320         return call(mbed::callback(obj, method), a0, a1);
00321     }
00322 
00323     /** Calls an event on the queue
00324      *  @see EventQueue::call
00325      */
00326     template <typename T, typename R, typename A0, typename A1, typename A2>
00327     int call(T *obj, R (T::*method)(A0, A1, A2), A0 a0, A1 a1, A2 a2) {
00328         return call(mbed::callback(obj, method), a0, a1, a2);
00329     }
00330 
00331     /** Calls an event on the queue
00332      *  @see EventQueue::call
00333      */
00334     template <typename T, typename R, typename A0, typename A1, typename A2>
00335     int call(const T *obj, R (T::*method)(A0, A1, A2) const, A0 a0, A1 a1, A2 a2) {
00336         return call(mbed::callback(obj, method), a0, a1, a2);
00337     }
00338 
00339     /** Calls an event on the queue
00340      *  @see EventQueue::call
00341      */
00342     template <typename T, typename R, typename A0, typename A1, typename A2>
00343     int call(volatile T *obj, R (T::*method)(A0, A1, A2) volatile, A0 a0, A1 a1, A2 a2) {
00344         return call(mbed::callback(obj, method), a0, a1, a2);
00345     }
00346 
00347     /** Calls an event on the queue
00348      *  @see EventQueue::call
00349      */
00350     template <typename T, typename R, typename A0, typename A1, typename A2>
00351     int call(const volatile T *obj, R (T::*method)(A0, A1, A2) const volatile, A0 a0, A1 a1, A2 a2) {
00352         return call(mbed::callback(obj, method), a0, a1, a2);
00353     }
00354 
00355     /** Calls an event on the queue
00356      *  @see EventQueue::call
00357      */
00358     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
00359     int call(T *obj, R (T::*method)(A0, A1, A2, A3), A0 a0, A1 a1, A2 a2, A3 a3) {
00360         return call(mbed::callback(obj, method), a0, a1, a2, a3);
00361     }
00362 
00363     /** Calls an event on the queue
00364      *  @see EventQueue::call
00365      */
00366     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
00367     int call(const T *obj, R (T::*method)(A0, A1, A2, A3) const, A0 a0, A1 a1, A2 a2, A3 a3) {
00368         return call(mbed::callback(obj, method), a0, a1, a2, a3);
00369     }
00370 
00371     /** Calls an event on the queue
00372      *  @see EventQueue::call
00373      */
00374     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
00375     int call(volatile T *obj, R (T::*method)(A0, A1, A2, A3) volatile, A0 a0, A1 a1, A2 a2, A3 a3) {
00376         return call(mbed::callback(obj, method), a0, a1, a2, a3);
00377     }
00378 
00379     /** Calls an event on the queue
00380      *  @see EventQueue::call
00381      */
00382     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
00383     int call(const volatile T *obj, R (T::*method)(A0, A1, A2, A3) const volatile, A0 a0, A1 a1, A2 a2, A3 a3) {
00384         return call(mbed::callback(obj, method), a0, a1, a2, a3);
00385     }
00386 
00387     /** Calls an event on the queue
00388      *  @see EventQueue::call
00389      */
00390     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
00391     int call(T *obj, R (T::*method)(A0, A1, A2, A3, A4), A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
00392         return call(mbed::callback(obj, method), a0, a1, a2, a3, a4);
00393     }
00394 
00395     /** Calls an event on the queue
00396      *  @see EventQueue::call
00397      */
00398     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
00399     int call(const T *obj, R (T::*method)(A0, A1, A2, A3, A4) const, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
00400         return call(mbed::callback(obj, method), a0, a1, a2, a3, a4);
00401     }
00402 
00403     /** Calls an event on the queue
00404      *  @see EventQueue::call
00405      */
00406     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
00407     int call(volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) volatile, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
00408         return call(mbed::callback(obj, method), a0, a1, a2, a3, a4);
00409     }
00410 
00411     /** Calls an event on the queue
00412      *  @see EventQueue::call
00413      */
00414     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
00415     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) {
00416         return call(mbed::callback(obj, method), a0, a1, a2, a3, a4);
00417     }
00418 
00419     /** Calls an event on the queue after a specified delay
00420      *
00421      *  The specified callback will be executed in the context of the event
00422      *  queue's dispatch loop.
00423      *
00424      *  The call_in function is irq safe and can act as a mechanism for moving
00425      *  events out of irq contexts.
00426      *
00427      *  @param f        Function to execute in the context of the dispatch loop
00428      *  @param a0..a4   Arguments to pass to the callback
00429      *  @param ms       Time to delay in milliseconds
00430      *  @return         A unique id that represents the posted event and can
00431      *                  be passed to cancel, or an id of 0 if there is not
00432      *                  enough memory to allocate the event.
00433      */
00434     template <typename F>
00435     int call_in(int ms, F f) {
00436         void *p = equeue_alloc(&_equeue, sizeof(F));
00437         if (!p) {
00438             return 0;
00439         }
00440 
00441         F *e = new (p) F(f);
00442         equeue_event_delay(e, ms);
00443         equeue_event_dtor(e, &EventQueue::function_dtor<F>);
00444         return equeue_post(&_equeue, &EventQueue::function_call<F>, e);
00445     }
00446 
00447     /** Calls an event on the queue after a specified delay
00448      *  @see EventQueue::call_in
00449      */
00450     template <typename F, typename A0>
00451     int call_in(int ms, F f, A0 a0) {
00452         return call_in(ms, context10<F, A0>(f, a0));
00453     }
00454 
00455     /** Calls an event on the queue after a specified delay
00456      *  @see EventQueue::call_in
00457      */
00458     template <typename F, typename A0, typename A1>
00459     int call_in(int ms, F f, A0 a0, A1 a1) {
00460         return call_in(ms, context20<F, A0, A1>(f, a0, a1));
00461     }
00462 
00463     /** Calls an event on the queue after a specified delay
00464      *  @see EventQueue::call_in
00465      */
00466     template <typename F, typename A0, typename A1, typename A2>
00467     int call_in(int ms, F f, A0 a0, A1 a1, A2 a2) {
00468         return call_in(ms, context30<F, A0, A1, A2>(f, a0, a1, a2));
00469     }
00470 
00471     /** Calls an event on the queue after a specified delay
00472      *  @see EventQueue::call_in
00473      */
00474     template <typename F, typename A0, typename A1, typename A2, typename A3>
00475     int call_in(int ms, F f, A0 a0, A1 a1, A2 a2, A3 a3) {
00476         return call_in(ms, context40<F, A0, A1, A2, A3>(f, a0, a1, a2, a3));
00477     }
00478 
00479     /** Calls an event on the queue after a specified delay
00480      *  @see EventQueue::call_in
00481      */
00482     template <typename F, typename A0, typename A1, typename A2, typename A3, typename A4>
00483     int call_in(int ms, F f, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
00484         return call_in(ms, context50<F, A0, A1, A2, A3, A4>(f, a0, a1, a2, a3, a4));
00485     }
00486 
00487     /** Calls an event on the queue after a specified delay
00488      *  @see EventQueue::call_in
00489      */
00490     template <typename T, typename R>
00491     int call_in(int ms, T *obj, R (T::*method)()) {
00492         return call_in(ms, mbed::callback(obj, method));
00493     }
00494 
00495     /** Calls an event on the queue after a specified delay
00496      *  @see EventQueue::call_in
00497      */
00498     template <typename T, typename R>
00499     int call_in(int ms, const T *obj, R (T::*method)() const) {
00500         return call_in(ms, mbed::callback(obj, method));
00501     }
00502 
00503     /** Calls an event on the queue after a specified delay
00504      *  @see EventQueue::call_in
00505      */
00506     template <typename T, typename R>
00507     int call_in(int ms, volatile T *obj, R (T::*method)() volatile) {
00508         return call_in(ms, mbed::callback(obj, method));
00509     }
00510 
00511     /** Calls an event on the queue after a specified delay
00512      *  @see EventQueue::call_in
00513      */
00514     template <typename T, typename R>
00515     int call_in(int ms, const volatile T *obj, R (T::*method)() const volatile) {
00516         return call_in(ms, mbed::callback(obj, method));
00517     }
00518 
00519     /** Calls an event on the queue after a specified delay
00520      *  @see EventQueue::call_in
00521      */
00522     template <typename T, typename R, typename A0>
00523     int call_in(int ms, T *obj, R (T::*method)(A0), A0 a0) {
00524         return call_in(ms, mbed::callback(obj, method), a0);
00525     }
00526 
00527     /** Calls an event on the queue after a specified delay
00528      *  @see EventQueue::call_in
00529      */
00530     template <typename T, typename R, typename A0>
00531     int call_in(int ms, const T *obj, R (T::*method)(A0) const, A0 a0) {
00532         return call_in(ms, mbed::callback(obj, method), a0);
00533     }
00534 
00535     /** Calls an event on the queue after a specified delay
00536      *  @see EventQueue::call_in
00537      */
00538     template <typename T, typename R, typename A0>
00539     int call_in(int ms, volatile T *obj, R (T::*method)(A0) volatile, A0 a0) {
00540         return call_in(ms, mbed::callback(obj, method), a0);
00541     }
00542 
00543     /** Calls an event on the queue after a specified delay
00544      *  @see EventQueue::call_in
00545      */
00546     template <typename T, typename R, typename A0>
00547     int call_in(int ms, const volatile T *obj, R (T::*method)(A0) const volatile, A0 a0) {
00548         return call_in(ms, mbed::callback(obj, method), a0);
00549     }
00550 
00551     /** Calls an event on the queue after a specified delay
00552      *  @see EventQueue::call_in
00553      */
00554     template <typename T, typename R, typename A0, typename A1>
00555     int call_in(int ms, T *obj, R (T::*method)(A0, A1), A0 a0, A1 a1) {
00556         return call_in(ms, mbed::callback(obj, method), a0, a1);
00557     }
00558 
00559     /** Calls an event on the queue after a specified delay
00560      *  @see EventQueue::call_in
00561      */
00562     template <typename T, typename R, typename A0, typename A1>
00563     int call_in(int ms, const T *obj, R (T::*method)(A0, A1) const, A0 a0, A1 a1) {
00564         return call_in(ms, mbed::callback(obj, method), a0, a1);
00565     }
00566 
00567     /** Calls an event on the queue after a specified delay
00568      *  @see EventQueue::call_in
00569      */
00570     template <typename T, typename R, typename A0, typename A1>
00571     int call_in(int ms, volatile T *obj, R (T::*method)(A0, A1) volatile, A0 a0, A1 a1) {
00572         return call_in(ms, mbed::callback(obj, method), a0, a1);
00573     }
00574 
00575     /** Calls an event on the queue after a specified delay
00576      *  @see EventQueue::call_in
00577      */
00578     template <typename T, typename R, typename A0, typename A1>
00579     int call_in(int ms, const volatile T *obj, R (T::*method)(A0, A1) const volatile, A0 a0, A1 a1) {
00580         return call_in(ms, mbed::callback(obj, method), a0, a1);
00581     }
00582 
00583     /** Calls an event on the queue after a specified delay
00584      *  @see EventQueue::call_in
00585      */
00586     template <typename T, typename R, typename A0, typename A1, typename A2>
00587     int call_in(int ms, T *obj, R (T::*method)(A0, A1, A2), A0 a0, A1 a1, A2 a2) {
00588         return call_in(ms, mbed::callback(obj, method), a0, a1, a2);
00589     }
00590 
00591     /** Calls an event on the queue after a specified delay
00592      *  @see EventQueue::call_in
00593      */
00594     template <typename T, typename R, typename A0, typename A1, typename A2>
00595     int call_in(int ms, const T *obj, R (T::*method)(A0, A1, A2) const, A0 a0, A1 a1, A2 a2) {
00596         return call_in(ms, mbed::callback(obj, method), a0, a1, a2);
00597     }
00598 
00599     /** Calls an event on the queue after a specified delay
00600      *  @see EventQueue::call_in
00601      */
00602     template <typename T, typename R, typename A0, typename A1, typename A2>
00603     int call_in(int ms, volatile T *obj, R (T::*method)(A0, A1, A2) volatile, A0 a0, A1 a1, A2 a2) {
00604         return call_in(ms, mbed::callback(obj, method), a0, a1, a2);
00605     }
00606 
00607     /** Calls an event on the queue after a specified delay
00608      *  @see EventQueue::call_in
00609      */
00610     template <typename T, typename R, typename A0, typename A1, typename A2>
00611     int call_in(int ms, const volatile T *obj, R (T::*method)(A0, A1, A2) const volatile, A0 a0, A1 a1, A2 a2) {
00612         return call_in(ms, mbed::callback(obj, method), a0, a1, a2);
00613     }
00614 
00615     /** Calls an event on the queue after a specified delay
00616      *  @see EventQueue::call_in
00617      */
00618     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
00619     int call_in(int ms, T *obj, R (T::*method)(A0, A1, A2, A3), A0 a0, A1 a1, A2 a2, A3 a3) {
00620         return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3);
00621     }
00622 
00623     /** Calls an event on the queue after a specified delay
00624      *  @see EventQueue::call_in
00625      */
00626     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
00627     int call_in(int ms, const T *obj, R (T::*method)(A0, A1, A2, A3) const, A0 a0, A1 a1, A2 a2, A3 a3) {
00628         return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3);
00629     }
00630 
00631     /** Calls an event on the queue after a specified delay
00632      *  @see EventQueue::call_in
00633      */
00634     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
00635     int call_in(int ms, volatile T *obj, R (T::*method)(A0, A1, A2, A3) volatile, A0 a0, A1 a1, A2 a2, A3 a3) {
00636         return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3);
00637     }
00638 
00639     /** Calls an event on the queue after a specified delay
00640      *  @see EventQueue::call_in
00641      */
00642     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
00643     int call_in(int ms, const volatile T *obj, R (T::*method)(A0, A1, A2, A3) const volatile, A0 a0, A1 a1, A2 a2, A3 a3) {
00644         return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3);
00645     }
00646 
00647     /** Calls an event on the queue after a specified delay
00648      *  @see EventQueue::call_in
00649      */
00650     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
00651     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) {
00652         return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4);
00653     }
00654 
00655     /** Calls an event on the queue after a specified delay
00656      *  @see EventQueue::call_in
00657      */
00658     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
00659     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) {
00660         return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4);
00661     }
00662 
00663     /** Calls an event on the queue after a specified delay
00664      *  @see EventQueue::call_in
00665      */
00666     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
00667     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) {
00668         return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4);
00669     }
00670 
00671     /** Calls an event on the queue after a specified delay
00672      *  @see EventQueue::call_in
00673      */
00674     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
00675     int call_in(int ms, const volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) const volatile, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
00676         return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4);
00677     }
00678 
00679     /** Calls an event on the queue periodically
00680      *
00681      *  The specified callback will be executed in the context of the event
00682      *  queue's dispatch loop.
00683      *
00684      *  The call_every function is irq safe and can act as a mechanism for
00685      *  moving events out of irq contexts.
00686      *
00687      *  @param f        Function to execute in the context of the dispatch loop
00688      *  @param a0..a4   Arguments to pass to the callback
00689      *  @param ms       Period of the event in milliseconds
00690      *  @return         A unique id that represents the posted event and can
00691      *                  be passed to cancel, or an id of 0 if there is not
00692      *                  enough memory to allocate the event.
00693      */
00694     template <typename F>
00695     int call_every(int ms, F f) {
00696         void *p = equeue_alloc(&_equeue, sizeof(F));
00697         if (!p) {
00698             return 0;
00699         }
00700 
00701         F *e = new (p) F(f);
00702         equeue_event_delay(e, ms);
00703         equeue_event_period(e, ms);
00704         equeue_event_dtor(e, &EventQueue::function_dtor<F>);
00705         return equeue_post(&_equeue, &EventQueue::function_call<F>, e);
00706     }
00707 
00708     /** Calls an event on the queue periodically
00709      *  @see EventQueue::call_every
00710      */
00711     template <typename F, typename A0>
00712     int call_every(int ms, F f, A0 a0) {
00713         return call_every(ms, context10<F, A0>(f, a0));
00714     }
00715 
00716     /** Calls an event on the queue periodically
00717      *  @see EventQueue::call_every
00718      */
00719     template <typename F, typename A0, typename A1>
00720     int call_every(int ms, F f, A0 a0, A1 a1) {
00721         return call_every(ms, context20<F, A0, A1>(f, a0, a1));
00722     }
00723 
00724     /** Calls an event on the queue periodically
00725      *  @see EventQueue::call_every
00726      */
00727     template <typename F, typename A0, typename A1, typename A2>
00728     int call_every(int ms, F f, A0 a0, A1 a1, A2 a2) {
00729         return call_every(ms, context30<F, A0, A1, A2>(f, a0, a1, a2));
00730     }
00731 
00732     /** Calls an event on the queue periodically
00733      *  @see EventQueue::call_every
00734      */
00735     template <typename F, typename A0, typename A1, typename A2, typename A3>
00736     int call_every(int ms, F f, A0 a0, A1 a1, A2 a2, A3 a3) {
00737         return call_every(ms, context40<F, A0, A1, A2, A3>(f, a0, a1, a2, a3));
00738     }
00739 
00740     /** Calls an event on the queue periodically
00741      *  @see EventQueue::call_every
00742      */
00743     template <typename F, typename A0, typename A1, typename A2, typename A3, typename A4>
00744     int call_every(int ms, F f, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
00745         return call_every(ms, context50<F, A0, A1, A2, A3, A4>(f, a0, a1, a2, a3, a4));
00746     }
00747 
00748     /** Calls an event on the queue periodically
00749      *  @see EventQueue::call_every
00750      */
00751     template <typename T, typename R>
00752     int call_every(int ms, T *obj, R (T::*method)()) {
00753         return call_every(ms, mbed::callback(obj, method));
00754     }
00755 
00756     /** Calls an event on the queue periodically
00757      *  @see EventQueue::call_every
00758      */
00759     template <typename T, typename R>
00760     int call_every(int ms, const T *obj, R (T::*method)() const) {
00761         return call_every(ms, mbed::callback(obj, method));
00762     }
00763 
00764     /** Calls an event on the queue periodically
00765      *  @see EventQueue::call_every
00766      */
00767     template <typename T, typename R>
00768     int call_every(int ms, volatile T *obj, R (T::*method)() volatile) {
00769         return call_every(ms, mbed::callback(obj, method));
00770     }
00771 
00772     /** Calls an event on the queue periodically
00773      *  @see EventQueue::call_every
00774      */
00775     template <typename T, typename R>
00776     int call_every(int ms, const volatile T *obj, R (T::*method)() const volatile) {
00777         return call_every(ms, mbed::callback(obj, method));
00778     }
00779 
00780     /** Calls an event on the queue periodically
00781      *  @see EventQueue::call_every
00782      */
00783     template <typename T, typename R, typename A0>
00784     int call_every(int ms, T *obj, R (T::*method)(A0), A0 a0) {
00785         return call_every(ms, mbed::callback(obj, method), a0);
00786     }
00787 
00788     /** Calls an event on the queue periodically
00789      *  @see EventQueue::call_every
00790      */
00791     template <typename T, typename R, typename A0>
00792     int call_every(int ms, const T *obj, R (T::*method)(A0) const, A0 a0) {
00793         return call_every(ms, mbed::callback(obj, method), a0);
00794     }
00795 
00796     /** Calls an event on the queue periodically
00797      *  @see EventQueue::call_every
00798      */
00799     template <typename T, typename R, typename A0>
00800     int call_every(int ms, volatile T *obj, R (T::*method)(A0) volatile, A0 a0) {
00801         return call_every(ms, mbed::callback(obj, method), a0);
00802     }
00803 
00804     /** Calls an event on the queue periodically
00805      *  @see EventQueue::call_every
00806      */
00807     template <typename T, typename R, typename A0>
00808     int call_every(int ms, const volatile T *obj, R (T::*method)(A0) const volatile, A0 a0) {
00809         return call_every(ms, mbed::callback(obj, method), a0);
00810     }
00811 
00812     /** Calls an event on the queue periodically
00813      *  @see EventQueue::call_every
00814      */
00815     template <typename T, typename R, typename A0, typename A1>
00816     int call_every(int ms, T *obj, R (T::*method)(A0, A1), A0 a0, A1 a1) {
00817         return call_every(ms, mbed::callback(obj, method), a0, a1);
00818     }
00819 
00820     /** Calls an event on the queue periodically
00821      *  @see EventQueue::call_every
00822      */
00823     template <typename T, typename R, typename A0, typename A1>
00824     int call_every(int ms, const T *obj, R (T::*method)(A0, A1) const, A0 a0, A1 a1) {
00825         return call_every(ms, mbed::callback(obj, method), a0, a1);
00826     }
00827 
00828     /** Calls an event on the queue periodically
00829      *  @see EventQueue::call_every
00830      */
00831     template <typename T, typename R, typename A0, typename A1>
00832     int call_every(int ms, volatile T *obj, R (T::*method)(A0, A1) volatile, A0 a0, A1 a1) {
00833         return call_every(ms, mbed::callback(obj, method), a0, a1);
00834     }
00835 
00836     /** Calls an event on the queue periodically
00837      *  @see EventQueue::call_every
00838      */
00839     template <typename T, typename R, typename A0, typename A1>
00840     int call_every(int ms, const volatile T *obj, R (T::*method)(A0, A1) const volatile, A0 a0, A1 a1) {
00841         return call_every(ms, mbed::callback(obj, method), a0, a1);
00842     }
00843 
00844     /** Calls an event on the queue periodically
00845      *  @see EventQueue::call_every
00846      */
00847     template <typename T, typename R, typename A0, typename A1, typename A2>
00848     int call_every(int ms, T *obj, R (T::*method)(A0, A1, A2), A0 a0, A1 a1, A2 a2) {
00849         return call_every(ms, mbed::callback(obj, method), a0, a1, a2);
00850     }
00851 
00852     /** Calls an event on the queue periodically
00853      *  @see EventQueue::call_every
00854      */
00855     template <typename T, typename R, typename A0, typename A1, typename A2>
00856     int call_every(int ms, const T *obj, R (T::*method)(A0, A1, A2) const, A0 a0, A1 a1, A2 a2) {
00857         return call_every(ms, mbed::callback(obj, method), a0, a1, a2);
00858     }
00859 
00860     /** Calls an event on the queue periodically
00861      *  @see EventQueue::call_every
00862      */
00863     template <typename T, typename R, typename A0, typename A1, typename A2>
00864     int call_every(int ms, volatile T *obj, R (T::*method)(A0, A1, A2) volatile, A0 a0, A1 a1, A2 a2) {
00865         return call_every(ms, mbed::callback(obj, method), a0, a1, a2);
00866     }
00867 
00868     /** Calls an event on the queue periodically
00869      *  @see EventQueue::call_every
00870      */
00871     template <typename T, typename R, typename A0, typename A1, typename A2>
00872     int call_every(int ms, const volatile T *obj, R (T::*method)(A0, A1, A2) const volatile, A0 a0, A1 a1, A2 a2) {
00873         return call_every(ms, mbed::callback(obj, method), a0, a1, a2);
00874     }
00875 
00876     /** Calls an event on the queue periodically
00877      *  @see EventQueue::call_every
00878      */
00879     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
00880     int call_every(int ms, T *obj, R (T::*method)(A0, A1, A2, A3), A0 a0, A1 a1, A2 a2, A3 a3) {
00881         return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3);
00882     }
00883 
00884     /** Calls an event on the queue periodically
00885      *  @see EventQueue::call_every
00886      */
00887     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
00888     int call_every(int ms, const T *obj, R (T::*method)(A0, A1, A2, A3) const, A0 a0, A1 a1, A2 a2, A3 a3) {
00889         return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3);
00890     }
00891 
00892     /** Calls an event on the queue periodically
00893      *  @see EventQueue::call_every
00894      */
00895     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
00896     int call_every(int ms, volatile T *obj, R (T::*method)(A0, A1, A2, A3) volatile, A0 a0, A1 a1, A2 a2, A3 a3) {
00897         return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3);
00898     }
00899 
00900     /** Calls an event on the queue periodically
00901      *  @see EventQueue::call_every
00902      */
00903     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
00904     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) {
00905         return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3);
00906     }
00907 
00908     /** Calls an event on the queue periodically
00909      *  @see EventQueue::call_every
00910      */
00911     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
00912     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) {
00913         return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4);
00914     }
00915 
00916     /** Calls an event on the queue periodically
00917      *  @see EventQueue::call_every
00918      */
00919     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
00920     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) {
00921         return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4);
00922     }
00923 
00924     /** Calls an event on the queue periodically
00925      *  @see EventQueue::call_every
00926      */
00927     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
00928     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) {
00929         return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4);
00930     }
00931 
00932     /** Calls an event on the queue periodically
00933      *  @see EventQueue::call_every
00934      */
00935     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
00936     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) {
00937         return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4);
00938     }
00939 
00940     /** Creates an event bound to the event queue
00941      *
00942      *  Constructs an event bound to the specified event queue. The specified
00943      *  callback acts as the target for the event and is executed in the
00944      *  context of the event queue's dispatch loop once posted.
00945      *
00946      *  @param f        Function to execute when the event is dispatched
00947      *  @param c0..c4   Arguments to bind to the callback, these arguments are
00948      *                  allocated on an irq-safe allocator from the event queue's
00949      *                  memory pool. Must be type-compatible with b0..b4, the
00950      *                  arguments to the underlying callback.
00951      *  @return         Event that will dispatch on the specific queue
00952      */
00953     template <typename R>
00954     Event<void()> event(R (*func)());
00955 
00956     /** Creates an event bound to the event queue
00957      *  @see EventQueue::event
00958      */
00959     template <typename T, typename R>
00960     Event<void()> event(T *obj, R (T::*method)());
00961 
00962     /** Creates an event bound to the event queue
00963      *  @see EventQueue::event
00964      */
00965     template <typename T, typename R>
00966     Event<void()> event(const T *obj, R (T::*method)() const);
00967 
00968     /** Creates an event bound to the event queue
00969      *  @see EventQueue::event
00970      */
00971     template <typename T, typename R>
00972     Event<void()> event(volatile T *obj, R (T::*method)() volatile);
00973 
00974     /** Creates an event bound to the event queue
00975      *  @see EventQueue::event
00976      */
00977     template <typename T, typename R>
00978     Event<void()> event(const volatile T *obj, R (T::*method)() const volatile);
00979 
00980     /** Creates an event bound to the event queue
00981      *  @see EventQueue::event
00982      */
00983     template <typename R>
00984     Event<void()> event(mbed::Callback<R()> cb);
00985 
00986     /** Creates an event bound to the event queue
00987      *  @see EventQueue::event
00988      */
00989     template <typename R, typename B0, typename C0>
00990     Event<void()> event(R (*func)(B0), C0 c0);
00991 
00992     /** Creates an event bound to the event queue
00993      *  @see EventQueue::event
00994      */
00995     template <typename T, typename R, typename B0, typename C0>
00996     Event<void()> event(T *obj, R (T::*method)(B0), C0 c0);
00997 
00998     /** Creates an event bound to the event queue
00999      *  @see EventQueue::event
01000      */
01001     template <typename T, typename R, typename B0, typename C0>
01002     Event<void()> event(const T *obj, R (T::*method)(B0) const, C0 c0);
01003 
01004     /** Creates an event bound to the event queue
01005      *  @see EventQueue::event
01006      */
01007     template <typename T, typename R, typename B0, typename C0>
01008     Event<void()> event(volatile T *obj, R (T::*method)(B0) volatile, C0 c0);
01009 
01010     /** Creates an event bound to the event queue
01011      *  @see EventQueue::event
01012      */
01013     template <typename T, typename R, typename B0, typename C0>
01014     Event<void()> event(const volatile T *obj, R (T::*method)(B0) const volatile, C0 c0);
01015 
01016     /** Creates an event bound to the event queue
01017      *  @see EventQueue::event
01018      */
01019     template <typename R, typename B0, typename C0>
01020     Event<void()> event(mbed::Callback<R(B0)> cb, C0 c0);
01021 
01022     /** Creates an event bound to the event queue
01023      *  @see EventQueue::event
01024      */
01025     template <typename R, typename B0, typename B1, typename C0, typename C1>
01026     Event<void()> event(R (*func)(B0, B1), C0 c0, C1 c1);
01027 
01028     /** Creates an event bound to the event queue
01029      *  @see EventQueue::event
01030      */
01031     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1>
01032     Event<void()> event(T *obj, R (T::*method)(B0, B1), C0 c0, C1 c1);
01033 
01034     /** Creates an event bound to the event queue
01035      *  @see EventQueue::event
01036      */
01037     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1>
01038     Event<void()> event(const T *obj, R (T::*method)(B0, B1) const, C0 c0, C1 c1);
01039 
01040     /** Creates an event bound to the event queue
01041      *  @see EventQueue::event
01042      */
01043     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1>
01044     Event<void()> event(volatile T *obj, R (T::*method)(B0, B1) volatile, C0 c0, C1 c1);
01045 
01046     /** Creates an event bound to the event queue
01047      *  @see EventQueue::event
01048      */
01049     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1>
01050     Event<void()> event(const volatile T *obj, R (T::*method)(B0, B1) const volatile, C0 c0, C1 c1);
01051 
01052     /** Creates an event bound to the event queue
01053      *  @see EventQueue::event
01054      */
01055     template <typename R, typename B0, typename B1, typename C0, typename C1>
01056     Event<void()> event(mbed::Callback<R(B0, B1)> cb, C0 c0, C1 c1);
01057 
01058     /** Creates an event bound to the event queue
01059      *  @see EventQueue::event
01060      */
01061     template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
01062     Event<void()> event(R (*func)(B0, B1, B2), C0 c0, C1 c1, C2 c2);
01063 
01064     /** Creates an event bound to the event queue
01065      *  @see EventQueue::event
01066      */
01067     template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
01068     Event<void()> event(T *obj, R (T::*method)(B0, B1, B2), C0 c0, C1 c1, C2 c2);
01069 
01070     /** Creates an event bound to the event queue
01071      *  @see EventQueue::event
01072      */
01073     template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
01074     Event<void()> event(const T *obj, R (T::*method)(B0, B1, B2) const, C0 c0, C1 c1, C2 c2);
01075 
01076     /** Creates an event bound to the event queue
01077      *  @see EventQueue::event
01078      */
01079     template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
01080     Event<void()> event(volatile T *obj, R (T::*method)(B0, B1, B2) volatile, C0 c0, C1 c1, C2 c2);
01081 
01082     /** Creates an event bound to the event queue
01083      *  @see EventQueue::event
01084      */
01085     template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
01086     Event<void()> event(const volatile T *obj, R (T::*method)(B0, B1, B2) const volatile, C0 c0, C1 c1, C2 c2);
01087 
01088     /** Creates an event bound to the event queue
01089      *  @see EventQueue::event
01090      */
01091     template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
01092     Event<void()> event(mbed::Callback<R(B0, B1, B2)> cb, C0 c0, C1 c1, C2 c2);
01093 
01094     /** Creates an event bound to the event queue
01095      *  @see EventQueue::event
01096      */
01097     template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
01098     Event<void()> event(R (*func)(B0, B1, B2, B3), C0 c0, C1 c1, C2 c2, C3 c3);
01099 
01100     /** Creates an event bound to the event queue
01101      *  @see EventQueue::event
01102      */
01103     template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
01104     Event<void()> event(T *obj, R (T::*method)(B0, B1, B2, B3), C0 c0, C1 c1, C2 c2, C3 c3);
01105 
01106     /** Creates an event bound to the event queue
01107      *  @see EventQueue::event
01108      */
01109     template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
01110     Event<void()> event(const T *obj, R (T::*method)(B0, B1, B2, B3) const, C0 c0, C1 c1, C2 c2, C3 c3);
01111 
01112     /** Creates an event bound to the event queue
01113      *  @see EventQueue::event
01114      */
01115     template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
01116     Event<void()> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3) volatile, C0 c0, C1 c1, C2 c2, C3 c3);
01117 
01118     /** Creates an event bound to the event queue
01119      *  @see EventQueue::event
01120      */
01121     template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
01122     Event<void()> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3) const volatile, C0 c0, C1 c1, C2 c2, C3 c3);
01123 
01124     /** Creates an event bound to the event queue
01125      *  @see EventQueue::event
01126      */
01127     template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
01128     Event<void()> event(mbed::Callback<R(B0, B1, B2, B3)> cb, C0 c0, C1 c1, C2 c2, C3 c3);
01129 
01130     /** Creates an event bound to the event queue
01131      *  @see EventQueue::event
01132      */
01133     template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4>
01134     Event<void()> event(R (*func)(B0, B1, B2, B3, B4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
01135 
01136     /** Creates an event bound to the event queue
01137      *  @see EventQueue::event
01138      */
01139     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>
01140     Event<void()> event(T *obj, R (T::*method)(B0, B1, B2, B3, B4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
01141 
01142     /** Creates an event bound to the event queue
01143      *  @see EventQueue::event
01144      */
01145     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>
01146     Event<void()> event(const T *obj, R (T::*method)(B0, B1, B2, B3, B4) const, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
01147 
01148     /** Creates an event bound to the event queue
01149      *  @see EventQueue::event
01150      */
01151     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>
01152     Event<void()> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4) volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
01153 
01154     /** Creates an event bound to the event queue
01155      *  @see EventQueue::event
01156      */
01157     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>
01158     Event<void()> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4) const volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
01159 
01160     /** Creates an event bound to the event queue
01161      *  @see EventQueue::event
01162      */
01163     template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4>
01164     Event<void()> event(mbed::Callback<R(B0, B1, B2, B3, B4)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
01165 
01166     /** Creates an event bound to the event queue
01167      *  @see EventQueue::event
01168      */
01169     template <typename R, typename A0>
01170     Event<void(A0)> event(R (*func)(A0));
01171 
01172     /** Creates an event bound to the event queue
01173      *  @see EventQueue::event
01174      */
01175     template <typename T, typename R, typename A0>
01176     Event<void(A0)> event(T *obj, R (T::*method)(A0));
01177 
01178     /** Creates an event bound to the event queue
01179      *  @see EventQueue::event
01180      */
01181     template <typename T, typename R, typename A0>
01182     Event<void(A0)> event(const T *obj, R (T::*method)(A0) const);
01183 
01184     /** Creates an event bound to the event queue
01185      *  @see EventQueue::event
01186      */
01187     template <typename T, typename R, typename A0>
01188     Event<void(A0)> event(volatile T *obj, R (T::*method)(A0) volatile);
01189 
01190     /** Creates an event bound to the event queue
01191      *  @see EventQueue::event
01192      */
01193     template <typename T, typename R, typename A0>
01194     Event<void(A0)> event(const volatile T *obj, R (T::*method)(A0) const volatile);
01195 
01196     /** Creates an event bound to the event queue
01197      *  @see EventQueue::event
01198      */
01199     template <typename R, typename A0>
01200     Event<void(A0)> event(mbed::Callback<R(A0)> cb);
01201 
01202     /** Creates an event bound to the event queue
01203      *  @see EventQueue::event
01204      */
01205     template <typename R, typename B0, typename C0, typename A0>
01206     Event<void(A0)> event(R (*func)(B0, A0), C0 c0);
01207 
01208     /** Creates an event bound to the event queue
01209      *  @see EventQueue::event
01210      */
01211     template <typename T, typename R, typename B0, typename C0, typename A0>
01212     Event<void(A0)> event(T *obj, R (T::*method)(B0, A0), C0 c0);
01213 
01214     /** Creates an event bound to the event queue
01215      *  @see EventQueue::event
01216      */
01217     template <typename T, typename R, typename B0, typename C0, typename A0>
01218     Event<void(A0)> event(const T *obj, R (T::*method)(B0, A0) const, C0 c0);
01219 
01220     /** Creates an event bound to the event queue
01221      *  @see EventQueue::event
01222      */
01223     template <typename T, typename R, typename B0, typename C0, typename A0>
01224     Event<void(A0)> event(volatile T *obj, R (T::*method)(B0, A0) volatile, C0 c0);
01225 
01226     /** Creates an event bound to the event queue
01227      *  @see EventQueue::event
01228      */
01229     template <typename T, typename R, typename B0, typename C0, typename A0>
01230     Event<void(A0)> event(const volatile T *obj, R (T::*method)(B0, A0) const volatile, C0 c0);
01231 
01232     /** Creates an event bound to the event queue
01233      *  @see EventQueue::event
01234      */
01235     template <typename R, typename B0, typename C0, typename A0>
01236     Event<void(A0)> event(mbed::Callback<R(B0, A0)> cb, C0 c0);
01237 
01238     /** Creates an event bound to the event queue
01239      *  @see EventQueue::event
01240      */
01241     template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
01242     Event<void(A0)> event(R (*func)(B0, B1, A0), C0 c0, C1 c1);
01243 
01244     /** Creates an event bound to the event queue
01245      *  @see EventQueue::event
01246      */
01247     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
01248     Event<void(A0)> event(T *obj, R (T::*method)(B0, B1, A0), C0 c0, C1 c1);
01249 
01250     /** Creates an event bound to the event queue
01251      *  @see EventQueue::event
01252      */
01253     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
01254     Event<void(A0)> event(const T *obj, R (T::*method)(B0, B1, A0) const, C0 c0, C1 c1);
01255 
01256     /** Creates an event bound to the event queue
01257      *  @see EventQueue::event
01258      */
01259     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
01260     Event<void(A0)> event(volatile T *obj, R (T::*method)(B0, B1, A0) volatile, C0 c0, C1 c1);
01261 
01262     /** Creates an event bound to the event queue
01263      *  @see EventQueue::event
01264      */
01265     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
01266     Event<void(A0)> event(const volatile T *obj, R (T::*method)(B0, B1, A0) const volatile, C0 c0, C1 c1);
01267 
01268     /** Creates an event bound to the event queue
01269      *  @see EventQueue::event
01270      */
01271     template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
01272     Event<void(A0)> event(mbed::Callback<R(B0, B1, A0)> cb, C0 c0, C1 c1);
01273 
01274     /** Creates an event bound to the event queue
01275      *  @see EventQueue::event
01276      */
01277     template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
01278     Event<void(A0)> event(R (*func)(B0, B1, B2, A0), C0 c0, C1 c1, C2 c2);
01279 
01280     /** Creates an event bound to the event queue
01281      *  @see EventQueue::event
01282      */
01283     template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
01284     Event<void(A0)> event(T *obj, R (T::*method)(B0, B1, B2, A0), C0 c0, C1 c1, C2 c2);
01285 
01286     /** Creates an event bound to the event queue
01287      *  @see EventQueue::event
01288      */
01289     template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
01290     Event<void(A0)> event(const T *obj, R (T::*method)(B0, B1, B2, A0) const, C0 c0, C1 c1, C2 c2);
01291 
01292     /** Creates an event bound to the event queue
01293      *  @see EventQueue::event
01294      */
01295     template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
01296     Event<void(A0)> event(volatile T *obj, R (T::*method)(B0, B1, B2, A0) volatile, C0 c0, C1 c1, C2 c2);
01297 
01298     /** Creates an event bound to the event queue
01299      *  @see EventQueue::event
01300      */
01301     template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
01302     Event<void(A0)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, A0) const volatile, C0 c0, C1 c1, C2 c2);
01303 
01304     /** Creates an event bound to the event queue
01305      *  @see EventQueue::event
01306      */
01307     template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
01308     Event<void(A0)> event(mbed::Callback<R(B0, B1, B2, A0)> cb, C0 c0, C1 c1, C2 c2);
01309 
01310     /** Creates an event bound to the event queue
01311      *  @see EventQueue::event
01312      */
01313     template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
01314     Event<void(A0)> event(R (*func)(B0, B1, B2, B3, A0), C0 c0, C1 c1, C2 c2, C3 c3);
01315 
01316     /** Creates an event bound to the event queue
01317      *  @see EventQueue::event
01318      */
01319     template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
01320     Event<void(A0)> event(T *obj, R (T::*method)(B0, B1, B2, B3, A0), C0 c0, C1 c1, C2 c2, C3 c3);
01321 
01322     /** Creates an event bound to the event queue
01323      *  @see EventQueue::event
01324      */
01325     template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
01326     Event<void(A0)> event(const T *obj, R (T::*method)(B0, B1, B2, B3, A0) const, C0 c0, C1 c1, C2 c2, C3 c3);
01327 
01328     /** Creates an event bound to the event queue
01329      *  @see EventQueue::event
01330      */
01331     template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
01332     Event<void(A0)> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0) volatile, C0 c0, C1 c1, C2 c2, C3 c3);
01333 
01334     /** Creates an event bound to the event queue
01335      *  @see EventQueue::event
01336      */
01337     template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
01338     Event<void(A0)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0) const volatile, C0 c0, C1 c1, C2 c2, C3 c3);
01339 
01340     /** Creates an event bound to the event queue
01341      *  @see EventQueue::event
01342      */
01343     template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
01344     Event<void(A0)> event(mbed::Callback<R(B0, B1, B2, B3, A0)> cb, C0 c0, C1 c1, C2 c2, C3 c3);
01345 
01346     /** Creates an event bound to the event queue
01347      *  @see EventQueue::event
01348      */
01349     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>
01350     Event<void(A0)> event(R (*func)(B0, B1, B2, B3, B4, A0), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
01351 
01352     /** Creates an event bound to the event queue
01353      *  @see EventQueue::event
01354      */
01355     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>
01356     Event<void(A0)> event(T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
01357 
01358     /** Creates an event bound to the event queue
01359      *  @see EventQueue::event
01360      */
01361     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>
01362     Event<void(A0)> event(const T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0) const, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
01363 
01364     /** Creates an event bound to the event queue
01365      *  @see EventQueue::event
01366      */
01367     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>
01368     Event<void(A0)> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0) volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
01369 
01370     /** Creates an event bound to the event queue
01371      *  @see EventQueue::event
01372      */
01373     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>
01374     Event<void(A0)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0) const volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
01375 
01376     /** Creates an event bound to the event queue
01377      *  @see EventQueue::event
01378      */
01379     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>
01380     Event<void(A0)> event(mbed::Callback<R(B0, B1, B2, B3, B4, A0)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
01381 
01382     /** Creates an event bound to the event queue
01383      *  @see EventQueue::event
01384      */
01385     template <typename R, typename A0, typename A1>
01386     Event<void(A0, A1)> event(R (*func)(A0, A1));
01387 
01388     /** Creates an event bound to the event queue
01389      *  @see EventQueue::event
01390      */
01391     template <typename T, typename R, typename A0, typename A1>
01392     Event<void(A0, A1)> event(T *obj, R (T::*method)(A0, A1));
01393 
01394     /** Creates an event bound to the event queue
01395      *  @see EventQueue::event
01396      */
01397     template <typename T, typename R, typename A0, typename A1>
01398     Event<void(A0, A1)> event(const T *obj, R (T::*method)(A0, A1) const);
01399 
01400     /** Creates an event bound to the event queue
01401      *  @see EventQueue::event
01402      */
01403     template <typename T, typename R, typename A0, typename A1>
01404     Event<void(A0, A1)> event(volatile T *obj, R (T::*method)(A0, A1) volatile);
01405 
01406     /** Creates an event bound to the event queue
01407      *  @see EventQueue::event
01408      */
01409     template <typename T, typename R, typename A0, typename A1>
01410     Event<void(A0, A1)> event(const volatile T *obj, R (T::*method)(A0, A1) const volatile);
01411 
01412     /** Creates an event bound to the event queue
01413      *  @see EventQueue::event
01414      */
01415     template <typename R, typename A0, typename A1>
01416     Event<void(A0, A1)> event(mbed::Callback<R(A0, A1)> cb);
01417 
01418     /** Creates an event bound to the event queue
01419      *  @see EventQueue::event
01420      */
01421     template <typename R, typename B0, typename C0, typename A0, typename A1>
01422     Event<void(A0, A1)> event(R (*func)(B0, A0, A1), C0 c0);
01423 
01424     /** Creates an event bound to the event queue
01425      *  @see EventQueue::event
01426      */
01427     template <typename T, typename R, typename B0, typename C0, typename A0, typename A1>
01428     Event<void(A0, A1)> event(T *obj, R (T::*method)(B0, A0, A1), C0 c0);
01429 
01430     /** Creates an event bound to the event queue
01431      *  @see EventQueue::event
01432      */
01433     template <typename T, typename R, typename B0, typename C0, typename A0, typename A1>
01434     Event<void(A0, A1)> event(const T *obj, R (T::*method)(B0, A0, A1) const, C0 c0);
01435 
01436     /** Creates an event bound to the event queue
01437      *  @see EventQueue::event
01438      */
01439     template <typename T, typename R, typename B0, typename C0, typename A0, typename A1>
01440     Event<void(A0, A1)> event(volatile T *obj, R (T::*method)(B0, A0, A1) volatile, C0 c0);
01441 
01442     /** Creates an event bound to the event queue
01443      *  @see EventQueue::event
01444      */
01445     template <typename T, typename R, typename B0, typename C0, typename A0, typename A1>
01446     Event<void(A0, A1)> event(const volatile T *obj, R (T::*method)(B0, A0, A1) const volatile, C0 c0);
01447 
01448     /** Creates an event bound to the event queue
01449      *  @see EventQueue::event
01450      */
01451     template <typename R, typename B0, typename C0, typename A0, typename A1>
01452     Event<void(A0, A1)> event(mbed::Callback<R(B0, A0, A1)> cb, C0 c0);
01453 
01454     /** Creates an event bound to the event queue
01455      *  @see EventQueue::event
01456      */
01457     template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
01458     Event<void(A0, A1)> event(R (*func)(B0, B1, A0, A1), C0 c0, C1 c1);
01459 
01460     /** Creates an event bound to the event queue
01461      *  @see EventQueue::event
01462      */
01463     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
01464     Event<void(A0, A1)> event(T *obj, R (T::*method)(B0, B1, A0, A1), C0 c0, C1 c1);
01465 
01466     /** Creates an event bound to the event queue
01467      *  @see EventQueue::event
01468      */
01469     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
01470     Event<void(A0, A1)> event(const T *obj, R (T::*method)(B0, B1, A0, A1) const, C0 c0, C1 c1);
01471 
01472     /** Creates an event bound to the event queue
01473      *  @see EventQueue::event
01474      */
01475     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
01476     Event<void(A0, A1)> event(volatile T *obj, R (T::*method)(B0, B1, A0, A1) volatile, C0 c0, C1 c1);
01477 
01478     /** Creates an event bound to the event queue
01479      *  @see EventQueue::event
01480      */
01481     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
01482     Event<void(A0, A1)> event(const volatile T *obj, R (T::*method)(B0, B1, A0, A1) const volatile, C0 c0, C1 c1);
01483 
01484     /** Creates an event bound to the event queue
01485      *  @see EventQueue::event
01486      */
01487     template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
01488     Event<void(A0, A1)> event(mbed::Callback<R(B0, B1, A0, A1)> cb, C0 c0, C1 c1);
01489 
01490     /** Creates an event bound to the event queue
01491      *  @see EventQueue::event
01492      */
01493     template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
01494     Event<void(A0, A1)> event(R (*func)(B0, B1, B2, A0, A1), C0 c0, C1 c1, C2 c2);
01495 
01496     /** Creates an event bound to the event queue
01497      *  @see EventQueue::event
01498      */
01499     template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
01500     Event<void(A0, A1)> event(T *obj, R (T::*method)(B0, B1, B2, A0, A1), C0 c0, C1 c1, C2 c2);
01501 
01502     /** Creates an event bound to the event queue
01503      *  @see EventQueue::event
01504      */
01505     template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
01506     Event<void(A0, A1)> event(const T *obj, R (T::*method)(B0, B1, B2, A0, A1) const, C0 c0, C1 c1, C2 c2);
01507 
01508     /** Creates an event bound to the event queue
01509      *  @see EventQueue::event
01510      */
01511     template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
01512     Event<void(A0, A1)> event(volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1) volatile, C0 c0, C1 c1, C2 c2);
01513 
01514     /** Creates an event bound to the event queue
01515      *  @see EventQueue::event
01516      */
01517     template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
01518     Event<void(A0, A1)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1) const volatile, C0 c0, C1 c1, C2 c2);
01519 
01520     /** Creates an event bound to the event queue
01521      *  @see EventQueue::event
01522      */
01523     template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
01524     Event<void(A0, A1)> event(mbed::Callback<R(B0, B1, B2, A0, A1)> cb, C0 c0, C1 c1, C2 c2);
01525 
01526     /** Creates an event bound to the event queue
01527      *  @see EventQueue::event
01528      */
01529     template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1>
01530     Event<void(A0, A1)> event(R (*func)(B0, B1, B2, B3, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3);
01531 
01532     /** Creates an event bound to the event queue
01533      *  @see EventQueue::event
01534      */
01535     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>
01536     Event<void(A0, A1)> event(T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3);
01537 
01538     /** Creates an event bound to the event queue
01539      *  @see EventQueue::event
01540      */
01541     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>
01542     Event<void(A0, A1)> event(const T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1) const, C0 c0, C1 c1, C2 c2, C3 c3);
01543 
01544     /** Creates an event bound to the event queue
01545      *  @see EventQueue::event
01546      */
01547     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>
01548     Event<void(A0, A1)> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1) volatile, C0 c0, C1 c1, C2 c2, C3 c3);
01549 
01550     /** Creates an event bound to the event queue
01551      *  @see EventQueue::event
01552      */
01553     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>
01554     Event<void(A0, A1)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1) const volatile, C0 c0, C1 c1, C2 c2, C3 c3);
01555 
01556     /** Creates an event bound to the event queue
01557      *  @see EventQueue::event
01558      */
01559     template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1>
01560     Event<void(A0, A1)> event(mbed::Callback<R(B0, B1, B2, B3, A0, A1)> cb, C0 c0, C1 c1, C2 c2, C3 c3);
01561 
01562     /** Creates an event bound to the event queue
01563      *  @see EventQueue::event
01564      */
01565     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>
01566     Event<void(A0, A1)> event(R (*func)(B0, B1, B2, B3, B4, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
01567 
01568     /** Creates an event bound to the event queue
01569      *  @see EventQueue::event
01570      */
01571     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>
01572     Event<void(A0, A1)> event(T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
01573 
01574     /** Creates an event bound to the event queue
01575      *  @see EventQueue::event
01576      */
01577     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>
01578     Event<void(A0, A1)> event(const T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1) const, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
01579 
01580     /** Creates an event bound to the event queue
01581      *  @see EventQueue::event
01582      */
01583     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>
01584     Event<void(A0, A1)> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1) volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
01585 
01586     /** Creates an event bound to the event queue
01587      *  @see EventQueue::event
01588      */
01589     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>
01590     Event<void(A0, A1)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1) const volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
01591 
01592     /** Creates an event bound to the event queue
01593      *  @see EventQueue::event
01594      */
01595     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>
01596     Event<void(A0, A1)> event(mbed::Callback<R(B0, B1, B2, B3, B4, A0, A1)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
01597 
01598     /** Creates an event bound to the event queue
01599      *  @see EventQueue::event
01600      */
01601     template <typename R, typename A0, typename A1, typename A2>
01602     Event<void(A0, A1, A2)> event(R (*func)(A0, A1, A2));
01603 
01604     /** Creates an event bound to the event queue
01605      *  @see EventQueue::event
01606      */
01607     template <typename T, typename R, typename A0, typename A1, typename A2>
01608     Event<void(A0, A1, A2)> event(T *obj, R (T::*method)(A0, A1, A2));
01609 
01610     /** Creates an event bound to the event queue
01611      *  @see EventQueue::event
01612      */
01613     template <typename T, typename R, typename A0, typename A1, typename A2>
01614     Event<void(A0, A1, A2)> event(const T *obj, R (T::*method)(A0, A1, A2) const);
01615 
01616     /** Creates an event bound to the event queue
01617      *  @see EventQueue::event
01618      */
01619     template <typename T, typename R, typename A0, typename A1, typename A2>
01620     Event<void(A0, A1, A2)> event(volatile T *obj, R (T::*method)(A0, A1, A2) volatile);
01621 
01622     /** Creates an event bound to the event queue
01623      *  @see EventQueue::event
01624      */
01625     template <typename T, typename R, typename A0, typename A1, typename A2>
01626     Event<void(A0, A1, A2)> event(const volatile T *obj, R (T::*method)(A0, A1, A2) const volatile);
01627 
01628     /** Creates an event bound to the event queue
01629      *  @see EventQueue::event
01630      */
01631     template <typename R, typename A0, typename A1, typename A2>
01632     Event<void(A0, A1, A2)> event(mbed::Callback<R(A0, A1, A2)> cb);
01633 
01634     /** Creates an event bound to the event queue
01635      *  @see EventQueue::event
01636      */
01637     template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
01638     Event<void(A0, A1, A2)> event(R (*func)(B0, A0, A1, A2), C0 c0);
01639 
01640     /** Creates an event bound to the event queue
01641      *  @see EventQueue::event
01642      */
01643     template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
01644     Event<void(A0, A1, A2)> event(T *obj, R (T::*method)(B0, A0, A1, A2), C0 c0);
01645 
01646     /** Creates an event bound to the event queue
01647      *  @see EventQueue::event
01648      */
01649     template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
01650     Event<void(A0, A1, A2)> event(const T *obj, R (T::*method)(B0, A0, A1, A2) const, C0 c0);
01651 
01652     /** Creates an event bound to the event queue
01653      *  @see EventQueue::event
01654      */
01655     template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
01656     Event<void(A0, A1, A2)> event(volatile T *obj, R (T::*method)(B0, A0, A1, A2) volatile, C0 c0);
01657 
01658     /** Creates an event bound to the event queue
01659      *  @see EventQueue::event
01660      */
01661     template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
01662     Event<void(A0, A1, A2)> event(const volatile T *obj, R (T::*method)(B0, A0, A1, A2) const volatile, C0 c0);
01663 
01664     /** Creates an event bound to the event queue
01665      *  @see EventQueue::event
01666      */
01667     template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
01668     Event<void(A0, A1, A2)> event(mbed::Callback<R(B0, A0, A1, A2)> cb, C0 c0);
01669 
01670     /** Creates an event bound to the event queue
01671      *  @see EventQueue::event
01672      */
01673     template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
01674     Event<void(A0, A1, A2)> event(R (*func)(B0, B1, A0, A1, A2), C0 c0, C1 c1);
01675 
01676     /** Creates an event bound to the event queue
01677      *  @see EventQueue::event
01678      */
01679     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
01680     Event<void(A0, A1, A2)> event(T *obj, R (T::*method)(B0, B1, A0, A1, A2), C0 c0, C1 c1);
01681 
01682     /** Creates an event bound to the event queue
01683      *  @see EventQueue::event
01684      */
01685     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
01686     Event<void(A0, A1, A2)> event(const T *obj, R (T::*method)(B0, B1, A0, A1, A2) const, C0 c0, C1 c1);
01687 
01688     /** Creates an event bound to the event queue
01689      *  @see EventQueue::event
01690      */
01691     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
01692     Event<void(A0, A1, A2)> event(volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2) volatile, C0 c0, C1 c1);
01693 
01694     /** Creates an event bound to the event queue
01695      *  @see EventQueue::event
01696      */
01697     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
01698     Event<void(A0, A1, A2)> event(const volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2) const volatile, C0 c0, C1 c1);
01699 
01700     /** Creates an event bound to the event queue
01701      *  @see EventQueue::event
01702      */
01703     template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
01704     Event<void(A0, A1, A2)> event(mbed::Callback<R(B0, B1, A0, A1, A2)> cb, C0 c0, C1 c1);
01705 
01706     /** Creates an event bound to the event queue
01707      *  @see EventQueue::event
01708      */
01709     template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
01710     Event<void(A0, A1, A2)> event(R (*func)(B0, B1, B2, A0, A1, A2), C0 c0, C1 c1, C2 c2);
01711 
01712     /** Creates an event bound to the event queue
01713      *  @see EventQueue::event
01714      */
01715     template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
01716     Event<void(A0, A1, A2)> event(T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2), C0 c0, C1 c1, C2 c2);
01717 
01718     /** Creates an event bound to the event queue
01719      *  @see EventQueue::event
01720      */
01721     template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
01722     Event<void(A0, A1, A2)> event(const T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2) const, C0 c0, C1 c1, C2 c2);
01723 
01724     /** Creates an event bound to the event queue
01725      *  @see EventQueue::event
01726      */
01727     template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
01728     Event<void(A0, A1, A2)> event(volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2) volatile, C0 c0, C1 c1, C2 c2);
01729 
01730     /** Creates an event bound to the event queue
01731      *  @see EventQueue::event
01732      */
01733     template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
01734     Event<void(A0, A1, A2)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2) const volatile, C0 c0, C1 c1, C2 c2);
01735 
01736     /** Creates an event bound to the event queue
01737      *  @see EventQueue::event
01738      */
01739     template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
01740     Event<void(A0, A1, A2)> event(mbed::Callback<R(B0, B1, B2, A0, A1, A2)> cb, C0 c0, C1 c1, C2 c2);
01741 
01742     /** Creates an event bound to the event queue
01743      *  @see EventQueue::event
01744      */
01745     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>
01746     Event<void(A0, A1, A2)> event(R (*func)(B0, B1, B2, B3, A0, A1, A2), C0 c0, C1 c1, C2 c2, C3 c3);
01747 
01748     /** Creates an event bound to the event queue
01749      *  @see EventQueue::event
01750      */
01751     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>
01752     Event<void(A0, A1, A2)> event(T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2), C0 c0, C1 c1, C2 c2, C3 c3);
01753 
01754     /** Creates an event bound to the event queue
01755      *  @see EventQueue::event
01756      */
01757     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>
01758     Event<void(A0, A1, A2)> event(const T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2) const, C0 c0, C1 c1, C2 c2, C3 c3);
01759 
01760     /** Creates an event bound to the event queue
01761      *  @see EventQueue::event
01762      */
01763     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>
01764     Event<void(A0, A1, A2)> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2) volatile, C0 c0, C1 c1, C2 c2, C3 c3);
01765 
01766     /** Creates an event bound to the event queue
01767      *  @see EventQueue::event
01768      */
01769     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>
01770     Event<void(A0, A1, A2)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2) const volatile, C0 c0, C1 c1, C2 c2, C3 c3);
01771 
01772     /** Creates an event bound to the event queue
01773      *  @see EventQueue::event
01774      */
01775     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>
01776     Event<void(A0, A1, A2)> event(mbed::Callback<R(B0, B1, B2, B3, A0, A1, A2)> cb, C0 c0, C1 c1, C2 c2, C3 c3);
01777 
01778     /** Creates an event bound to the event queue
01779      *  @see EventQueue::event
01780      */
01781     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>
01782     Event<void(A0, A1, A2)> event(R (*func)(B0, B1, B2, B3, B4, A0, A1, A2), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
01783 
01784     /** Creates an event bound to the event queue
01785      *  @see EventQueue::event
01786      */
01787     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>
01788     Event<void(A0, A1, A2)> event(T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
01789 
01790     /** Creates an event bound to the event queue
01791      *  @see EventQueue::event
01792      */
01793     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>
01794     Event<void(A0, A1, A2)> event(const T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2) const, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
01795 
01796     /** Creates an event bound to the event queue
01797      *  @see EventQueue::event
01798      */
01799     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>
01800     Event<void(A0, A1, A2)> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2) volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
01801 
01802     /** Creates an event bound to the event queue
01803      *  @see EventQueue::event
01804      */
01805     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>
01806     Event<void(A0, A1, A2)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2) const volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
01807 
01808     /** Creates an event bound to the event queue
01809      *  @see EventQueue::event
01810      */
01811     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>
01812     Event<void(A0, A1, A2)> event(mbed::Callback<R(B0, B1, B2, B3, B4, A0, A1, A2)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
01813 
01814     /** Creates an event bound to the event queue
01815      *  @see EventQueue::event
01816      */
01817     template <typename R, typename A0, typename A1, typename A2, typename A3>
01818     Event<void(A0, A1, A2, A3)> event(R (*func)(A0, A1, A2, A3));
01819 
01820     /** Creates an event bound to the event queue
01821      *  @see EventQueue::event
01822      */
01823     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
01824     Event<void(A0, A1, A2, A3)> event(T *obj, R (T::*method)(A0, A1, A2, A3));
01825 
01826     /** Creates an event bound to the event queue
01827      *  @see EventQueue::event
01828      */
01829     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
01830     Event<void(A0, A1, A2, A3)> event(const T *obj, R (T::*method)(A0, A1, A2, A3) const);
01831 
01832     /** Creates an event bound to the event queue
01833      *  @see EventQueue::event
01834      */
01835     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
01836     Event<void(A0, A1, A2, A3)> event(volatile T *obj, R (T::*method)(A0, A1, A2, A3) volatile);
01837 
01838     /** Creates an event bound to the event queue
01839      *  @see EventQueue::event
01840      */
01841     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
01842     Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R (T::*method)(A0, A1, A2, A3) const volatile);
01843 
01844     /** Creates an event bound to the event queue
01845      *  @see EventQueue::event
01846      */
01847     template <typename R, typename A0, typename A1, typename A2, typename A3>
01848     Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(A0, A1, A2, A3)> cb);
01849 
01850     /** Creates an event bound to the event queue
01851      *  @see EventQueue::event
01852      */
01853     template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
01854     Event<void(A0, A1, A2, A3)> event(R (*func)(B0, A0, A1, A2, A3), C0 c0);
01855 
01856     /** Creates an event bound to the event queue
01857      *  @see EventQueue::event
01858      */
01859     template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
01860     Event<void(A0, A1, A2, A3)> event(T *obj, R (T::*method)(B0, A0, A1, A2, A3), C0 c0);
01861 
01862     /** Creates an event bound to the event queue
01863      *  @see EventQueue::event
01864      */
01865     template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
01866     Event<void(A0, A1, A2, A3)> event(const T *obj, R (T::*method)(B0, A0, A1, A2, A3) const, C0 c0);
01867 
01868     /** Creates an event bound to the event queue
01869      *  @see EventQueue::event
01870      */
01871     template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
01872     Event<void(A0, A1, A2, A3)> event(volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3) volatile, C0 c0);
01873 
01874     /** Creates an event bound to the event queue
01875      *  @see EventQueue::event
01876      */
01877     template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
01878     Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3) const volatile, C0 c0);
01879 
01880     /** Creates an event bound to the event queue
01881      *  @see EventQueue::event
01882      */
01883     template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
01884     Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(B0, A0, A1, A2, A3)> cb, C0 c0);
01885 
01886     /** Creates an event bound to the event queue
01887      *  @see EventQueue::event
01888      */
01889     template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
01890     Event<void(A0, A1, A2, A3)> event(R (*func)(B0, B1, A0, A1, A2, A3), C0 c0, C1 c1);
01891 
01892     /** Creates an event bound to the event queue
01893      *  @see EventQueue::event
01894      */
01895     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
01896     Event<void(A0, A1, A2, A3)> event(T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3), C0 c0, C1 c1);
01897 
01898     /** Creates an event bound to the event queue
01899      *  @see EventQueue::event
01900      */
01901     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
01902     Event<void(A0, A1, A2, A3)> event(const T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3) const, C0 c0, C1 c1);
01903 
01904     /** Creates an event bound to the event queue
01905      *  @see EventQueue::event
01906      */
01907     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
01908     Event<void(A0, A1, A2, A3)> event(volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3) volatile, C0 c0, C1 c1);
01909 
01910     /** Creates an event bound to the event queue
01911      *  @see EventQueue::event
01912      */
01913     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
01914     Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3) const volatile, C0 c0, C1 c1);
01915 
01916     /** Creates an event bound to the event queue
01917      *  @see EventQueue::event
01918      */
01919     template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
01920     Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(B0, B1, A0, A1, A2, A3)> cb, C0 c0, C1 c1);
01921 
01922     /** Creates an event bound to the event queue
01923      *  @see EventQueue::event
01924      */
01925     template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3>
01926     Event<void(A0, A1, A2, A3)> event(R (*func)(B0, B1, B2, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2);
01927 
01928     /** Creates an event bound to the event queue
01929      *  @see EventQueue::event
01930      */
01931     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>
01932     Event<void(A0, A1, A2, A3)> event(T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2);
01933 
01934     /** Creates an event bound to the event queue
01935      *  @see EventQueue::event
01936      */
01937     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>
01938     Event<void(A0, A1, A2, A3)> event(const T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3) const, C0 c0, C1 c1, C2 c2);
01939 
01940     /** Creates an event bound to the event queue
01941      *  @see EventQueue::event
01942      */
01943     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>
01944     Event<void(A0, A1, A2, A3)> event(volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3) volatile, C0 c0, C1 c1, C2 c2);
01945 
01946     /** Creates an event bound to the event queue
01947      *  @see EventQueue::event
01948      */
01949     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>
01950     Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3) const volatile, C0 c0, C1 c1, C2 c2);
01951 
01952     /** Creates an event bound to the event queue
01953      *  @see EventQueue::event
01954      */
01955     template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3>
01956     Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(B0, B1, B2, A0, A1, A2, A3)> cb, C0 c0, C1 c1, C2 c2);
01957 
01958     /** Creates an event bound to the event queue
01959      *  @see EventQueue::event
01960      */
01961     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>
01962     Event<void(A0, A1, A2, A3)> event(R (*func)(B0, B1, B2, B3, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2, C3 c3);
01963 
01964     /** Creates an event bound to the event queue
01965      *  @see EventQueue::event
01966      */
01967     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>
01968     Event<void(A0, A1, A2, A3)> event(T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2, C3 c3);
01969 
01970     /** Creates an event bound to the event queue
01971      *  @see EventQueue::event
01972      */
01973     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>
01974     Event<void(A0, A1, A2, A3)> event(const T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3) const, C0 c0, C1 c1, C2 c2, C3 c3);
01975 
01976     /** Creates an event bound to the event queue
01977      *  @see EventQueue::event
01978      */
01979     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>
01980     Event<void(A0, A1, A2, A3)> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3) volatile, C0 c0, C1 c1, C2 c2, C3 c3);
01981 
01982     /** Creates an event bound to the event queue
01983      *  @see EventQueue::event
01984      */
01985     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>
01986     Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3) const volatile, C0 c0, C1 c1, C2 c2, C3 c3);
01987 
01988     /** Creates an event bound to the event queue
01989      *  @see EventQueue::event
01990      */
01991     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>
01992     Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(B0, B1, B2, B3, A0, A1, A2, A3)> cb, C0 c0, C1 c1, C2 c2, C3 c3);
01993 
01994     /** Creates an event bound to the event queue
01995      *  @see EventQueue::event
01996      */
01997     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>
01998     Event<void(A0, A1, A2, A3)> event(R (*func)(B0, B1, B2, B3, B4, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
01999 
02000     /** Creates an event bound to the event queue
02001      *  @see EventQueue::event
02002      */
02003     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>
02004     Event<void(A0, A1, A2, A3)> event(T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
02005 
02006     /** Creates an event bound to the event queue
02007      *  @see EventQueue::event
02008      */
02009     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>
02010     Event<void(A0, A1, A2, A3)> event(const T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3) const, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
02011 
02012     /** Creates an event bound to the event queue
02013      *  @see EventQueue::event
02014      */
02015     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>
02016     Event<void(A0, A1, A2, A3)> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3) volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
02017 
02018     /** Creates an event bound to the event queue
02019      *  @see EventQueue::event
02020      */
02021     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>
02022     Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3) const volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
02023 
02024     /** Creates an event bound to the event queue
02025      *  @see EventQueue::event
02026      */
02027     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>
02028     Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(B0, B1, B2, B3, B4, A0, A1, A2, A3)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
02029 
02030     /** Creates an event bound to the event queue
02031      *  @see EventQueue::event
02032      */
02033     template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
02034     Event<void(A0, A1, A2, A3, A4)> event(R (*func)(A0, A1, A2, A3, A4));
02035 
02036     /** Creates an event bound to the event queue
02037      *  @see EventQueue::event
02038      */
02039     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
02040     Event<void(A0, A1, A2, A3, A4)> event(T *obj, R (T::*method)(A0, A1, A2, A3, A4));
02041 
02042     /** Creates an event bound to the event queue
02043      *  @see EventQueue::event
02044      */
02045     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
02046     Event<void(A0, A1, A2, A3, A4)> event(const T *obj, R (T::*method)(A0, A1, A2, A3, A4) const);
02047 
02048     /** Creates an event bound to the event queue
02049      *  @see EventQueue::event
02050      */
02051     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
02052     Event<void(A0, A1, A2, A3, A4)> event(volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) volatile);
02053 
02054     /** Creates an event bound to the event queue
02055      *  @see EventQueue::event
02056      */
02057     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
02058     Event<void(A0, A1, A2, A3, A4)> event(const volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) const volatile);
02059 
02060     /** Creates an event bound to the event queue
02061      *  @see EventQueue::event
02062      */
02063     template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
02064     Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(A0, A1, A2, A3, A4)> cb);
02065 
02066     /** Creates an event bound to the event queue
02067      *  @see EventQueue::event
02068      */
02069     template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
02070     Event<void(A0, A1, A2, A3, A4)> event(R (*func)(B0, A0, A1, A2, A3, A4), C0 c0);
02071 
02072     /** Creates an event bound to the event queue
02073      *  @see EventQueue::event
02074      */
02075     template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
02076     Event<void(A0, A1, A2, A3, A4)> event(T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4), C0 c0);
02077 
02078     /** Creates an event bound to the event queue
02079      *  @see EventQueue::event
02080      */
02081     template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
02082     Event<void(A0, A1, A2, A3, A4)> event(const T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4) const, C0 c0);
02083 
02084     /** Creates an event bound to the event queue
02085      *  @see EventQueue::event
02086      */
02087     template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
02088     Event<void(A0, A1, A2, A3, A4)> event(volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4) volatile, C0 c0);
02089 
02090     /** Creates an event bound to the event queue
02091      *  @see EventQueue::event
02092      */
02093     template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
02094     Event<void(A0, A1, A2, A3, A4)> event(const volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4) const volatile, C0 c0);
02095 
02096     /** Creates an event bound to the event queue
02097      *  @see EventQueue::event
02098      */
02099     template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
02100     Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(B0, A0, A1, A2, A3, A4)> cb, C0 c0);
02101 
02102     /** Creates an event bound to the event queue
02103      *  @see EventQueue::event
02104      */
02105     template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
02106     Event<void(A0, A1, A2, A3, A4)> event(R (*func)(B0, B1, A0, A1, A2, A3, A4), C0 c0, C1 c1);
02107 
02108     /** Creates an event bound to the event queue
02109      *  @see EventQueue::event
02110      */
02111     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
02112     Event<void(A0, A1, A2, A3, A4)> event(T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3, A4), C0 c0, C1 c1);
02113 
02114     /** Creates an event bound to the event queue
02115      *  @see EventQueue::event
02116      */
02117     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
02118     Event<void(A0, A1, A2, A3, A4)> event(const T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3, A4) const, C0 c0, C1 c1);
02119 
02120     /** Creates an event bound to the event queue
02121      *  @see EventQueue::event
02122      */
02123     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
02124     Event<void(A0, A1, A2, A3, A4)> event(volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3, A4) volatile, C0 c0, C1 c1);
02125 
02126     /** Creates an event bound to the event queue
02127      *  @see EventQueue::event
02128      */
02129     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
02130     Event<void(A0, A1, A2, A3, A4)> event(const volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3, A4) const volatile, C0 c0, C1 c1);
02131 
02132     /** Creates an event bound to the event queue
02133      *  @see EventQueue::event
02134      */
02135     template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
02136     Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(B0, B1, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1);
02137 
02138     /** Creates an event bound to the event queue
02139      *  @see EventQueue::event
02140      */
02141     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>
02142     Event<void(A0, A1, A2, A3, A4)> event(R (*func)(B0, B1, B2, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2);
02143 
02144     /** Creates an event bound to the event queue
02145      *  @see EventQueue::event
02146      */
02147     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>
02148     Event<void(A0, A1, A2, A3, A4)> event(T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2);
02149 
02150     /** Creates an event bound to the event queue
02151      *  @see EventQueue::event
02152      */
02153     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>
02154     Event<void(A0, A1, A2, A3, A4)> event(const T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3, A4) const, C0 c0, C1 c1, C2 c2);
02155 
02156     /** Creates an event bound to the event queue
02157      *  @see EventQueue::event
02158      */
02159     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>
02160     Event<void(A0, A1, A2, A3, A4)> event(volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3, A4) volatile, C0 c0, C1 c1, C2 c2);
02161 
02162     /** Creates an event bound to the event queue
02163      *  @see EventQueue::event
02164      */
02165     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>
02166     Event<void(A0, A1, A2, A3, A4)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3, A4) const volatile, C0 c0, C1 c1, C2 c2);
02167 
02168     /** Creates an event bound to the event queue
02169      *  @see EventQueue::event
02170      */
02171     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>
02172     Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(B0, B1, B2, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1, C2 c2);
02173 
02174     /** Creates an event bound to the event queue
02175      *  @see EventQueue::event
02176      */
02177     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>
02178     Event<void(A0, A1, A2, A3, A4)> event(R (*func)(B0, B1, B2, B3, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2, C3 c3);
02179 
02180     /** Creates an event bound to the event queue
02181      *  @see EventQueue::event
02182      */
02183     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>
02184     Event<void(A0, A1, A2, A3, A4)> event(T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2, C3 c3);
02185 
02186     /** Creates an event bound to the event queue
02187      *  @see EventQueue::event
02188      */
02189     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>
02190     Event<void(A0, A1, A2, A3, A4)> event(const T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3, A4) const, C0 c0, C1 c1, C2 c2, C3 c3);
02191 
02192     /** Creates an event bound to the event queue
02193      *  @see EventQueue::event
02194      */
02195     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>
02196     Event<void(A0, A1, A2, A3, A4)> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3, A4) volatile, C0 c0, C1 c1, C2 c2, C3 c3);
02197 
02198     /** Creates an event bound to the event queue
02199      *  @see EventQueue::event
02200      */
02201     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>
02202     Event<void(A0, A1, A2, A3, A4)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3, A4) const volatile, C0 c0, C1 c1, C2 c2, C3 c3);
02203 
02204     /** Creates an event bound to the event queue
02205      *  @see EventQueue::event
02206      */
02207     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>
02208     Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(B0, B1, B2, B3, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1, C2 c2, C3 c3);
02209 
02210     /** Creates an event bound to the event queue
02211      *  @see EventQueue::event
02212      */
02213     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>
02214     Event<void(A0, A1, A2, A3, A4)> event(R (*func)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
02215 
02216     /** Creates an event bound to the event queue
02217      *  @see EventQueue::event
02218      */
02219     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>
02220     Event<void(A0, A1, A2, A3, A4)> event(T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
02221 
02222     /** Creates an event bound to the event queue
02223      *  @see EventQueue::event
02224      */
02225     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>
02226     Event<void(A0, A1, A2, A3, A4)> event(const T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4) const, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
02227 
02228     /** Creates an event bound to the event queue
02229      *  @see EventQueue::event
02230      */
02231     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>
02232     Event<void(A0, A1, A2, A3, A4)> event(volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4) volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
02233 
02234     /** Creates an event bound to the event queue
02235      *  @see EventQueue::event
02236      */
02237     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>
02238     Event<void(A0, A1, A2, A3, A4)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4) const volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
02239 
02240     /** Creates an event bound to the event queue
02241      *  @see EventQueue::event
02242      */
02243     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>
02244     Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
02245 
02246 protected:
02247     template <typename F>
02248     friend class Event;
02249     struct equeue _equeue;
02250     mbed::Callback<void(int)> _update;
02251 
02252     // Function attributes
02253     template <typename F>
02254     static void function_call(void *p) {
02255         (*(F*)p)();
02256     }
02257 
02258     template <typename F>
02259     static void function_dtor(void *p) {
02260         ((F*)p)->~F();
02261     }
02262 
02263     // Context structures
02264     template <typename F>
02265     struct context00 {
02266         F f;
02267 
02268         context00(F f)
02269             : f(f) {}
02270 
02271         void operator()() {
02272             f();
02273         }
02274     };
02275 
02276     template <typename F, typename C0>
02277     struct context10 {
02278         F f; C0 c0;
02279 
02280         context10(F f, C0 c0)
02281             : f(f), c0(c0) {}
02282 
02283         void operator()() {
02284             f(c0);
02285         }
02286     };
02287 
02288     template <typename F, typename C0, typename C1>
02289     struct context20 {
02290         F f; C0 c0; C1 c1;
02291 
02292         context20(F f, C0 c0, C1 c1)
02293             : f(f), c0(c0), c1(c1) {}
02294 
02295         void operator()() {
02296             f(c0, c1);
02297         }
02298     };
02299 
02300     template <typename F, typename C0, typename C1, typename C2>
02301     struct context30 {
02302         F f; C0 c0; C1 c1; C2 c2;
02303 
02304         context30(F f, C0 c0, C1 c1, C2 c2)
02305             : f(f), c0(c0), c1(c1), c2(c2) {}
02306 
02307         void operator()() {
02308             f(c0, c1, c2);
02309         }
02310     };
02311 
02312     template <typename F, typename C0, typename C1, typename C2, typename C3>
02313     struct context40 {
02314         F f; C0 c0; C1 c1; C2 c2; C3 c3;
02315 
02316         context40(F f, C0 c0, C1 c1, C2 c2, C3 c3)
02317             : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {}
02318 
02319         void operator()() {
02320             f(c0, c1, c2, c3);
02321         }
02322     };
02323 
02324     template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4>
02325     struct context50 {
02326         F f; C0 c0; C1 c1; C2 c2; C3 c3; C4 c4;
02327 
02328         context50(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
02329             : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {}
02330 
02331         void operator()() {
02332             f(c0, c1, c2, c3, c4);
02333         }
02334     };
02335 
02336     template <typename F, typename A0>
02337     struct context01 {
02338         F f;
02339 
02340         context01(F f)
02341             : f(f) {}
02342 
02343         void operator()(A0 a0) {
02344             f(a0);
02345         }
02346     };
02347 
02348     template <typename F, typename C0, typename A0>
02349     struct context11 {
02350         F f; C0 c0;
02351 
02352         context11(F f, C0 c0)
02353             : f(f), c0(c0) {}
02354 
02355         void operator()(A0 a0) {
02356             f(c0, a0);
02357         }
02358     };
02359 
02360     template <typename F, typename C0, typename C1, typename A0>
02361     struct context21 {
02362         F f; C0 c0; C1 c1;
02363 
02364         context21(F f, C0 c0, C1 c1)
02365             : f(f), c0(c0), c1(c1) {}
02366 
02367         void operator()(A0 a0) {
02368             f(c0, c1, a0);
02369         }
02370     };
02371 
02372     template <typename F, typename C0, typename C1, typename C2, typename A0>
02373     struct context31 {
02374         F f; C0 c0; C1 c1; C2 c2;
02375 
02376         context31(F f, C0 c0, C1 c1, C2 c2)
02377             : f(f), c0(c0), c1(c1), c2(c2) {}
02378 
02379         void operator()(A0 a0) {
02380             f(c0, c1, c2, a0);
02381         }
02382     };
02383 
02384     template <typename F, typename C0, typename C1, typename C2, typename C3, typename A0>
02385     struct context41 {
02386         F f; C0 c0; C1 c1; C2 c2; C3 c3;
02387 
02388         context41(F f, C0 c0, C1 c1, C2 c2, C3 c3)
02389             : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {}
02390 
02391         void operator()(A0 a0) {
02392             f(c0, c1, c2, c3, a0);
02393         }
02394     };
02395 
02396     template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0>
02397     struct context51 {
02398         F f; C0 c0; C1 c1; C2 c2; C3 c3; C4 c4;
02399 
02400         context51(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
02401             : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {}
02402 
02403         void operator()(A0 a0) {
02404             f(c0, c1, c2, c3, c4, a0);
02405         }
02406     };
02407 
02408     template <typename F, typename A0, typename A1>
02409     struct context02 {
02410         F f;
02411 
02412         context02(F f)
02413             : f(f) {}
02414 
02415         void operator()(A0 a0, A1 a1) {
02416             f(a0, a1);
02417         }
02418     };
02419 
02420     template <typename F, typename C0, typename A0, typename A1>
02421     struct context12 {
02422         F f; C0 c0;
02423 
02424         context12(F f, C0 c0)
02425             : f(f), c0(c0) {}
02426 
02427         void operator()(A0 a0, A1 a1) {
02428             f(c0, a0, a1);
02429         }
02430     };
02431 
02432     template <typename F, typename C0, typename C1, typename A0, typename A1>
02433     struct context22 {
02434         F f; C0 c0; C1 c1;
02435 
02436         context22(F f, C0 c0, C1 c1)
02437             : f(f), c0(c0), c1(c1) {}
02438 
02439         void operator()(A0 a0, A1 a1) {
02440             f(c0, c1, a0, a1);
02441         }
02442     };
02443 
02444     template <typename F, typename C0, typename C1, typename C2, typename A0, typename A1>
02445     struct context32 {
02446         F f; C0 c0; C1 c1; C2 c2;
02447 
02448         context32(F f, C0 c0, C1 c1, C2 c2)
02449             : f(f), c0(c0), c1(c1), c2(c2) {}
02450 
02451         void operator()(A0 a0, A1 a1) {
02452             f(c0, c1, c2, a0, a1);
02453         }
02454     };
02455 
02456     template <typename F, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1>
02457     struct context42 {
02458         F f; C0 c0; C1 c1; C2 c2; C3 c3;
02459 
02460         context42(F f, C0 c0, C1 c1, C2 c2, C3 c3)
02461             : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {}
02462 
02463         void operator()(A0 a0, A1 a1) {
02464             f(c0, c1, c2, c3, a0, a1);
02465         }
02466     };
02467 
02468     template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1>
02469     struct context52 {
02470         F f; C0 c0; C1 c1; C2 c2; C3 c3; C4 c4;
02471 
02472         context52(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
02473             : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {}
02474 
02475         void operator()(A0 a0, A1 a1) {
02476             f(c0, c1, c2, c3, c4, a0, a1);
02477         }
02478     };
02479 
02480     template <typename F, typename A0, typename A1, typename A2>
02481     struct context03 {
02482         F f;
02483 
02484         context03(F f)
02485             : f(f) {}
02486 
02487         void operator()(A0 a0, A1 a1, A2 a2) {
02488             f(a0, a1, a2);
02489         }
02490     };
02491 
02492     template <typename F, typename C0, typename A0, typename A1, typename A2>
02493     struct context13 {
02494         F f; C0 c0;
02495 
02496         context13(F f, C0 c0)
02497             : f(f), c0(c0) {}
02498 
02499         void operator()(A0 a0, A1 a1, A2 a2) {
02500             f(c0, a0, a1, a2);
02501         }
02502     };
02503 
02504     template <typename F, typename C0, typename C1, typename A0, typename A1, typename A2>
02505     struct context23 {
02506         F f; C0 c0; C1 c1;
02507 
02508         context23(F f, C0 c0, C1 c1)
02509             : f(f), c0(c0), c1(c1) {}
02510 
02511         void operator()(A0 a0, A1 a1, A2 a2) {
02512             f(c0, c1, a0, a1, a2);
02513         }
02514     };
02515 
02516     template <typename F, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
02517     struct context33 {
02518         F f; C0 c0; C1 c1; C2 c2;
02519 
02520         context33(F f, C0 c0, C1 c1, C2 c2)
02521             : f(f), c0(c0), c1(c1), c2(c2) {}
02522 
02523         void operator()(A0 a0, A1 a1, A2 a2) {
02524             f(c0, c1, c2, a0, a1, a2);
02525         }
02526     };
02527 
02528     template <typename F, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2>
02529     struct context43 {
02530         F f; C0 c0; C1 c1; C2 c2; C3 c3;
02531 
02532         context43(F f, C0 c0, C1 c1, C2 c2, C3 c3)
02533             : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {}
02534 
02535         void operator()(A0 a0, A1 a1, A2 a2) {
02536             f(c0, c1, c2, c3, a0, a1, a2);
02537         }
02538     };
02539 
02540     template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2>
02541     struct context53 {
02542         F f; C0 c0; C1 c1; C2 c2; C3 c3; C4 c4;
02543 
02544         context53(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
02545             : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {}
02546 
02547         void operator()(A0 a0, A1 a1, A2 a2) {
02548             f(c0, c1, c2, c3, c4, a0, a1, a2);
02549         }
02550     };
02551 
02552     template <typename F, typename A0, typename A1, typename A2, typename A3>
02553     struct context04 {
02554         F f;
02555 
02556         context04(F f)
02557             : f(f) {}
02558 
02559         void operator()(A0 a0, A1 a1, A2 a2, A3 a3) {
02560             f(a0, a1, a2, a3);
02561         }
02562     };
02563 
02564     template <typename F, typename C0, typename A0, typename A1, typename A2, typename A3>
02565     struct context14 {
02566         F f; C0 c0;
02567 
02568         context14(F f, C0 c0)
02569             : f(f), c0(c0) {}
02570 
02571         void operator()(A0 a0, A1 a1, A2 a2, A3 a3) {
02572             f(c0, a0, a1, a2, a3);
02573         }
02574     };
02575 
02576     template <typename F, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
02577     struct context24 {
02578         F f; C0 c0; C1 c1;
02579 
02580         context24(F f, C0 c0, C1 c1)
02581             : f(f), c0(c0), c1(c1) {}
02582 
02583         void operator()(A0 a0, A1 a1, A2 a2, A3 a3) {
02584             f(c0, c1, a0, a1, a2, a3);
02585         }
02586     };
02587 
02588     template <typename F, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3>
02589     struct context34 {
02590         F f; C0 c0; C1 c1; C2 c2;
02591 
02592         context34(F f, C0 c0, C1 c1, C2 c2)
02593             : f(f), c0(c0), c1(c1), c2(c2) {}
02594 
02595         void operator()(A0 a0, A1 a1, A2 a2, A3 a3) {
02596             f(c0, c1, c2, a0, a1, a2, a3);
02597         }
02598     };
02599 
02600     template <typename F, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3>
02601     struct context44 {
02602         F f; C0 c0; C1 c1; C2 c2; C3 c3;
02603 
02604         context44(F f, C0 c0, C1 c1, C2 c2, C3 c3)
02605             : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {}
02606 
02607         void operator()(A0 a0, A1 a1, A2 a2, A3 a3) {
02608             f(c0, c1, c2, c3, a0, a1, a2, a3);
02609         }
02610     };
02611 
02612     template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3>
02613     struct context54 {
02614         F f; C0 c0; C1 c1; C2 c2; C3 c3; C4 c4;
02615 
02616         context54(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
02617             : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {}
02618 
02619         void operator()(A0 a0, A1 a1, A2 a2, A3 a3) {
02620             f(c0, c1, c2, c3, c4, a0, a1, a2, a3);
02621         }
02622     };
02623 
02624     template <typename F, typename A0, typename A1, typename A2, typename A3, typename A4>
02625     struct context05 {
02626         F f;
02627 
02628         context05(F f)
02629             : f(f) {}
02630 
02631         void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
02632             f(a0, a1, a2, a3, a4);
02633         }
02634     };
02635 
02636     template <typename F, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
02637     struct context15 {
02638         F f; C0 c0;
02639 
02640         context15(F f, C0 c0)
02641             : f(f), c0(c0) {}
02642 
02643         void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
02644             f(c0, a0, a1, a2, a3, a4);
02645         }
02646     };
02647 
02648     template <typename F, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
02649     struct context25 {
02650         F f; C0 c0; C1 c1;
02651 
02652         context25(F f, C0 c0, C1 c1)
02653             : f(f), c0(c0), c1(c1) {}
02654 
02655         void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
02656             f(c0, c1, a0, a1, a2, a3, a4);
02657         }
02658     };
02659 
02660     template <typename F, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3, typename A4>
02661     struct context35 {
02662         F f; C0 c0; C1 c1; C2 c2;
02663 
02664         context35(F f, C0 c0, C1 c1, C2 c2)
02665             : f(f), c0(c0), c1(c1), c2(c2) {}
02666 
02667         void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
02668             f(c0, c1, c2, a0, a1, a2, a3, a4);
02669         }
02670     };
02671 
02672     template <typename F, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3, typename A4>
02673     struct context45 {
02674         F f; C0 c0; C1 c1; C2 c2; C3 c3;
02675 
02676         context45(F f, C0 c0, C1 c1, C2 c2, C3 c3)
02677             : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {}
02678 
02679         void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
02680             f(c0, c1, c2, c3, a0, a1, a2, a3, a4);
02681         }
02682     };
02683 
02684     template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3, typename A4>
02685     struct context55 {
02686         F f; C0 c0; C1 c1; C2 c2; C3 c3; C4 c4;
02687 
02688         context55(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
02689             : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {}
02690 
02691         void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
02692             f(c0, c1, c2, c3, c4, a0, a1, a2, a3, a4);
02693         }
02694     };
02695 };
02696 
02697 }
02698 
02699 #endif
02700 
02701 /** @}*/