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