EventQueue.h

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