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