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