EventQueue.h

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