ON Semiconductor / mbed-os

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependents:   mbed-TFT-example-NCS36510 mbed-Accelerometer-example-NCS36510 mbed-Accelerometer-example-NCS36510

Embed: (wiki syntax)

« Back to documentation index

Events
Data Structures | Functions

Events

Data Structures

class  Event< void()>
 Event. More...
class  Event< void(A0)>
 Event. More...
class  Event< void(A0, A1)>
 Event. More...
class  Event< void(A0, A1, A2)>
 Event. More...
class  Event< void(A0, A1, A2, A3)>
 Event. More...
class  Event< void(A0, A1, A2, A3, A4)>
 Event. More...
class  EventQueue
 EventQueue. More...

Functions

 Event (const Event &e)
 Copy constructor for events.
Event & operator= (const Event &that)
 Assignment operator for events.
 ~Event ()
 Destructor for events.
void delay (int delay)
 Configure the delay of an event.
void period (int period)
 Configure the period of an event.
int post () const
 Posts an event onto the underlying event queue.
void call () const
 Posts an event onto the underlying event queue, returning void.
void operator() () const
 Posts an event onto the underlying event queue, returning void.
static void thunk (void *func)
 Static thunk for passing as C-style function.
void cancel () const
 Cancels the most recently posted event.
template<typename F , typename C0 >
 Event (EventQueue *q, F f, C0 c0)
 Create an event.
template<typename F , typename C0 , typename C1 >
 Event (EventQueue *q, F f, C0 c0, C1 c1)
 Create an event.
template<typename F , typename C0 , typename C1 , typename C2 >
 Event (EventQueue *q, F f, C0 c0, C1 c1, C2 c2)
 Create an event.
template<typename F , typename C0 , typename C1 , typename C2 , typename C3 >
 Event (EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3)
 Create an event.
template<typename F , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 >
 Event (EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
 Create an event.
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0), B0 b0)
 Create an event.
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0) const, B0 b0)
 Create an event.
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0) volatile, B0 b0)
 Create an event.
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0) const volatile, B0 b0)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1), B0 b0, B1 b1)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1) const, B0 b0, B1 b1)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1) volatile, B0 b0, B1 b1)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1) const volatile, B0 b0, B1 b1)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1, B2), B0 b0, B1 b1, B2 b2)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2) const, B0 b0, B1 b1, B2 b2)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2) volatile, B0 b0, B1 b1, B2 b2)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2) const volatile, B0 b0, B1 b1, B2 b2)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3), B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3) const, B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3) volatile, B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3) const volatile, B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, B4), B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, B4) const, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4) volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4) const volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event.
 Event (const Event &e)
 Copy constructor for events.
Event & operator= (const Event &that)
 Assignment operator for events.
 ~Event ()
 Destructor for events.
void delay (int delay)
 Configure the delay of an event.
void period (int period)
 Configure the period of an event.
int post (A0 a0) const
 Posts an event onto the underlying event queue.
void call (A0 a0) const
 Posts an event onto the underlying event queue, returning void.
void operator() (A0 a0) const
 Posts an event onto the underlying event queue, returning void.
static void thunk (void *func, A0 a0)
 Static thunk for passing as C-style function.
void cancel () const
 Cancels the most recently posted event.
template<typename F , typename C0 >
 Event (EventQueue *q, F f, C0 c0)
 Create an event.
template<typename F , typename C0 , typename C1 >
 Event (EventQueue *q, F f, C0 c0, C1 c1)
 Create an event.
template<typename F , typename C0 , typename C1 , typename C2 >
 Event (EventQueue *q, F f, C0 c0, C1 c1, C2 c2)
 Create an event.
template<typename F , typename C0 , typename C1 , typename C2 , typename C3 >
 Event (EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3)
 Create an event.
template<typename F , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 >
 Event (EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
 Create an event.
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, A0), B0 b0)
 Create an event.
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, A0) const, B0 b0)
 Create an event.
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, A0) volatile, B0 b0)
 Create an event.
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, A0) const volatile, B0 b0)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1, A0), B0 b0, B1 b1)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1, A0) const, B0 b0, B1 b1)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, A0) volatile, B0 b0, B1 b1)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, A0) const volatile, B0 b0, B1 b1)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, A0), B0 b0, B1 b1, B2 b2)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, A0) const, B0 b0, B1 b1, B2 b2)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, A0) volatile, B0 b0, B1 b1, B2 b2)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, A0) const volatile, B0 b0, B1 b1, B2 b2)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, A0), B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, A0) const, B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0) volatile, B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0) const volatile, B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0), B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0) const, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0) volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0) const volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event.
 Event (const Event &e)
 Copy constructor for events.
Event & operator= (const Event &that)
 Assignment operator for events.
 ~Event ()
 Destructor for events.
void delay (int delay)
 Configure the delay of an event.
void period (int period)
 Configure the period of an event.
int post (A0 a0, A1 a1) const
 Posts an event onto the underlying event queue.
void call (A0 a0, A1 a1) const
 Posts an event onto the underlying event queue, returning void.
void operator() (A0 a0, A1 a1) const
 Posts an event onto the underlying event queue, returning void.
static void thunk (void *func, A0 a0, A1 a1)
 Static thunk for passing as C-style function.
void cancel () const
 Cancels the most recently posted event.
template<typename F , typename C0 >
 Event (EventQueue *q, F f, C0 c0)
 Create an event.
template<typename F , typename C0 , typename C1 >
 Event (EventQueue *q, F f, C0 c0, C1 c1)
 Create an event.
template<typename F , typename C0 , typename C1 , typename C2 >
 Event (EventQueue *q, F f, C0 c0, C1 c1, C2 c2)
 Create an event.
template<typename F , typename C0 , typename C1 , typename C2 , typename C3 >
 Event (EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3)
 Create an event.
template<typename F , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 >
 Event (EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
 Create an event.
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, A0, A1), B0 b0)
 Create an event.
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, A0, A1) const, B0 b0)
 Create an event.
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, A0, A1) volatile, B0 b0)
 Create an event.
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, A0, A1) const volatile, B0 b0)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1, A0, A1), B0 b0, B1 b1)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1, A0, A1) const, B0 b0, B1 b1)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, A0, A1) volatile, B0 b0, B1 b1)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, A0, A1) const volatile, B0 b0, B1 b1)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, A0, A1), B0 b0, B1 b1, B2 b2)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, A0, A1) const, B0 b0, B1 b1, B2 b2)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1) volatile, B0 b0, B1 b1, B2 b2)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1) const volatile, B0 b0, B1 b1, B2 b2)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1), B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1) const, B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1) volatile, B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1) const volatile, B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1), B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1) const, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1) volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1) const volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event.
 Event (const Event &e)
 Copy constructor for events.
Event & operator= (const Event &that)
 Assignment operator for events.
 ~Event ()
 Destructor for events.
void delay (int delay)
 Configure the delay of an event.
void period (int period)
 Configure the period of an event.
int post (A0 a0, A1 a1, A2 a2) const
 Posts an event onto the underlying event queue.
void call (A0 a0, A1 a1, A2 a2) const
 Posts an event onto the underlying event queue, returning void.
void operator() (A0 a0, A1 a1, A2 a2) const
 Posts an event onto the underlying event queue, returning void.
static void thunk (void *func, A0 a0, A1 a1, A2 a2)
 Static thunk for passing as C-style function.
void cancel () const
 Cancels the most recently posted event.
template<typename F , typename C0 >
 Event (EventQueue *q, F f, C0 c0)
 Create an event.
template<typename F , typename C0 , typename C1 >
 Event (EventQueue *q, F f, C0 c0, C1 c1)
 Create an event.
template<typename F , typename C0 , typename C1 , typename C2 >
 Event (EventQueue *q, F f, C0 c0, C1 c1, C2 c2)
 Create an event.
template<typename F , typename C0 , typename C1 , typename C2 , typename C3 >
 Event (EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3)
 Create an event.
template<typename F , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 >
 Event (EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
 Create an event.
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, A0, A1, A2), B0 b0)
 Create an event.
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, A0, A1, A2) const, B0 b0)
 Create an event.
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, A0, A1, A2) volatile, B0 b0)
 Create an event.
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, A0, A1, A2) const volatile, B0 b0)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1, A0, A1, A2), B0 b0, B1 b1)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1, A0, A1, A2) const, B0 b0, B1 b1)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, A0, A1, A2) volatile, B0 b0, B1 b1)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, A0, A1, A2) const volatile, B0 b0, B1 b1)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2), B0 b0, B1 b1, B2 b2)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2) const, B0 b0, B1 b1, B2 b2)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2) volatile, B0 b0, B1 b1, B2 b2)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2) const volatile, B0 b0, B1 b1, B2 b2)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2), B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2) const, B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2) volatile, B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2) const volatile, B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2), B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2) const, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2) volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2) const volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event.
 Event (const Event &e)
 Copy constructor for events.
Event & operator= (const Event &that)
 Assignment operator for events.
 ~Event ()
 Destructor for events.
void delay (int delay)
 Configure the delay of an event.
void period (int period)
 Configure the period of an event.
int post (A0 a0, A1 a1, A2 a2, A3 a3) const
 Posts an event onto the underlying event queue.
void call (A0 a0, A1 a1, A2 a2, A3 a3) const
 Posts an event onto the underlying event queue, returning void.
void operator() (A0 a0, A1 a1, A2 a2, A3 a3) const
 Posts an event onto the underlying event queue, returning void.
static void thunk (void *func, A0 a0, A1 a1, A2 a2, A3 a3)
 Static thunk for passing as C-style function.
void cancel () const
 Cancels the most recently posted event.
template<typename F , typename C0 >
 Event (EventQueue *q, F f, C0 c0)
 Create an event.
template<typename F , typename C0 , typename C1 >
 Event (EventQueue *q, F f, C0 c0, C1 c1)
 Create an event.
template<typename F , typename C0 , typename C1 , typename C2 >
 Event (EventQueue *q, F f, C0 c0, C1 c1, C2 c2)
 Create an event.
template<typename F , typename C0 , typename C1 , typename C2 , typename C3 >
 Event (EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3)
 Create an event.
template<typename F , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 >
 Event (EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
 Create an event.
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, A0, A1, A2, A3), B0 b0)
 Create an event.
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, A0, A1, A2, A3) const, B0 b0)
 Create an event.
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, A0, A1, A2, A3) volatile, B0 b0)
 Create an event.
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, A0, A1, A2, A3) const volatile, B0 b0)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3), B0 b0, B1 b1)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3) const, B0 b0, B1 b1)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3) volatile, B0 b0, B1 b1)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3) const volatile, B0 b0, B1 b1)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3), B0 b0, B1 b1, B2 b2)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3) const, B0 b0, B1 b1, B2 b2)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3) volatile, B0 b0, B1 b1, B2 b2)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3) const volatile, B0 b0, B1 b1, B2 b2)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3), B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3) const, B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3) volatile, B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3) const volatile, B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3), B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3) const, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3) volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3) const volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event.
 Event (const Event &e)
 Copy constructor for events.
Event & operator= (const Event &that)
 Assignment operator for events.
 ~Event ()
 Destructor for events.
void delay (int delay)
 Configure the delay of an event.
void period (int period)
 Configure the period of an event.
int post (A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const
 Posts an event onto the underlying event queue.
void call (A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const
 Posts an event onto the underlying event queue, returning void.
void operator() (A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const
 Posts an event onto the underlying event queue, returning void.
static void thunk (void *func, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4)
 Static thunk for passing as C-style function.
void cancel () const
 Cancels the most recently posted event.
template<typename F , typename C0 >
 Event (EventQueue *q, F f, C0 c0)
 Create an event.
template<typename F , typename C0 , typename C1 >
 Event (EventQueue *q, F f, C0 c0, C1 c1)
 Create an event.
template<typename F , typename C0 , typename C1 , typename C2 >
 Event (EventQueue *q, F f, C0 c0, C1 c1, C2 c2)
 Create an event.
template<typename F , typename C0 , typename C1 , typename C2 , typename C3 >
 Event (EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3)
 Create an event.
template<typename F , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 >
 Event (EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
 Create an event.
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, A0, A1, A2, A3, A4), B0 b0)
 Create an event.
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, A0, A1, A2, A3, A4) const, B0 b0)
 Create an event.
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, A0, A1, A2, A3, A4) volatile, B0 b0)
 Create an event.
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, A0, A1, A2, A3, A4) const volatile, B0 b0)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3, A4), B0 b0, B1 b1)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3, A4) const, B0 b0, B1 b1)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3, A4) volatile, B0 b0, B1 b1)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3, A4) const volatile, B0 b0, B1 b1)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3, A4), B0 b0, B1 b1, B2 b2)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3, A4) const, B0 b0, B1 b1, B2 b2)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3, A4) volatile, B0 b0, B1 b1, B2 b2)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3, A4) const volatile, B0 b0, B1 b1, B2 b2)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3, A4), B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3, A4) const, B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3, A4) volatile, B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3, A4) const volatile, B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4), B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4) const, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4) volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4) const volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event.
 ~EventQueue ()
 Destroy an EventQueue.
void dispatch (int ms=-1)
 Dispatch events.
void dispatch_forever ()
 Dispatch events without a timeout.
void break_dispatch ()
 Break out of a running event loop.
unsigned tick ()
 Millisecond counter.
void cancel (int id)
 Cancel an in-flight event.
void background (mbed::Callback< void(int)> update)
 Background an event queue onto a single-shot timer-interrupt.
void chain (EventQueue *target)
 Chain an event queue onto another event queue.
template<typename F >
int call (F f)
 Calls an event on the queue.
template<typename F , typename A0 >
int call (F f, A0 a0)
 Calls an event on the queue.
template<typename F , typename A0 , typename A1 >
int call (F f, A0 a0, A1 a1)
 Calls an event on the queue.
template<typename F , typename A0 , typename A1 , typename A2 >
int call (F f, A0 a0, A1 a1, A2 a2)
 Calls an event on the queue.
template<typename F , typename A0 , typename A1 , typename A2 , typename A3 >
int call (F f, A0 a0, A1 a1, A2 a2, A3 a3)
 Calls an event on the queue.
template<typename F , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
int call (F f, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4)
 Calls an event on the queue.
template<typename T , typename R >
int call (T *obj, R(T::*method)())
 Calls an event on the queue.
template<typename T , typename R >
int call (const T *obj, R(T::*method)() const)
 Calls an event on the queue.
template<typename T , typename R >
int call (volatile T *obj, R(T::*method)() volatile)
 Calls an event on the queue.
template<typename T , typename R >
int call (const volatile T *obj, R(T::*method)() const volatile)
 Calls an event on the queue.
template<typename T , typename R , typename A0 >
int call (T *obj, R(T::*method)(A0), A0 a0)
 Calls an event on the queue.
template<typename T , typename R , typename A0 >
int call (const T *obj, R(T::*method)(A0) const, A0 a0)
 Calls an event on the queue.
template<typename T , typename R , typename A0 >
int call (volatile T *obj, R(T::*method)(A0) volatile, A0 a0)
 Calls an event on the queue.
template<typename T , typename R , typename A0 >
int call (const volatile T *obj, R(T::*method)(A0) const volatile, A0 a0)
 Calls an event on the queue.
template<typename T , typename R , typename A0 , typename A1 >
int call (T *obj, R(T::*method)(A0, A1), A0 a0, A1 a1)
 Calls an event on the queue.
template<typename T , typename R , typename A0 , typename A1 >
int call (const T *obj, R(T::*method)(A0, A1) const, A0 a0, A1 a1)
 Calls an event on the queue.
template<typename T , typename R , typename A0 , typename A1 >
int call (volatile T *obj, R(T::*method)(A0, A1) volatile, A0 a0, A1 a1)
 Calls an event on the queue.
template<typename T , typename R , typename A0 , typename A1 >
int call (const volatile T *obj, R(T::*method)(A0, A1) const volatile, A0 a0, A1 a1)
 Calls an event on the queue.
template<typename T , typename R , typename A0 , typename A1 , typename A2 >
int call (T *obj, R(T::*method)(A0, A1, A2), A0 a0, A1 a1, A2 a2)
 Calls an event on the queue.
template<typename T , typename R , typename A0 , typename A1 , typename A2 >
int call (const T *obj, R(T::*method)(A0, A1, A2) const, A0 a0, A1 a1, A2 a2)
 Calls an event on the queue.
template<typename T , typename R , typename A0 , typename A1 , typename A2 >
int call (volatile T *obj, R(T::*method)(A0, A1, A2) volatile, A0 a0, A1 a1, A2 a2)
 Calls an event on the queue.
template<typename T , typename R , typename A0 , typename A1 , typename A2 >
int call (const volatile T *obj, R(T::*method)(A0, A1, A2) const volatile, A0 a0, A1 a1, A2 a2)
 Calls an event on the queue.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 >
int call (T *obj, R(T::*method)(A0, A1, A2, A3), A0 a0, A1 a1, A2 a2, A3 a3)
 Calls an event on the queue.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 >
int call (const T *obj, R(T::*method)(A0, A1, A2, A3) const, A0 a0, A1 a1, A2 a2, A3 a3)
 Calls an event on the queue.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 >
int call (volatile T *obj, R(T::*method)(A0, A1, A2, A3) volatile, A0 a0, A1 a1, A2 a2, A3 a3)
 Calls an event on the queue.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 >
int call (const volatile T *obj, R(T::*method)(A0, A1, A2, A3) const volatile, A0 a0, A1 a1, A2 a2, A3 a3)
 Calls an event on the queue.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
int call (T *obj, R(T::*method)(A0, A1, A2, A3, A4), A0 a0, A1 a1, A2 a2, A3 a3, A4 a4)
 Calls an event on the queue.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
int call (const T *obj, R(T::*method)(A0, A1, A2, A3, A4) const, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4)
 Calls an event on the queue.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
int call (volatile T *obj, R(T::*method)(A0, A1, A2, A3, A4) volatile, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4)
 Calls an event on the queue.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
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)
 Calls an event on the queue.
template<typename F >
int call_in (int ms, F f)
 Calls an event on the queue after a specified delay.
template<typename F , typename A0 >
int call_in (int ms, F f, A0 a0)
 Calls an event on the queue after a specified delay.
template<typename F , typename A0 , typename A1 >
int call_in (int ms, F f, A0 a0, A1 a1)
 Calls an event on the queue after a specified delay.
template<typename F , typename A0 , typename A1 , typename A2 >
int call_in (int ms, F f, A0 a0, A1 a1, A2 a2)
 Calls an event on the queue after a specified delay.
template<typename F , typename A0 , typename A1 , typename A2 , typename A3 >
int call_in (int ms, F f, A0 a0, A1 a1, A2 a2, A3 a3)
 Calls an event on the queue after a specified delay.
template<typename F , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
int call_in (int ms, F f, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4)
 Calls an event on the queue after a specified delay.
template<typename T , typename R >
int call_in (int ms, T *obj, R(T::*method)())
 Calls an event on the queue after a specified delay.
template<typename T , typename R >
int call_in (int ms, const T *obj, R(T::*method)() const)
 Calls an event on the queue after a specified delay.
template<typename T , typename R >
int call_in (int ms, volatile T *obj, R(T::*method)() volatile)
 Calls an event on the queue after a specified delay.
template<typename T , typename R >
int call_in (int ms, const volatile T *obj, R(T::*method)() const volatile)
 Calls an event on the queue after a specified delay.
template<typename T , typename R , typename A0 >
int call_in (int ms, T *obj, R(T::*method)(A0), A0 a0)
 Calls an event on the queue after a specified delay.
template<typename T , typename R , typename A0 >
int call_in (int ms, const T *obj, R(T::*method)(A0) const, A0 a0)
 Calls an event on the queue after a specified delay.
template<typename T , typename R , typename A0 >
int call_in (int ms, volatile T *obj, R(T::*method)(A0) volatile, A0 a0)
 Calls an event on the queue after a specified delay.
template<typename T , typename R , typename A0 >
int call_in (int ms, const volatile T *obj, R(T::*method)(A0) const volatile, A0 a0)
 Calls an event on the queue after a specified delay.
template<typename T , typename R , typename A0 , typename A1 >
int call_in (int ms, T *obj, R(T::*method)(A0, A1), A0 a0, A1 a1)
 Calls an event on the queue after a specified delay.
template<typename T , typename R , typename A0 , typename A1 >
int call_in (int ms, const T *obj, R(T::*method)(A0, A1) const, A0 a0, A1 a1)
 Calls an event on the queue after a specified delay.
template<typename T , typename R , typename A0 , typename A1 >
int call_in (int ms, volatile T *obj, R(T::*method)(A0, A1) volatile, A0 a0, A1 a1)
 Calls an event on the queue after a specified delay.
template<typename T , typename R , typename A0 , typename A1 >
int call_in (int ms, const volatile T *obj, R(T::*method)(A0, A1) const volatile, A0 a0, A1 a1)
 Calls an event on the queue after a specified delay.
template<typename T , typename R , typename A0 , typename A1 , typename A2 >
int call_in (int ms, T *obj, R(T::*method)(A0, A1, A2), A0 a0, A1 a1, A2 a2)
 Calls an event on the queue after a specified delay.
template<typename T , typename R , typename A0 , typename A1 , typename A2 >
int call_in (int ms, const T *obj, R(T::*method)(A0, A1, A2) const, A0 a0, A1 a1, A2 a2)
 Calls an event on the queue after a specified delay.
template<typename T , typename R , typename A0 , typename A1 , typename A2 >
int call_in (int ms, volatile T *obj, R(T::*method)(A0, A1, A2) volatile, A0 a0, A1 a1, A2 a2)
 Calls an event on the queue after a specified delay.
template<typename T , typename R , typename A0 , typename A1 , typename A2 >
int call_in (int ms, const volatile T *obj, R(T::*method)(A0, A1, A2) const volatile, A0 a0, A1 a1, A2 a2)
 Calls an event on the queue after a specified delay.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 >
int call_in (int ms, T *obj, R(T::*method)(A0, A1, A2, A3), A0 a0, A1 a1, A2 a2, A3 a3)
 Calls an event on the queue after a specified delay.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 >
int call_in (int ms, const T *obj, R(T::*method)(A0, A1, A2, A3) const, A0 a0, A1 a1, A2 a2, A3 a3)
 Calls an event on the queue after a specified delay.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 >
int call_in (int ms, volatile T *obj, R(T::*method)(A0, A1, A2, A3) volatile, A0 a0, A1 a1, A2 a2, A3 a3)
 Calls an event on the queue after a specified delay.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 >
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)
 Calls an event on the queue after a specified delay.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
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)
 Calls an event on the queue after a specified delay.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
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)
 Calls an event on the queue after a specified delay.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
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)
 Calls an event on the queue after a specified delay.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
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)
 Calls an event on the queue after a specified delay.
template<typename F >
int call_every (int ms, F f)
 Calls an event on the queue periodically.
template<typename F , typename A0 >
int call_every (int ms, F f, A0 a0)
 Calls an event on the queue periodically.
template<typename F , typename A0 , typename A1 >
int call_every (int ms, F f, A0 a0, A1 a1)
 Calls an event on the queue periodically.
template<typename F , typename A0 , typename A1 , typename A2 >
int call_every (int ms, F f, A0 a0, A1 a1, A2 a2)
 Calls an event on the queue periodically.
template<typename F , typename A0 , typename A1 , typename A2 , typename A3 >
int call_every (int ms, F f, A0 a0, A1 a1, A2 a2, A3 a3)
 Calls an event on the queue periodically.
template<typename F , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
int call_every (int ms, F f, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4)
 Calls an event on the queue periodically.
template<typename T , typename R >
int call_every (int ms, T *obj, R(T::*method)())
 Calls an event on the queue periodically.
template<typename T , typename R >
int call_every (int ms, const T *obj, R(T::*method)() const)
 Calls an event on the queue periodically.
template<typename T , typename R >
int call_every (int ms, volatile T *obj, R(T::*method)() volatile)
 Calls an event on the queue periodically.
template<typename T , typename R >
int call_every (int ms, const volatile T *obj, R(T::*method)() const volatile)
 Calls an event on the queue periodically.
template<typename T , typename R , typename A0 >
int call_every (int ms, T *obj, R(T::*method)(A0), A0 a0)
 Calls an event on the queue periodically.
template<typename T , typename R , typename A0 >
int call_every (int ms, const T *obj, R(T::*method)(A0) const, A0 a0)
 Calls an event on the queue periodically.
template<typename T , typename R , typename A0 >
int call_every (int ms, volatile T *obj, R(T::*method)(A0) volatile, A0 a0)
 Calls an event on the queue periodically.
template<typename T , typename R , typename A0 >
int call_every (int ms, const volatile T *obj, R(T::*method)(A0) const volatile, A0 a0)
 Calls an event on the queue periodically.
template<typename T , typename R , typename A0 , typename A1 >
int call_every (int ms, T *obj, R(T::*method)(A0, A1), A0 a0, A1 a1)
 Calls an event on the queue periodically.
template<typename T , typename R , typename A0 , typename A1 >
int call_every (int ms, const T *obj, R(T::*method)(A0, A1) const, A0 a0, A1 a1)
 Calls an event on the queue periodically.
template<typename T , typename R , typename A0 , typename A1 >
int call_every (int ms, volatile T *obj, R(T::*method)(A0, A1) volatile, A0 a0, A1 a1)
 Calls an event on the queue periodically.
template<typename T , typename R , typename A0 , typename A1 >
int call_every (int ms, const volatile T *obj, R(T::*method)(A0, A1) const volatile, A0 a0, A1 a1)
 Calls an event on the queue periodically.
template<typename T , typename R , typename A0 , typename A1 , typename A2 >
int call_every (int ms, T *obj, R(T::*method)(A0, A1, A2), A0 a0, A1 a1, A2 a2)
 Calls an event on the queue periodically.
template<typename T , typename R , typename A0 , typename A1 , typename A2 >
int call_every (int ms, const T *obj, R(T::*method)(A0, A1, A2) const, A0 a0, A1 a1, A2 a2)
 Calls an event on the queue periodically.
template<typename T , typename R , typename A0 , typename A1 , typename A2 >
int call_every (int ms, volatile T *obj, R(T::*method)(A0, A1, A2) volatile, A0 a0, A1 a1, A2 a2)
 Calls an event on the queue periodically.
template<typename T , typename R , typename A0 , typename A1 , typename A2 >
int call_every (int ms, const volatile T *obj, R(T::*method)(A0, A1, A2) const volatile, A0 a0, A1 a1, A2 a2)
 Calls an event on the queue periodically.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 >
int call_every (int ms, T *obj, R(T::*method)(A0, A1, A2, A3), A0 a0, A1 a1, A2 a2, A3 a3)
 Calls an event on the queue periodically.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 >
int call_every (int ms, const T *obj, R(T::*method)(A0, A1, A2, A3) const, A0 a0, A1 a1, A2 a2, A3 a3)
 Calls an event on the queue periodically.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 >
int call_every (int ms, volatile T *obj, R(T::*method)(A0, A1, A2, A3) volatile, A0 a0, A1 a1, A2 a2, A3 a3)
 Calls an event on the queue periodically.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 >
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)
 Calls an event on the queue periodically.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
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)
 Calls an event on the queue periodically.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
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)
 Calls an event on the queue periodically.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
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)
 Calls an event on the queue periodically.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
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)
 Calls an event on the queue periodically.
template<typename R >
Event< void()> event (R(*func)())
 Creates an event bound to the event queue.
template<typename T , typename R >
Event< void()> event (T *obj, R(T::*method)())
 Creates an event bound to the event queue.
template<typename T , typename R >
Event< void()> event (const T *obj, R(T::*method)() const)
 Creates an event bound to the event queue.
template<typename T , typename R >
Event< void()> event (volatile T *obj, R(T::*method)() volatile)
 Creates an event bound to the event queue.
template<typename T , typename R >
Event< void()> event (const volatile T *obj, R(T::*method)() const volatile)
 Creates an event bound to the event queue.
template<typename R , typename B0 , typename C0 >
Event< void()> event (R(*func)(B0), C0 c0)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename C0 >
Event< void()> event (T *obj, R(T::*method)(B0), C0 c0)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename C0 >
Event< void()> event (const T *obj, R(T::*method)(B0) const, C0 c0)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename C0 >
Event< void()> event (volatile T *obj, R(T::*method)(B0) volatile, C0 c0)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename C0 >
Event< void()> event (const volatile T *obj, R(T::*method)(B0) const volatile, C0 c0)
 Creates an event bound to the event queue.
template<typename R , typename B0 , typename B1 , typename C0 , typename C1 >
Event< void()> event (R(*func)(B0, B1), C0 c0, C1 c1)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename C0 , typename C1 >
Event< void()> event (T *obj, R(T::*method)(B0, B1), C0 c0, C1 c1)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename C0 , typename C1 >
Event< void()> event (const T *obj, R(T::*method)(B0, B1) const, C0 c0, C1 c1)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename C0 , typename C1 >
Event< void()> event (volatile T *obj, R(T::*method)(B0, B1) volatile, C0 c0, C1 c1)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename C0 , typename C1 >
Event< void()> event (const volatile T *obj, R(T::*method)(B0, B1) const volatile, C0 c0, C1 c1)
 Creates an event bound to the event queue.
template<typename R , typename B0 , typename B1 , typename B2 , typename C0 , typename C1 , typename C2 >
Event< void()> event (R(*func)(B0, B1, B2), C0 c0, C1 c1, C2 c2)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename C0 , typename C1 , typename C2 >
Event< void()> event (T *obj, R(T::*method)(B0, B1, B2), C0 c0, C1 c1, C2 c2)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename C0 , typename C1 , typename C2 >
Event< void()> event (const T *obj, R(T::*method)(B0, B1, B2) const, C0 c0, C1 c1, C2 c2)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename C0 , typename C1 , typename C2 >
Event< void()> event (volatile T *obj, R(T::*method)(B0, B1, B2) volatile, C0 c0, C1 c1, C2 c2)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename C0 , typename C1 , typename C2 >
Event< void()> event (const volatile T *obj, R(T::*method)(B0, B1, B2) const volatile, C0 c0, C1 c1, C2 c2)
 Creates an event bound to the event queue.
template<typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename C0 , typename C1 , typename C2 , typename C3 >
Event< void()> event (R(*func)(B0, B1, B2, B3), C0 c0, C1 c1, C2 c2, C3 c3)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename C0 , typename C1 , typename C2 , typename C3 >
Event< void()> event (T *obj, R(T::*method)(B0, B1, B2, B3), C0 c0, C1 c1, C2 c2, C3 c3)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename C0 , typename C1 , typename C2 , typename C3 >
Event< void()> event (const T *obj, R(T::*method)(B0, B1, B2, B3) const, C0 c0, C1 c1, C2 c2, C3 c3)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename C0 , typename C1 , typename C2 , typename C3 >
Event< void()> event (volatile T *obj, R(T::*method)(B0, B1, B2, B3) volatile, C0 c0, C1 c1, C2 c2, C3 c3)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename C0 , typename C1 , typename C2 , typename C3 >
Event< void()> event (const volatile T *obj, R(T::*method)(B0, B1, B2, B3) const volatile, C0 c0, C1 c1, C2 c2, C3 c3)
 Creates an event bound to the event queue.
template<typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 >
Event< void()> event (R(*func)(B0, B1, B2, B3, B4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
 Creates an event bound to the event queue.
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 >
Event< void()> event (T *obj, R(T::*method)(B0, B1, B2, B3, B4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
template<typename R , typename A0 >
Event< void(A0)> event (R(*func)(A0))
 Creates an event bound to the event queue.
template<typename T , typename R , typename A0 >
Event< void(A0)> event (T *obj, R(T::*method)(A0))
 Creates an event bound to the event queue.
template<typename T , typename R , typename A0 >
Event< void(A0)> event (const T *obj, R(T::*method)(A0) const)
 Creates an event bound to the event queue.
template<typename T , typename R , typename A0 >
Event< void(A0)> event (volatile T *obj, R(T::*method)(A0) volatile)
 Creates an event bound to the event queue.
template<typename T , typename R , typename A0 >
Event< void(A0)> event (const volatile T *obj, R(T::*method)(A0) const volatile)
 Creates an event bound to the event queue.
template<typename R , typename B0 , typename C0 , typename A0 >
Event< void(A0)> event (R(*func)(B0, A0), C0 c0)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename C0 , typename A0 >
Event< void(A0)> event (T *obj, R(T::*method)(B0, A0), C0 c0)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename C0 , typename A0 >
Event< void(A0)> event (const T *obj, R(T::*method)(B0, A0) const, C0 c0)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename C0 , typename A0 >
Event< void(A0)> event (volatile T *obj, R(T::*method)(B0, A0) volatile, C0 c0)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename C0 , typename A0 >
Event< void(A0)> event (const volatile T *obj, R(T::*method)(B0, A0) const volatile, C0 c0)
 Creates an event bound to the event queue.
template<typename R , typename B0 , typename B1 , typename C0 , typename C1 , typename A0 >
Event< void(A0)> event (R(*func)(B0, B1, A0), C0 c0, C1 c1)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename C0 , typename C1 , typename A0 >
Event< void(A0)> event (T *obj, R(T::*method)(B0, B1, A0), C0 c0, C1 c1)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename C0 , typename C1 , typename A0 >
Event< void(A0)> event (const T *obj, R(T::*method)(B0, B1, A0) const, C0 c0, C1 c1)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename C0 , typename C1 , typename A0 >
Event< void(A0)> event (volatile T *obj, R(T::*method)(B0, B1, A0) volatile, C0 c0, C1 c1)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename C0 , typename C1 , typename A0 >
Event< void(A0)> event (const volatile T *obj, R(T::*method)(B0, B1, A0) const volatile, C0 c0, C1 c1)
 Creates an event bound to the event queue.
template<typename R , typename B0 , typename B1 , typename B2 , typename C0 , typename C1 , typename C2 , typename A0 >
Event< void(A0)> event (R(*func)(B0, B1, B2, A0), C0 c0, C1 c1, C2 c2)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename C0 , typename C1 , typename C2 , typename A0 >
Event< void(A0)> event (T *obj, R(T::*method)(B0, B1, B2, A0), C0 c0, C1 c1, C2 c2)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename C0 , typename C1 , typename C2 , typename A0 >
Event< void(A0)> event (const T *obj, R(T::*method)(B0, B1, B2, A0) const, C0 c0, C1 c1, C2 c2)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename C0 , typename C1 , typename C2 , typename A0 >
Event< void(A0)> event (volatile T *obj, R(T::*method)(B0, B1, B2, A0) volatile, C0 c0, C1 c1, C2 c2)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename C0 , typename C1 , typename C2 , typename A0 >
Event< void(A0)> event (const volatile T *obj, R(T::*method)(B0, B1, B2, A0) const volatile, C0 c0, C1 c1, C2 c2)
 Creates an event bound to the event queue.
template<typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename C0 , typename C1 , typename C2 , typename C3 , typename A0 >
Event< void(A0)> event (R(*func)(B0, B1, B2, B3, A0), C0 c0, C1 c1, C2 c2, C3 c3)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename C0 , typename C1 , typename C2 , typename C3 , typename A0 >
Event< void(A0)> event (T *obj, R(T::*method)(B0, B1, B2, B3, A0), C0 c0, C1 c1, C2 c2, C3 c3)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename C0 , typename C1 , typename C2 , typename C3 , typename A0 >
Event< void(A0)> event (const T *obj, R(T::*method)(B0, B1, B2, B3, A0) const, C0 c0, C1 c1, C2 c2, C3 c3)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename C0 , typename C1 , typename C2 , typename C3 , typename A0 >
Event< void(A0)> event (volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0) volatile, C0 c0, C1 c1, C2 c2, C3 c3)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename C0 , typename C1 , typename C2 , typename C3 , typename A0 >
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)
 Creates an event bound to the event queue.
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 >
Event< void(A0)> event (R(*func)(B0, B1, B2, B3, B4, A0), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
template<typename R , typename A0 , typename A1 >
Event< void(A0, A1)> event (R(*func)(A0, A1))
 Creates an event bound to the event queue.
template<typename T , typename R , typename A0 , typename A1 >
Event< void(A0, A1)> event (T *obj, R(T::*method)(A0, A1))
 Creates an event bound to the event queue.
template<typename T , typename R , typename A0 , typename A1 >
Event< void(A0, A1)> event (const T *obj, R(T::*method)(A0, A1) const)
 Creates an event bound to the event queue.
template<typename T , typename R , typename A0 , typename A1 >
Event< void(A0, A1)> event (volatile T *obj, R(T::*method)(A0, A1) volatile)
 Creates an event bound to the event queue.
template<typename T , typename R , typename A0 , typename A1 >
Event< void(A0, A1)> event (const volatile T *obj, R(T::*method)(A0, A1) const volatile)
 Creates an event bound to the event queue.
template<typename R , typename B0 , typename C0 , typename A0 , typename A1 >
Event< void(A0, A1)> event (R(*func)(B0, A0, A1), C0 c0)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename C0 , typename A0 , typename A1 >
Event< void(A0, A1)> event (T *obj, R(T::*method)(B0, A0, A1), C0 c0)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename C0 , typename A0 , typename A1 >
Event< void(A0, A1)> event (const T *obj, R(T::*method)(B0, A0, A1) const, C0 c0)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename C0 , typename A0 , typename A1 >
Event< void(A0, A1)> event (volatile T *obj, R(T::*method)(B0, A0, A1) volatile, C0 c0)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename C0 , typename A0 , typename A1 >
Event< void(A0, A1)> event (const volatile T *obj, R(T::*method)(B0, A0, A1) const volatile, C0 c0)
 Creates an event bound to the event queue.
template<typename R , typename B0 , typename B1 , typename C0 , typename C1 , typename A0 , typename A1 >
Event< void(A0, A1)> event (R(*func)(B0, B1, A0, A1), C0 c0, C1 c1)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename C0 , typename C1 , typename A0 , typename A1 >
Event< void(A0, A1)> event (T *obj, R(T::*method)(B0, B1, A0, A1), C0 c0, C1 c1)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename C0 , typename C1 , typename A0 , typename A1 >
Event< void(A0, A1)> event (const T *obj, R(T::*method)(B0, B1, A0, A1) const, C0 c0, C1 c1)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename C0 , typename C1 , typename A0 , typename A1 >
Event< void(A0, A1)> event (volatile T *obj, R(T::*method)(B0, B1, A0, A1) volatile, C0 c0, C1 c1)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename C0 , typename C1 , typename A0 , typename A1 >
Event< void(A0, A1)> event (const volatile T *obj, R(T::*method)(B0, B1, A0, A1) const volatile, C0 c0, C1 c1)
 Creates an event bound to the event queue.
template<typename R , typename B0 , typename B1 , typename B2 , typename C0 , typename C1 , typename C2 , typename A0 , typename A1 >
Event< void(A0, A1)> event (R(*func)(B0, B1, B2, A0, A1), C0 c0, C1 c1, C2 c2)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename C0 , typename C1 , typename C2 , typename A0 , typename A1 >
Event< void(A0, A1)> event (T *obj, R(T::*method)(B0, B1, B2, A0, A1), C0 c0, C1 c1, C2 c2)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename C0 , typename C1 , typename C2 , typename A0 , typename A1 >
Event< void(A0, A1)> event (const T *obj, R(T::*method)(B0, B1, B2, A0, A1) const, C0 c0, C1 c1, C2 c2)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename C0 , typename C1 , typename C2 , typename A0 , typename A1 >
Event< void(A0, A1)> event (volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1) volatile, C0 c0, C1 c1, C2 c2)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename C0 , typename C1 , typename C2 , typename A0 , typename A1 >
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)
 Creates an event bound to the event queue.
template<typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename C0 , typename C1 , typename C2 , typename C3 , typename A0 , typename A1 >
Event< void(A0, A1)> event (R(*func)(B0, B1, B2, B3, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3)
 Creates an event bound to the event queue.
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 >
Event< void(A0, A1)> event (T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
Event< void(A0, A1)> event (R(*func)(B0, B1, B2, B3, B4, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
template<typename R , typename A0 , typename A1 , typename A2 >
Event< void(A0, A1, A2)> event (R(*func)(A0, A1, A2))
 Creates an event bound to the event queue.
template<typename T , typename R , typename A0 , typename A1 , typename A2 >
Event< void(A0, A1, A2)> event (T *obj, R(T::*method)(A0, A1, A2))
 Creates an event bound to the event queue.
template<typename T , typename R , typename A0 , typename A1 , typename A2 >
Event< void(A0, A1, A2)> event (const T *obj, R(T::*method)(A0, A1, A2) const)
 Creates an event bound to the event queue.
template<typename T , typename R , typename A0 , typename A1 , typename A2 >
Event< void(A0, A1, A2)> event (volatile T *obj, R(T::*method)(A0, A1, A2) volatile)
 Creates an event bound to the event queue.
template<typename T , typename R , typename A0 , typename A1 , typename A2 >
Event< void(A0, A1, A2)> event (const volatile T *obj, R(T::*method)(A0, A1, A2) const volatile)
 Creates an event bound to the event queue.
template<typename R , typename B0 , typename C0 , typename A0 , typename A1 , typename A2 >
Event< void(A0, A1, A2)> event (R(*func)(B0, A0, A1, A2), C0 c0)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename C0 , typename A0 , typename A1 , typename A2 >
Event< void(A0, A1, A2)> event (T *obj, R(T::*method)(B0, A0, A1, A2), C0 c0)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename C0 , typename A0 , typename A1 , typename A2 >
Event< void(A0, A1, A2)> event (const T *obj, R(T::*method)(B0, A0, A1, A2) const, C0 c0)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename C0 , typename A0 , typename A1 , typename A2 >
Event< void(A0, A1, A2)> event (volatile T *obj, R(T::*method)(B0, A0, A1, A2) volatile, C0 c0)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename C0 , typename A0 , typename A1 , typename A2 >
Event< void(A0, A1, A2)> event (const volatile T *obj, R(T::*method)(B0, A0, A1, A2) const volatile, C0 c0)
 Creates an event bound to the event queue.
template<typename R , typename B0 , typename B1 , typename C0 , typename C1 , typename A0 , typename A1 , typename A2 >
Event< void(A0, A1, A2)> event (R(*func)(B0, B1, A0, A1, A2), C0 c0, C1 c1)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename C0 , typename C1 , typename A0 , typename A1 , typename A2 >
Event< void(A0, A1, A2)> event (T *obj, R(T::*method)(B0, B1, A0, A1, A2), C0 c0, C1 c1)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename C0 , typename C1 , typename A0 , typename A1 , typename A2 >
Event< void(A0, A1, A2)> event (const T *obj, R(T::*method)(B0, B1, A0, A1, A2) const, C0 c0, C1 c1)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename C0 , typename C1 , typename A0 , typename A1 , typename A2 >
Event< void(A0, A1, A2)> event (volatile T *obj, R(T::*method)(B0, B1, A0, A1, A2) volatile, C0 c0, C1 c1)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename C0 , typename C1 , typename A0 , typename A1 , typename A2 >
Event< void(A0, A1, A2)> event (const volatile T *obj, R(T::*method)(B0, B1, A0, A1, A2) const volatile, C0 c0, C1 c1)
 Creates an event bound to the event queue.
template<typename R , typename B0 , typename B1 , typename B2 , typename C0 , typename C1 , typename C2 , typename A0 , typename A1 , typename A2 >
Event< void(A0, A1, A2)> event (R(*func)(B0, B1, B2, A0, A1, A2), C0 c0, C1 c1, C2 c2)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename C0 , typename C1 , typename C2 , typename A0 , typename A1 , typename A2 >
Event< void(A0, A1, A2)> event (T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2), C0 c0, C1 c1, C2 c2)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename C0 , typename C1 , typename C2 , typename A0 , typename A1 , typename A2 >
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)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename C0 , typename C1 , typename C2 , typename A0 , typename A1 , typename A2 >
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)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename C0 , typename C1 , typename C2 , typename A0 , typename A1 , typename A2 >
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)
 Creates an event bound to the event queue.
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 >
Event< void(A0, A1, A2)> event (R(*func)(B0, B1, B2, B3, A0, A1, A2), C0 c0, C1 c1, C2 c2, C3 c3)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
template<typename R , typename A0 , typename A1 , typename A2 , typename A3 >
Event< void(A0, A1, A2, A3)> event (R(*func)(A0, A1, A2, A3))
 Creates an event bound to the event queue.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 >
Event< void(A0, A1, A2, A3)> event (T *obj, R(T::*method)(A0, A1, A2, A3))
 Creates an event bound to the event queue.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 >
Event< void(A0, A1, A2, A3)> event (const T *obj, R(T::*method)(A0, A1, A2, A3) const)
 Creates an event bound to the event queue.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 >
Event< void(A0, A1, A2, A3)> event (volatile T *obj, R(T::*method)(A0, A1, A2, A3) volatile)
 Creates an event bound to the event queue.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 >
Event< void(A0, A1, A2, A3)> event (const volatile T *obj, R(T::*method)(A0, A1, A2, A3) const volatile)
 Creates an event bound to the event queue.
template<typename R , typename B0 , typename C0 , typename A0 , typename A1 , typename A2 , typename A3 >
Event< void(A0, A1, A2, A3)> event (R(*func)(B0, A0, A1, A2, A3), C0 c0)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename C0 , typename A0 , typename A1 , typename A2 , typename A3 >
Event< void(A0, A1, A2, A3)> event (T *obj, R(T::*method)(B0, A0, A1, A2, A3), C0 c0)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename C0 , typename A0 , typename A1 , typename A2 , typename A3 >
Event< void(A0, A1, A2, A3)> event (const T *obj, R(T::*method)(B0, A0, A1, A2, A3) const, C0 c0)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename C0 , typename A0 , typename A1 , typename A2 , typename A3 >
Event< void(A0, A1, A2, A3)> event (volatile T *obj, R(T::*method)(B0, A0, A1, A2, A3) volatile, C0 c0)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename C0 , typename A0 , typename A1 , typename A2 , typename A3 >
Event< void(A0, A1, A2, A3)> event (const volatile T *obj, R(T::*method)(B0, A0, A1, A2, A3) const volatile, C0 c0)
 Creates an event bound to the event queue.
template<typename R , typename B0 , typename B1 , typename C0 , typename C1 , typename A0 , typename A1 , typename A2 , typename A3 >
Event< void(A0, A1, A2, A3)> event (R(*func)(B0, B1, A0, A1, A2, A3), C0 c0, C1 c1)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename C0 , typename C1 , typename A0 , typename A1 , typename A2 , typename A3 >
Event< void(A0, A1, A2, A3)> event (T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3), C0 c0, C1 c1)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename C0 , typename C1 , typename A0 , typename A1 , typename A2 , typename A3 >
Event< void(A0, A1, A2, A3)> event (const T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3) const, C0 c0, C1 c1)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename C0 , typename C1 , typename A0 , typename A1 , typename A2 , typename A3 >
Event< void(A0, A1, A2, A3)> event (volatile T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3) volatile, C0 c0, C1 c1)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename C0 , typename C1 , typename A0 , typename A1 , typename A2 , typename A3 >
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)
 Creates an event bound to the event queue.
template<typename R , typename B0 , typename B1 , typename B2 , typename C0 , typename C1 , typename C2 , typename A0 , typename A1 , typename A2 , typename A3 >
Event< void(A0, A1, A2, A3)> event (R(*func)(B0, B1, B2, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
Event< void(A0, A1, A2, A3, A4)> event (R(*func)(A0, A1, A2, A3, A4))
 Creates an event bound to the event queue.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
Event< void(A0, A1, A2, A3, A4)> event (T *obj, R(T::*method)(A0, A1, A2, A3, A4))
 Creates an event bound to the event queue.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
Event< void(A0, A1, A2, A3, A4)> event (const T *obj, R(T::*method)(A0, A1, A2, A3, A4) const)
 Creates an event bound to the event queue.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
Event< void(A0, A1, A2, A3, A4)> event (volatile T *obj, R(T::*method)(A0, A1, A2, A3, A4) volatile)
 Creates an event bound to the event queue.
template<typename T , typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
Event< void(A0, A1, A2, A3, A4)> event (const volatile T *obj, R(T::*method)(A0, A1, A2, A3, A4) const volatile)
 Creates an event bound to the event queue.
template<typename R , typename B0 , typename C0 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
Event< void(A0, A1, A2, A3, A4)> event (R(*func)(B0, A0, A1, A2, A3, A4), C0 c0)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename C0 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
Event< void(A0, A1, A2, A3, A4)> event (T *obj, R(T::*method)(B0, A0, A1, A2, A3, A4), C0 c0)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename C0 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
Event< void(A0, A1, A2, A3, A4)> event (const T *obj, R(T::*method)(B0, A0, A1, A2, A3, A4) const, C0 c0)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename C0 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
Event< void(A0, A1, A2, A3, A4)> event (volatile T *obj, R(T::*method)(B0, A0, A1, A2, A3, A4) volatile, C0 c0)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename C0 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
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)
 Creates an event bound to the event queue.
template<typename R , typename B0 , typename B1 , typename C0 , typename C1 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
Event< void(A0, A1, A2, A3, A4)> event (R(*func)(B0, B1, A0, A1, A2, A3, A4), C0 c0, C1 c1)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename C0 , typename C1 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
Event< void(A0, A1, A2, A3, A4)> event (T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3, A4), C0 c0, C1 c1)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename C0 , typename C1 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
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)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename C0 , typename C1 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
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)
 Creates an event bound to the event queue.
template<typename T , typename R , typename B0 , typename B1 , typename C0 , typename C1 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
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)
 Creates an event bound to the event queue.
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 >
Event< void(A0, A1, A2, A3, A4)> event (R(*func)(B0, B1, B2, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.
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 >
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)
 Creates an event bound to the event queue.

Function Documentation

void background ( mbed::Callback< void(int)>  update ) [inherited]

Background an event queue onto a single-shot timer-interrupt.

When updated, the event queue will call the provided update function with a timeout indicating when the queue should be dispatched. A negative timeout will be passed to the update function when the timer-interrupt is no longer needed.

Passing a null function disables the existing update function.

The background function allows an event queue to take advantage of hardware timers or other event loops, allowing an event queue to be ran in the background without consuming the foreground thread.

Parameters:
updateFunction called to indicate when the queue should be dispatched
void break_dispatch (  ) [inherited]

Break out of a running event loop.

Forces the specified event queue's dispatch loop to terminate. Pending events may finish executing, but no new events will be executed.

void call ( A0  a0 ) const [inherited]

Posts an event onto the underlying event queue, returning void.

Parameters:
a0..a4Arguments to pass to the event

Definition at line 542 of file Event.h.

void call ( A0  a0,
A1  a1,
A2  a2 
) const [inherited]

Posts an event onto the underlying event queue, returning void.

Parameters:
a0..a4Arguments to pass to the event

Definition at line 1328 of file Event.h.

int call ( F  f ) [inherited]

Calls an event on the queue.

The specified callback will be executed in the context of the event queue's dispatch loop.

The call function is irq safe and can act as a mechanism for moving events out of irq contexts.

Parameters:
fFunction to execute in the context of the dispatch loop
a0..a4Arguments to pass to the callback
Returns:
A unique id that represents the posted event and can be passed to cancel, or an id of 0 if there is not enough memory to allocate the event.

Definition at line 176 of file EventQueue.h.

int call ( F  f,
A0  a0 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 191 of file EventQueue.h.

int call ( F  f,
A0  a0,
A1  a1 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 199 of file EventQueue.h.

int call ( F  f,
A0  a0,
A1  a1,
A2  a2 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 207 of file EventQueue.h.

int call ( F  f,
A0  a0,
A1  a1,
A2  a2,
A3  a3 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 215 of file EventQueue.h.

int call ( F  f,
A0  a0,
A1  a1,
A2  a2,
A3  a3,
A4  a4 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 223 of file EventQueue.h.

int call ( T *  obj,
R(T::*)()  method 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 231 of file EventQueue.h.

int call ( const T *  obj,
R(T::*)() const   method 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 239 of file EventQueue.h.

int call ( volatile T *  obj,
R(T::*)() volatile  method 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 247 of file EventQueue.h.

int call ( const volatile T *  obj,
R(T::*)() const volatile  method 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 255 of file EventQueue.h.

int call ( T *  obj,
R(T::*)(A0)  method,
A0  a0 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 263 of file EventQueue.h.

int call ( const T *  obj,
R(T::*)(A0) const   method,
A0  a0 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 271 of file EventQueue.h.

int call ( volatile T *  obj,
R(T::*)(A0) volatile  method,
A0  a0 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 279 of file EventQueue.h.

int call ( const volatile T *  obj,
R(T::*)(A0) const volatile  method,
A0  a0 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 287 of file EventQueue.h.

int call ( T *  obj,
R(T::*)(A0, A1)  method,
A0  a0,
A1  a1 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 295 of file EventQueue.h.

int call ( const T *  obj,
R(T::*)(A0, A1) const   method,
A0  a0,
A1  a1 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 303 of file EventQueue.h.

int call ( volatile T *  obj,
R(T::*)(A0, A1) volatile  method,
A0  a0,
A1  a1 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 311 of file EventQueue.h.

int call ( const volatile T *  obj,
R(T::*)(A0, A1) const volatile  method,
A0  a0,
A1  a1 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 319 of file EventQueue.h.

int call ( T *  obj,
R(T::*)(A0, A1, A2)  method,
A0  a0,
A1  a1,
A2  a2 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 327 of file EventQueue.h.

int call ( const T *  obj,
R(T::*)(A0, A1, A2) const   method,
A0  a0,
A1  a1,
A2  a2 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 335 of file EventQueue.h.

int call ( volatile T *  obj,
R(T::*)(A0, A1, A2) volatile  method,
A0  a0,
A1  a1,
A2  a2 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 343 of file EventQueue.h.

int call ( const volatile T *  obj,
R(T::*)(A0, A1, A2) const volatile  method,
A0  a0,
A1  a1,
A2  a2 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 351 of file EventQueue.h.

int call ( T *  obj,
R(T::*)(A0, A1, A2, A3)  method,
A0  a0,
A1  a1,
A2  a2,
A3  a3 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 359 of file EventQueue.h.

int call ( const T *  obj,
R(T::*)(A0, A1, A2, A3) const   method,
A0  a0,
A1  a1,
A2  a2,
A3  a3 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 367 of file EventQueue.h.

int call ( volatile T *  obj,
R(T::*)(A0, A1, A2, A3) volatile  method,
A0  a0,
A1  a1,
A2  a2,
A3  a3 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 375 of file EventQueue.h.

int call ( const volatile T *  obj,
R(T::*)(A0, A1, A2, A3) const volatile  method,
A0  a0,
A1  a1,
A2  a2,
A3  a3 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 383 of file EventQueue.h.

int call ( T *  obj,
R(T::*)(A0, A1, A2, A3, A4)  method,
A0  a0,
A1  a1,
A2  a2,
A3  a3,
A4  a4 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 391 of file EventQueue.h.

int call ( const T *  obj,
R(T::*)(A0, A1, A2, A3, A4) const   method,
A0  a0,
A1  a1,
A2  a2,
A3  a3,
A4  a4 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 399 of file EventQueue.h.

int call ( volatile T *  obj,
R(T::*)(A0, A1, A2, A3, A4) volatile  method,
A0  a0,
A1  a1,
A2  a2,
A3  a3,
A4  a4 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 407 of file EventQueue.h.

int call ( const volatile T *  obj,
R(T::*)(A0, A1, A2, A3, A4) const volatile  method,
A0  a0,
A1  a1,
A2  a2,
A3  a3,
A4  a4 
) [inherited]

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 415 of file EventQueue.h.

void call ( A0  a0,
A1  a1,
A2  a2,
A3  a3 
) const [inherited]

Posts an event onto the underlying event queue, returning void.

Parameters:
a0..a4Arguments to pass to the event

Definition at line 1721 of file Event.h.

void call ( A0  a0,
A1  a1,
A2  a2,
A3  a3,
A4  a4 
) const [inherited]

Posts an event onto the underlying event queue, returning void.

Parameters:
a0..a4Arguments to pass to the event

Definition at line 2114 of file Event.h.

void call (  ) const [inherited]

Posts an event onto the underlying event queue, returning void.

Parameters:
a0..a4Arguments to pass to the event

Definition at line 149 of file Event.h.

void call ( A0  a0,
A1  a1 
) const [inherited]

Posts an event onto the underlying event queue, returning void.

Parameters:
a0..a4Arguments to pass to the event

Definition at line 935 of file Event.h.

int call_every ( int  ms,
F  f 
) [inherited]

Calls an event on the queue periodically.

The specified callback will be executed in the context of the event queue's dispatch loop.

The call_every function is irq safe and can act as a mechanism for moving events out of irq contexts.

Parameters:
fFunction to execute in the context of the dispatch loop
a0..a4Arguments to pass to the callback
msPeriod of the event in milliseconds
Returns:
A unique id that represents the posted event and can be passed to cancel, or an id of 0 if there is not enough memory to allocate the event.

Definition at line 695 of file EventQueue.h.

int call_every ( int  ms,
F  f,
A0  a0 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 712 of file EventQueue.h.

int call_every ( int  ms,
F  f,
A0  a0,
A1  a1 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 720 of file EventQueue.h.

int call_every ( int  ms,
F  f,
A0  a0,
A1  a1,
A2  a2 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 728 of file EventQueue.h.

int call_every ( int  ms,
F  f,
A0  a0,
A1  a1,
A2  a2,
A3  a3 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 736 of file EventQueue.h.

int call_every ( int  ms,
F  f,
A0  a0,
A1  a1,
A2  a2,
A3  a3,
A4  a4 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 744 of file EventQueue.h.

int call_every ( int  ms,
T *  obj,
R(T::*)()  method 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 752 of file EventQueue.h.

int call_every ( int  ms,
const T *  obj,
R(T::*)() const   method 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 760 of file EventQueue.h.

int call_every ( int  ms,
volatile T *  obj,
R(T::*)() volatile  method 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 768 of file EventQueue.h.

int call_every ( int  ms,
const volatile T *  obj,
R(T::*)() const volatile  method 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 776 of file EventQueue.h.

int call_every ( int  ms,
T *  obj,
R(T::*)(A0)  method,
A0  a0 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 784 of file EventQueue.h.

int call_every ( int  ms,
const T *  obj,
R(T::*)(A0) const   method,
A0  a0 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 792 of file EventQueue.h.

int call_every ( int  ms,
volatile T *  obj,
R(T::*)(A0) volatile  method,
A0  a0 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 800 of file EventQueue.h.

int call_every ( int  ms,
const volatile T *  obj,
R(T::*)(A0) const volatile  method,
A0  a0 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 808 of file EventQueue.h.

int call_every ( int  ms,
T *  obj,
R(T::*)(A0, A1)  method,
A0  a0,
A1  a1 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 816 of file EventQueue.h.

int call_every ( int  ms,
const T *  obj,
R(T::*)(A0, A1) const   method,
A0  a0,
A1  a1 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 824 of file EventQueue.h.

int call_every ( int  ms,
volatile T *  obj,
R(T::*)(A0, A1) volatile  method,
A0  a0,
A1  a1 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 832 of file EventQueue.h.

int call_every ( int  ms,
const volatile T *  obj,
R(T::*)(A0, A1) const volatile  method,
A0  a0,
A1  a1 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 840 of file EventQueue.h.

int call_every ( int  ms,
T *  obj,
R(T::*)(A0, A1, A2)  method,
A0  a0,
A1  a1,
A2  a2 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 848 of file EventQueue.h.

int call_every ( int  ms,
const T *  obj,
R(T::*)(A0, A1, A2) const   method,
A0  a0,
A1  a1,
A2  a2 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 856 of file EventQueue.h.

int call_every ( int  ms,
volatile T *  obj,
R(T::*)(A0, A1, A2) volatile  method,
A0  a0,
A1  a1,
A2  a2 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 864 of file EventQueue.h.

int call_every ( int  ms,
const volatile T *  obj,
R(T::*)(A0, A1, A2) const volatile  method,
A0  a0,
A1  a1,
A2  a2 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 872 of file EventQueue.h.

int call_every ( int  ms,
T *  obj,
R(T::*)(A0, A1, A2, A3)  method,
A0  a0,
A1  a1,
A2  a2,
A3  a3 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 880 of file EventQueue.h.

int call_every ( int  ms,
const T *  obj,
R(T::*)(A0, A1, A2, A3) const   method,
A0  a0,
A1  a1,
A2  a2,
A3  a3 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 888 of file EventQueue.h.

int call_every ( int  ms,
volatile T *  obj,
R(T::*)(A0, A1, A2, A3) volatile  method,
A0  a0,
A1  a1,
A2  a2,
A3  a3 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 896 of file EventQueue.h.

int call_every ( int  ms,
const volatile T *  obj,
R(T::*)(A0, A1, A2, A3) const volatile  method,
A0  a0,
A1  a1,
A2  a2,
A3  a3 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 904 of file EventQueue.h.

int call_every ( int  ms,
T *  obj,
R(T::*)(A0, A1, A2, A3, A4)  method,
A0  a0,
A1  a1,
A2  a2,
A3  a3,
A4  a4 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 912 of file EventQueue.h.

int call_every ( int  ms,
const T *  obj,
R(T::*)(A0, A1, A2, A3, A4) const   method,
A0  a0,
A1  a1,
A2  a2,
A3  a3,
A4  a4 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 920 of file EventQueue.h.

int call_every ( int  ms,
volatile T *  obj,
R(T::*)(A0, A1, A2, A3, A4) volatile  method,
A0  a0,
A1  a1,
A2  a2,
A3  a3,
A4  a4 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 928 of file EventQueue.h.

int call_every ( int  ms,
const volatile T *  obj,
R(T::*)(A0, A1, A2, A3, A4) const volatile  method,
A0  a0,
A1  a1,
A2  a2,
A3  a3,
A4  a4 
) [inherited]

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 936 of file EventQueue.h.

int call_in ( int  ms,
F  f 
) [inherited]

Calls an event on the queue after a specified delay.

The specified callback will be executed in the context of the event queue's dispatch loop.

The call_in function is irq safe and can act as a mechanism for moving events out of irq contexts.

Parameters:
fFunction to execute in the context of the dispatch loop
a0..a4Arguments to pass to the callback
msTime to delay in milliseconds
Returns:
A unique id that represents the posted event and can be passed to cancel, or an id of 0 if there is not enough memory to allocate the event.

Definition at line 435 of file EventQueue.h.

int call_in ( int  ms,
F  f,
A0  a0,
A1  a1 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 459 of file EventQueue.h.

int call_in ( int  ms,
F  f,
A0  a0,
A1  a1,
A2  a2 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 467 of file EventQueue.h.

int call_in ( int  ms,
F  f,
A0  a0,
A1  a1,
A2  a2,
A3  a3 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 475 of file EventQueue.h.

int call_in ( int  ms,
F  f,
A0  a0,
A1  a1,
A2  a2,
A3  a3,
A4  a4 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 483 of file EventQueue.h.

int call_in ( int  ms,
T *  obj,
R(T::*)()  method 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 491 of file EventQueue.h.

int call_in ( int  ms,
const T *  obj,
R(T::*)() const   method 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 499 of file EventQueue.h.

int call_in ( int  ms,
volatile T *  obj,
R(T::*)() volatile  method 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 507 of file EventQueue.h.

int call_in ( int  ms,
const volatile T *  obj,
R(T::*)() const volatile  method 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 515 of file EventQueue.h.

int call_in ( int  ms,
T *  obj,
R(T::*)(A0)  method,
A0  a0 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 523 of file EventQueue.h.

int call_in ( int  ms,
const T *  obj,
R(T::*)(A0) const   method,
A0  a0 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 531 of file EventQueue.h.

int call_in ( int  ms,
volatile T *  obj,
R(T::*)(A0) volatile  method,
A0  a0 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 539 of file EventQueue.h.

int call_in ( int  ms,
const volatile T *  obj,
R(T::*)(A0) const volatile  method,
A0  a0 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 547 of file EventQueue.h.

int call_in ( int  ms,
T *  obj,
R(T::*)(A0, A1)  method,
A0  a0,
A1  a1 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 555 of file EventQueue.h.

int call_in ( int  ms,
const T *  obj,
R(T::*)(A0, A1) const   method,
A0  a0,
A1  a1 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 563 of file EventQueue.h.

int call_in ( int  ms,
volatile T *  obj,
R(T::*)(A0, A1) volatile  method,
A0  a0,
A1  a1 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 571 of file EventQueue.h.

int call_in ( int  ms,
T *  obj,
R(T::*)(A0, A1, A2)  method,
A0  a0,
A1  a1,
A2  a2 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 587 of file EventQueue.h.

int call_in ( int  ms,
const T *  obj,
R(T::*)(A0, A1, A2) const   method,
A0  a0,
A1  a1,
A2  a2 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 595 of file EventQueue.h.

int call_in ( int  ms,
volatile T *  obj,
R(T::*)(A0, A1, A2) volatile  method,
A0  a0,
A1  a1,
A2  a2 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 603 of file EventQueue.h.

int call_in ( int  ms,
const volatile T *  obj,
R(T::*)(A0, A1, A2) const volatile  method,
A0  a0,
A1  a1,
A2  a2 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 611 of file EventQueue.h.

int call_in ( int  ms,
T *  obj,
R(T::*)(A0, A1, A2, A3)  method,
A0  a0,
A1  a1,
A2  a2,
A3  a3 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 619 of file EventQueue.h.

int call_in ( int  ms,
const T *  obj,
R(T::*)(A0, A1, A2, A3) const   method,
A0  a0,
A1  a1,
A2  a2,
A3  a3 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 627 of file EventQueue.h.

int call_in ( int  ms,
volatile T *  obj,
R(T::*)(A0, A1, A2, A3) volatile  method,
A0  a0,
A1  a1,
A2  a2,
A3  a3 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 635 of file EventQueue.h.

int call_in ( int  ms,
T *  obj,
R(T::*)(A0, A1, A2, A3, A4)  method,
A0  a0,
A1  a1,
A2  a2,
A3  a3,
A4  a4 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 651 of file EventQueue.h.

int call_in ( int  ms,
const T *  obj,
R(T::*)(A0, A1, A2, A3, A4) const   method,
A0  a0,
A1  a1,
A2  a2,
A3  a3,
A4  a4 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 659 of file EventQueue.h.

int call_in ( int  ms,
volatile T *  obj,
R(T::*)(A0, A1, A2, A3, A4) volatile  method,
A0  a0,
A1  a1,
A2  a2,
A3  a3,
A4  a4 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 667 of file EventQueue.h.

int call_in ( int  ms,
F  f,
A0  a0 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 451 of file EventQueue.h.

int call_in ( int  ms,
const volatile T *  obj,
R(T::*)(A0, A1, A2, A3, A4) const volatile  method,
A0  a0,
A1  a1,
A2  a2,
A3  a3,
A4  a4 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 675 of file EventQueue.h.

int call_in ( int  ms,
const volatile T *  obj,
R(T::*)(A0, A1) const volatile  method,
A0  a0,
A1  a1 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 579 of file EventQueue.h.

int call_in ( int  ms,
const volatile T *  obj,
R(T::*)(A0, A1, A2, A3) const volatile  method,
A0  a0,
A1  a1,
A2  a2,
A3  a3 
) [inherited]

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 643 of file EventQueue.h.

void cancel (  ) const [inherited]

Cancels the most recently posted event.

Attempts to cancel the most recently posted event. It is safe to call cancel after an event has already been dispatched.

The cancel function is irq safe.

If called while the event queue's dispatch loop is active, the cancel function does not garuntee that the event will not execute after it returns, as the event may have already begun executing.

Definition at line 1361 of file Event.h.

void cancel (  ) const [inherited]

Cancels the most recently posted event.

Attempts to cancel the most recently posted event. It is safe to call cancel after an event has already been dispatched.

The cancel function is irq safe.

If called while the event queue's dispatch loop is active, the cancel function does not garuntee that the event will not execute after it returns, as the event may have already begun executing.

Definition at line 182 of file Event.h.

void cancel (  ) const [inherited]

Cancels the most recently posted event.

Attempts to cancel the most recently posted event. It is safe to call cancel after an event has already been dispatched.

The cancel function is irq safe.

If called while the event queue's dispatch loop is active, the cancel function does not garuntee that the event will not execute after it returns, as the event may have already begun executing.

Definition at line 575 of file Event.h.

void cancel (  ) const [inherited]

Cancels the most recently posted event.

Attempts to cancel the most recently posted event. It is safe to call cancel after an event has already been dispatched.

The cancel function is irq safe.

If called while the event queue's dispatch loop is active, the cancel function does not garuntee that the event will not execute after it returns, as the event may have already begun executing.

Definition at line 1754 of file Event.h.

void cancel (  ) const [inherited]

Cancels the most recently posted event.

Attempts to cancel the most recently posted event. It is safe to call cancel after an event has already been dispatched.

The cancel function is irq safe.

If called while the event queue's dispatch loop is active, the cancel function does not garuntee that the event will not execute after it returns, as the event may have already begun executing.

Definition at line 968 of file Event.h.

void cancel (  ) const [inherited]

Cancels the most recently posted event.

Attempts to cancel the most recently posted event. It is safe to call cancel after an event has already been dispatched.

The cancel function is irq safe.

If called while the event queue's dispatch loop is active, the cancel function does not garuntee that the event will not execute after it returns, as the event may have already begun executing.

Definition at line 2147 of file Event.h.

void cancel ( int  id ) [inherited]

Cancel an in-flight event.

Attempts to cancel an event referenced by the unique id returned from one of the call functions. It is safe to call cancel after an event has already been dispatched.

The cancel function is irq safe.

If called while the event queue's dispatch loop is active, the cancel function does not garuntee that the event will not execute after it returns, as the event may have already begun executing.

Parameters:
idUnique id of the event
void chain ( EventQueue *  target ) [inherited]

Chain an event queue onto another event queue.

After chaining a queue to a target, calling dispatch on the target queue will also dispatch events from this queue. The queues use their own buffers and events must be handled independently.

A null queue as the target will unchain the existing queue.

The chain function allows multiple event queues to be composed, sharing the context of a dispatch loop while still being managed independently

Parameters:
targetQueue that will dispatch this queue's events as a part of its dispatch loop
void delay ( int  delay ) [inherited]

Configure the delay of an event.

Parameters:
delayMillisecond delay before dispatching the event

Definition at line 107 of file Event.h.

void delay ( int  delay ) [inherited]

Configure the delay of an event.

Parameters:
delayMillisecond delay before dispatching the event

Definition at line 1286 of file Event.h.

void delay ( int  delay ) [inherited]

Configure the delay of an event.

Parameters:
delayMillisecond delay before dispatching the event

Definition at line 500 of file Event.h.

void delay ( int  delay ) [inherited]

Configure the delay of an event.

Parameters:
delayMillisecond delay before dispatching the event

Definition at line 1679 of file Event.h.

void delay ( int  delay ) [inherited]

Configure the delay of an event.

Parameters:
delayMillisecond delay before dispatching the event

Definition at line 2072 of file Event.h.

void delay ( int  delay ) [inherited]

Configure the delay of an event.

Parameters:
delayMillisecond delay before dispatching the event

Definition at line 893 of file Event.h.

void dispatch ( int  ms = -1 ) [inherited]

Dispatch events.

Executes events until the specified milliseconds have passed. If ms is negative, the dispatch function will dispatch events indefinitely or until break_dispatch is called on this queue.

When called with a finite timeout, the dispatch function is guaranteed to terminate. When called with a timeout of 0, the dispatch function does not wait and is irq safe.

Parameters:
msTime to wait for events in milliseconds, a negative value will dispatch events indefinitely (default to -1)
void dispatch_forever (  ) [inherited]

Dispatch events without a timeout.

This is equivalent to EventQueue::dispatch with no arguments, but avoids overload ambiguities when passed as a callback.

See also:
EventQueue::dispatch

Definition at line 91 of file EventQueue.h.

Event< void(A0, A1)> event ( volatile T *  obj,
R(T::*)(B0, B1, B2, A0, A1) volatile  method,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2786 of file Event.h.

Event< void(A0, A1)> event ( volatile T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1) volatile  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2811 of file Event.h.

Event< void(A0, A1)> event ( T *  obj,
R(T::*)(B0, B1, B2, A0, A1)  method,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2776 of file Event.h.

Event< void(A0, A1)> event ( R(*)(B0, B1, B2, A0, A1)  func,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2771 of file Event.h.

Event< void(A0, A1)> event ( const volatile T *  obj,
R(T::*)(B0, B1, A0, A1) const volatile  method,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2766 of file Event.h.

Event< void(A0, A1, A2)> event ( R(*)(B0, B1, A0, A1, A2)  func,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2896 of file Event.h.

Event< void(A0, A1)> event ( const T *  obj,
R(T::*)(B0, B1, A0, A1) const   method,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2756 of file Event.h.

Event< void(A0, A1)> event ( T *  obj,
R(T::*)(B0, B1, A0, A1)  method,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2751 of file Event.h.

Event< void(A0, A1, A2)> event ( volatile T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1, A2) volatile  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2961 of file Event.h.

Event ( const Event< void(A0)> &  e ) [inherited]

Copy constructor for events.

Definition at line 465 of file Event.h.

Event< void(A0, A1)> event ( volatile T *  obj,
R(T::*)(B0, A0, A1) volatile  method,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2736 of file Event.h.

Event< void(A0, A1)> event ( const T *  obj,
R(T::*)(B0, A0, A1) const   method,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2731 of file Event.h.

Event< void(A0, A1)> event ( T *  obj,
R(T::*)(B0, A0, A1)  method,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2726 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( R(*)(B0, B1, B2, A0, A1, A2, A3, A4)  func,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3221 of file Event.h.

Event< void(A0, A1)> event ( const volatile T *  obj,
R(T::*)(A0, A1) const volatile  method 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2716 of file Event.h.

Event< void(A0, A1)> event ( volatile T *  obj,
R(T::*)(A0, A1) volatile  method 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2711 of file Event.h.

Event< void(A0, A1)> event ( const T *  obj,
R(T::*)(A0, A1) const   method 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2706 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, B1, B2, A0, A1) volatile  method,
B0  b0,
B1  b1,
B2  b2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1135 of file Event.h.

Event< void(A0, A1)> event ( R(*)(A0, A1)  func ) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2696 of file Event.h.

Event< void(A0)> event ( const volatile T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0) const volatile  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2691 of file Event.h.

Event< void(A0)> event ( volatile T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0) volatile  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2686 of file Event.h.

Event< void(A0)> event ( const T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0) const   method,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2681 of file Event.h.

Event< void(A0)> event ( T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0)  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2676 of file Event.h.

Event< void(A0)> event ( R(*)(B0, B1, B2, B3, B4, A0)  func,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2671 of file Event.h.

Event< void(A0)> event ( const volatile T *  obj,
R(T::*)(B0, B1, B2, B3, A0) const volatile  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2666 of file Event.h.

Event< void(A0)> event ( volatile T *  obj,
R(T::*)(B0, B1, B2, B3, A0) volatile  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2661 of file Event.h.

Event< void(A0)> event ( const T *  obj,
R(T::*)(B0, B1, B2, B3, A0) const   method,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2656 of file Event.h.

Event< void(A0)> event ( T *  obj,
R(T::*)(B0, B1, B2, B3, A0)  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2651 of file Event.h.

Event< void(A0)> event ( R(*)(B0, B1, B2, B3, A0)  func,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2646 of file Event.h.

Event< void(A0)> event ( const volatile T *  obj,
R(T::*)(B0, B1, B2, A0) const volatile  method,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2641 of file Event.h.

Event< void(A0)> event ( volatile T *  obj,
R(T::*)(B0, B1, B2, A0) volatile  method,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2636 of file Event.h.

Event< void(A0)> event ( const T *  obj,
R(T::*)(B0, B1, B2, A0) const   method,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2631 of file Event.h.

Event< void(A0)> event ( T *  obj,
R(T::*)(B0, B1, B2, A0)  method,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2626 of file Event.h.

Event< void(A0)> event ( R(*)(B0, B1, B2, A0)  func,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2621 of file Event.h.

Event< void(A0)> event ( const volatile T *  obj,
R(T::*)(B0, B1, A0) const volatile  method,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2616 of file Event.h.

Event< void(A0)> event ( volatile T *  obj,
R(T::*)(B0, B1, A0) volatile  method,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2611 of file Event.h.

Event< void(A0)> event ( const T *  obj,
R(T::*)(B0, B1, A0) const   method,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2606 of file Event.h.

Event< void(A0)> event ( T *  obj,
R(T::*)(B0, B1, A0)  method,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2601 of file Event.h.

Event< void(A0)> event ( R(*)(B0, B1, A0)  func,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2596 of file Event.h.

Event< void(A0)> event ( const volatile T *  obj,
R(T::*)(B0, A0) const volatile  method,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2591 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( volatile T *  obj,
R(T::*)(A0, A1, A2, A3) volatile  method 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3011 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, B1, B2, A0, A1) const volatile  method,
B0  b0,
B1  b1,
B2  b2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1143 of file Event.h.

Event< void(A0)> event ( T *  obj,
R(T::*)(B0, A0)  method,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2576 of file Event.h.

Event< void(A0)> event ( R(*)(B0, A0)  func,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2571 of file Event.h.

Event< void(A0)> event ( const volatile T *  obj,
R(T::*)(A0) const volatile  method 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2566 of file Event.h.

Event< void(A0)> event ( volatile T *  obj,
R(T::*)(A0) volatile  method 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2561 of file Event.h.

Event< void(A0)> event ( const T *  obj,
R(T::*)(A0) const   method 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2556 of file Event.h.

Event< void(A0)> event ( T *  obj,
R(T::*)(A0)  method 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2551 of file Event.h.

Event< void(A0)> event ( R(*)(A0)  func ) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2546 of file Event.h.

Event< void()> event ( const volatile T *  obj,
R(T::*)(B0, B1, B2, B3, B4) const volatile  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2541 of file Event.h.

Event< void()> event ( volatile T *  obj,
R(T::*)(B0, B1, B2, B3, B4) volatile  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2536 of file Event.h.

Event< void()> event ( const T *  obj,
R(T::*)(B0, B1, B2, B3, B4) const   method,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2531 of file Event.h.

Event< void()> event ( T *  obj,
R(T::*)(B0, B1, B2, B3, B4)  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2526 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1, A2, A3, A4)  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3251 of file Event.h.

Event< void()> event ( const volatile T *  obj,
R(T::*)(B0, B1, B2, B3) const volatile  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2516 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( volatile T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1, A2, A3, A4) volatile  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3261 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( const volatile T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1, A2, A3, A4) const volatile  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3266 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1)  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1151 of file Event.h.

Event< void()> event ( R(*)(B0, B1, B2, B3)  func,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2496 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1) const   method,
B0  b0,
B1  b1,
B2  b2,
B3  b3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1159 of file Event.h.

Event< void()> event ( volatile T *  obj,
R(T::*)(B0, B1, B2) volatile  method,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2486 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( const T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4) const   method,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3281 of file Event.h.

Event< void()> event ( T *  obj,
R(T::*)(B0, B1, B2)  method,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2476 of file Event.h.

Event< void()> event ( R(*)(B0, B1, B2)  func,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2471 of file Event.h.

Event< void()> event ( const volatile T *  obj,
R(T::*)(B0, B1) const volatile  method,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2466 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( const volatile T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4) const volatile  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3291 of file Event.h.

Event< void()> event ( const T *  obj,
R(T::*)(B0, B1) const   method,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2456 of file Event.h.

Event< void(A0, A1, A2)> event ( const volatile T *  obj,
R(T::*)(B0, B1, B2, A0, A1, A2) const volatile  method,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2941 of file Event.h.

Event< void()> event ( R(*)(B0, B1)  func,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2446 of file Event.h.

Event< void()> event ( const volatile T *  obj,
R(T::*)(B0) const volatile  method,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2441 of file Event.h.

Event< void()> event ( volatile T *  obj,
R(T::*)(B0) volatile  method,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2436 of file Event.h.

Event< void(A0, A1, A2)> event ( R(*)(B0, B1, B2, B3, B4, A0, A1, A2)  func,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2971 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( volatile T *  obj,
R(T::*)(B0, A0, A1, A2, A3) volatile  method,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3036 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1, A2, A3)  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3101 of file Event.h.

Event< void()> event ( const volatile T *  obj,
R(T::*)() const volatile  method 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2416 of file Event.h.

Event< void()> event ( volatile T *  obj,
R(T::*)() volatile  method 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2411 of file Event.h.

Event< void()> event ( const T *  obj,
R(T::*)() const   method 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2406 of file Event.h.

Event< void()> event ( T *  obj,
R(T::*)()  method 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2401 of file Event.h.

Event< void()> event ( R(*)()  func ) [inherited]

Creates an event bound to the event queue.

Constructs an event bound to the specified event queue. The specified callback acts as the target for the event and is executed in the context of the event queue's dispatch loop once posted.

Parameters:
fFunction to execute when the event is dispatched
a0..a4Arguments to pass to the callback
Returns:
Event that will dispatch on the specific queue

Definition at line 2396 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1) volatile  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1167 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, B1, A0) const   method,
B0  b0,
B1  b1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 702 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( const volatile T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1, A2, A3) const volatile  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3116 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1) const volatile  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1175 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( R(*)(B0, A0, A1, A2, A3, A4)  func,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3171 of file Event.h.

Event< void(A0, A1, A2)> event ( const T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1, A2) const   method,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2956 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( const volatile T *  obj,
R(T::*)(B0, B1, B2, A0, A1, A2, A3) const volatile  method,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3091 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( volatile T *  obj,
R(T::*)(A0, A1, A2, A3, A4) volatile  method 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3161 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( const T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1, A2, A3) const   method,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3131 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, A0) const volatile  method,
B0  b0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 686 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( R(*)(B0, B1, B2, A0, A1, A2, A3)  func,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3071 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1) const   method,
B0  b0,
B1  b1,
B2  b2,
B3  b3,
B4  b4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1191 of file Event.h.

Event< void(A0, A1, A2)> event ( volatile T *  obj,
R(T::*)(B0, B1, A0, A1, A2) volatile  method,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2911 of file Event.h.

Event< void(A0, A1, A2)> event ( const volatile T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1, A2) const volatile  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2966 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( const volatile T *  obj,
R(T::*)(B0, A0, A1, A2, A3) const volatile  method,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3041 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( volatile T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1, A2, A3) volatile  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3136 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1) volatile  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3,
B4  b4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1199 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1) const volatile  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3,
B4  b4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1207 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( R(*)(B0, B1, A0, A1, A2, A3)  func,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3046 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( volatile T *  obj,
R(T::*)(B0, B1, B2, A0, A1, A2, A3) volatile  method,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3086 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( const volatile T *  obj,
R(T::*)(A0, A1, A2, A3) const volatile  method 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3016 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( const T *  obj,
R(T::*)(B0, B1, A0, A1, A2, A3) const   method,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3056 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( T *  obj,
R(T::*)(B0, B1, B2, A0, A1, A2, A3)  method,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3076 of file Event.h.

Event ( const Event< void(A0, A1, A2)> &  e ) [inherited]

Copy constructor for events.

Definition at line 1251 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( const T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1, A2, A3) const   method,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3106 of file Event.h.

Event< void(A0, A1, A2)> event ( volatile T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1, A2) volatile  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2986 of file Event.h.

Event< void(A0, A1, A2)> event ( const volatile T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1, A2) const volatile  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2991 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( const volatile T *  obj,
R(T::*)(B0, B1, A0, A1, A2, A3, A4) const volatile  method,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3216 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( R(*)(B0, A0, A1, A2, A3)  func,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3021 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 646 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( T *  obj,
R(T::*)(B0, B1, A0, A1, A2, A3)  method,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3051 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( R(*)(A0, A1, A2, A3)  func ) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2996 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, A0, A1, A2) volatile  method,
B0  b0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1464 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 638 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( T *  obj,
R(T::*)(B0, A0, A1, A2, A3)  method,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3026 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( volatile T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1, A2, A3) volatile  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3111 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, A0, A1, A2)  method,
B0  b0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1448 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0,
C1  c1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 630 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1440 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( const T *  obj,
R(T::*)(B0, B1, B2, A0, A1, A2, A3) const   method,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3081 of file Event.h.

Event< void(A0, A1, A2)> event ( T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1, A2)  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2976 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1424 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( T *  obj,
R(T::*)(A0, A1, A2, A3)  method 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3001 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( const T *  obj,
R(T::*)(A0, A1, A2, A3) const   method 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3006 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1, A2, A3)  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3126 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( volatile T *  obj,
R(T::*)(B0, A0, A1, A2, A3, A4) volatile  method,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3186 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( T *  obj,
R(T::*)(B0, A0, A1, A2, A3, A4)  method,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3176 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( volatile T *  obj,
R(T::*)(B0, B1, A0, A1, A2, A3) volatile  method,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3061 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( R(*)(B0, B1, B2, B3, B4, A0, A1, A2, A3)  func,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3121 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( const T *  obj,
R(T::*)(B0, A0, A1, A2, A3, A4) const   method,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3181 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( const T *  obj,
R(T::*)(B0, A0, A1, A2, A3) const   method,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3031 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( const volatile T *  obj,
R(T::*)(B0, B1, A0, A1, A2, A3) const volatile  method,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3066 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( R(*)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4)  func,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3271 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1408 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( R(*)(B0, B1, B2, B3, A0, A1, A2, A3)  func,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3096 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4)  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3276 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0,
C1  c1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1416 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( volatile T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4) volatile  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3286 of file Event.h.

Event< void(A0, A1, A2)> event ( const T *  obj,
R(T::*)(B0, B1, A0, A1, A2) const   method,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2906 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( R(*)(B0, B1, A0, A1, A2, A3, A4)  func,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3196 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( volatile T *  obj,
R(T::*)(B0, B1, B2, A0, A1, A2, A3, A4) volatile  method,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3236 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 622 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1432 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( const volatile T *  obj,
R(T::*)(B0, B1, B2, A0, A1, A2, A3, A4) const volatile  method,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3241 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( const T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1, A2, A3, A4) const   method,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3256 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( R(*)(B0, B1, B2, B3, A0, A1, A2, A3, A4)  func,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3246 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( T *  obj,
R(T::*)(B0, B1, B2, A0, A1, A2, A3, A4)  method,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3226 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 229 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, A0, A1, A2) const   method,
B0  b0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1456 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( const T *  obj,
R(T::*)(B0, B1, B2, A0, A1, A2, A3, A4) const   method,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3231 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( const T *  obj,
R(T::*)(B0, B1, A0, A1, A2, A3, A4) const   method,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3206 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, A0, A1, A2) const volatile  method,
B0  b0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1472 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, B1, A0, A1, A2)  method,
B0  b0,
B1  b1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1480 of file Event.h.

Event< void(A0, A1)> event ( volatile T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1) volatile  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2836 of file Event.h.

Event< void(A0, A1, A2)> event ( R(*)(B0, A0, A1, A2)  func,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2871 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( const volatile T *  obj,
R(T::*)(A0, A1, A2, A3, A4) const volatile  method 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3166 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0,
C1  c1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 237 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, B1, A0, A1, A2) const   method,
B0  b0,
B1  b1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1488 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 654 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, B1, A0, A1, A2) volatile  method,
B0  b0,
B1  b1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1496 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, B1, A0, A1, A2) const volatile  method,
B0  b0,
B1  b1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1504 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, A0)  method,
B0  b0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 662 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, B1, B2, A0, A1, A2)  method,
B0  b0,
B1  b1,
B2  b2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1512 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 245 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, B1, B2, A0, A1, A2) const   method,
B0  b0,
B1  b1,
B2  b2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1520 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, A0) const   method,
B0  b0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 670 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, B1, B2, A0, A1, A2) volatile  method,
B0  b0,
B1  b1,
B2  b2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1528 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, B1, B2, A0, A1, A2) const volatile  method,
B0  b0,
B1  b1,
B2  b2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1536 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, A0) volatile  method,
B0  b0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 678 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1, A2)  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1544 of file Event.h.

Event< void(A0, A1, A2)> event ( const T *  obj,
R(T::*)(A0, A1, A2) const   method 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2856 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( volatile T *  obj,
R(T::*)(B0, B1, A0, A1, A2, A3, A4) volatile  method,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3211 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( T *  obj,
R(T::*)(B0, B1, A0, A1, A2, A3, A4)  method,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3201 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( const volatile T *  obj,
R(T::*)(B0, A0, A1, A2, A3, A4) const volatile  method,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3191 of file Event.h.

Event< void(A0, A1, A2)> event ( T *  obj,
R(T::*)(B0, A0, A1, A2)  method,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2876 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, B1, A0, A1) volatile  method,
B0  b0,
B1  b1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1103 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, B1, A0, A1) const volatile  method,
B0  b0,
B1  b1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1111 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( T *  obj,
R(T::*)(A0, A1, A2, A3, A4)  method 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3151 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( const volatile T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1, A2, A3) const volatile  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3141 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4) volatile  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3,
B4  b4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 2378 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4) const   method,
B0  b0,
B1  b1,
B2  b2,
B3  b3,
B4  b4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 2370 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4)  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3,
B4  b4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 2362 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1, A2, A3, A4) const volatile  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 2354 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1, A2, A3, A4) volatile  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 2346 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1, A2, A3, A4) const   method,
B0  b0,
B1  b1,
B2  b2,
B3  b3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 2338 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1, A2, A3, A4)  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 2330 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 253 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, B1, B2, A0, A1, A2, A3, A4) volatile  method,
B0  b0,
B1  b1,
B2  b2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 2314 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, B1, B2, A0, A1, A2, A3, A4) const   method,
B0  b0,
B1  b1,
B2  b2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 2306 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, B1, B2, A0, A1, A2, A3, A4)  method,
B0  b0,
B1  b1,
B2  b2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 2298 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, B1, A0, A1, A2, A3, A4) const volatile  method,
B0  b0,
B1  b1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 2290 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, B1, A0, A1, A2, A3, A4) volatile  method,
B0  b0,
B1  b1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 2282 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, B1, A0, A1, A2, A3, A4) const   method,
B0  b0,
B1  b1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 2274 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, B1, A0, A1, A2, A3, A4)  method,
B0  b0,
B1  b1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 2266 of file Event.h.

Event< void(A0, A1, A2)> event ( const T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1, A2) const   method,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2981 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, A0, A1, A2, A3, A4) volatile  method,
B0  b0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 2250 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, A0, A1, A2, A3, A4) const   method,
B0  b0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 2242 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, A0, A1, A2, A3, A4)  method,
B0  b0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 2234 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 2226 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 2218 of file Event.h.

Event< void(A0, A1, A2)> event ( R(*)(B0, B1, B2, A0, A1, A2)  func,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2921 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1, A2) const   method,
B0  b0,
B1  b1,
B2  b2,
B3  b3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1552 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1, A2) volatile  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1560 of file Event.h.

Event< void(A0, A1, A2)> event ( const volatile T *  obj,
R(T::*)(B0, A0, A1, A2) const volatile  method,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2891 of file Event.h.

Event< void(A0, A1, A2)> event ( volatile T *  obj,
R(T::*)(B0, A0, A1, A2) volatile  method,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2886 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, B1, B2) const volatile  method,
B0  b0,
B1  b1,
B2  b2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 357 of file Event.h.

Event< void(A0, A1, A2)> event ( const volatile T *  obj,
R(T::*)(A0, A1, A2) const volatile  method 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2866 of file Event.h.

Event< void(A0, A1, A2)> event ( T *  obj,
R(T::*)(A0, A1, A2)  method 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2851 of file Event.h.

Event< void(A0, A1)> event ( const volatile T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1) const volatile  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2841 of file Event.h.

Event< void(A0, A1)> event ( const T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1) const   method,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2831 of file Event.h.

Event< void(A0, A1)> event ( T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1)  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2826 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, B1, B2) const   method,
B0  b0,
B1  b1,
B2  b2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 341 of file Event.h.

Event< void(A0, A1)> event ( const T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1) const   method,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2806 of file Event.h.

Event< void(A0, A1)> event ( const volatile T *  obj,
R(T::*)(B0, B1, B2, A0, A1) const volatile  method,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2791 of file Event.h.

Event< void(A0, A1)> event ( const T *  obj,
R(T::*)(B0, B1, B2, A0, A1) const   method,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2781 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1, A2, A3) const volatile  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3,
B4  b4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1993 of file Event.h.

Event< void(A0, A1)> event ( volatile T *  obj,
R(T::*)(B0, B1, A0, A1) volatile  method,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2761 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1, A2, A3) const   method,
B0  b0,
B1  b1,
B2  b2,
B3  b3,
B4  b4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1977 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1, A2) const volatile  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1568 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1, A2, A3) const volatile  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1961 of file Event.h.

Event< void(A0, A1)> event ( R(*)(B0, A0, A1)  func,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2721 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1, A2, A3) const   method,
B0  b0,
B1  b1,
B2  b2,
B3  b3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1945 of file Event.h.

Event< void(A0, A1)> event ( T *  obj,
R(T::*)(A0, A1)  method 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2701 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, B1, B2, A0, A1, A2, A3) const volatile  method,
B0  b0,
B1  b1,
B2  b2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1929 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, B1, B2, A0, A1, A2, A3) volatile  method,
B0  b0,
B1  b1,
B2  b2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1921 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, B1, B2, A0, A1, A2, A3) const   method,
B0  b0,
B1  b1,
B2  b2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1913 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, B1, B2, A0, A1, A2, A3)  method,
B0  b0,
B1  b1,
B2  b2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1905 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, B1, A0, A1, A2, A3) const volatile  method,
B0  b0,
B1  b1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1897 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, B1, A0, A1, A2, A3) volatile  method,
B0  b0,
B1  b1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1889 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, B1, A0, A1, A2, A3) const   method,
B0  b0,
B1  b1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1881 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, B1, A0, A1, A2, A3)  method,
B0  b0,
B1  b1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1873 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, A0, A1, A2, A3) const volatile  method,
B0  b0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1865 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, A0, A1, A2, A3) volatile  method,
B0  b0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1857 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, A0, A1, A2, A3) const   method,
B0  b0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1849 of file Event.h.

Event< void(A0)> event ( volatile T *  obj,
R(T::*)(B0, A0) volatile  method,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2586 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1833 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1825 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1817 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0,
C1  c1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1809 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1801 of file Event.h.

Event< void()> event ( R(*)(B0, B1, B2, B3, B4)  func,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2521 of file Event.h.

Event< void()> event ( volatile T *  obj,
R(T::*)(B0, B1, B2, B3) volatile  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2511 of file Event.h.

Event< void()> event ( const T *  obj,
R(T::*)(B0, B1, B2, B3) const   method,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2506 of file Event.h.

Event< void()> event ( const volatile T *  obj,
R(T::*)(B0, B1, B2) const volatile  method,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2491 of file Event.h.

Event< void()> event ( const T *  obj,
R(T::*)(B0, B1, B2) const   method,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2481 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, B1, B2, A0) const   method,
B0  b0,
B1  b1,
B2  b2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 734 of file Event.h.

Event< void()> event ( volatile T *  obj,
R(T::*)(B0, B1) volatile  method,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2461 of file Event.h.

Event< void()> event ( T *  obj,
R(T::*)(B0, B1)  method,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2451 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, B1, B2, A0)  method,
B0  b0,
B1  b1,
B2  b2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 726 of file Event.h.

Event< void()> event ( const T *  obj,
R(T::*)(B0) const   method,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2431 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, B1, A0)  method,
B0  b0,
B1  b1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 694 of file Event.h.

Event ( const Event< void(A0, A1, A2, A3)> &  e ) [inherited]

Copy constructor for events.

Definition at line 1644 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1, A2) const volatile  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3,
B4  b4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1600 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1, A2)  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3,
B4  b4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1576 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1)  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3,
B4  b4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1183 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 261 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1, A2) const   method,
B0  b0,
B1  b1,
B2  b2,
B3  b3,
B4  b4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1584 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1, A2) volatile  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3,
B4  b4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1592 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, B1, A0) volatile  method,
B0  b0,
B1  b1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 710 of file Event.h.

Event< void(A0, A1, A2)> event ( R(*)(B0, B1, B2, B3, A0, A1, A2)  func,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2946 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, B1, A0) const volatile  method,
B0  b0,
B1  b1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 718 of file Event.h.

Event< void()> event ( R(*)(B0)  func,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2421 of file Event.h.

Event< void()> event ( T *  obj,
R(T::*)(B0)  method,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2426 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0)  method,
B0  b0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 269 of file Event.h.

Event< void(A0, A1, A2)> event ( T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1, A2)  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2951 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0) const   method,
B0  b0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 277 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, B1, B2, A0) volatile  method,
B0  b0,
B1  b1,
B2  b2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 742 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0) volatile  method,
B0  b0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 285 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, B1, B2, A0) const volatile  method,
B0  b0,
B1  b1,
B2  b2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 750 of file Event.h.

Event< void()> event ( T *  obj,
R(T::*)(B0, B1, B2, B3)  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2501 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, B1, B2, B3, A0)  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 758 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0) const volatile  method,
B0  b0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 293 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, B1, B2, B3, A0) const   method,
B0  b0,
B1  b1,
B2  b2,
B3  b3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 766 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, B1, B2, B3, A0) volatile  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 774 of file Event.h.

Event< void(A0, A1)> event ( R(*)(B0, B1, B2, B3, A0, A1)  func,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2796 of file Event.h.

Event< void(A0, A1)> event ( const volatile T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1) const volatile  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2816 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, B1)  method,
B0  b0,
B1  b1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 301 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, B1, B2, B3, A0) const volatile  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 782 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, A0, A1, A2, A3)  method,
B0  b0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1841 of file Event.h.

Event< void(A0)> event ( const T *  obj,
R(T::*)(B0, A0) const   method,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2581 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0)  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3,
B4  b4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 790 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, B1) const   method,
B0  b0,
B1  b1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 309 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0) const   method,
B0  b0,
B1  b1,
B2  b2,
B3  b3,
B4  b4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 798 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0) volatile  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3,
B4  b4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 806 of file Event.h.

Event< void(A0, A1, A2)> event ( R(*)(A0, A1, A2)  func ) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2846 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, B1) volatile  method,
B0  b0,
B1  b1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 317 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0) const volatile  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3,
B4  b4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 814 of file Event.h.

Event ( const Event< void(A0, A1)> &  e ) [inherited]

Copy constructor for events.

Definition at line 858 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, B1) const volatile  method,
B0  b0,
B1  b1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 325 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1, A2, A3)  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1937 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1, A2, A3) volatile  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1953 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, B1, B2)  method,
B0  b0,
B1  b1,
B2  b2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 333 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1, A2, A3)  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3,
B4  b4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1969 of file Event.h.

Event< void(A0, A1)> event ( const volatile T *  obj,
R(T::*)(B0, A0, A1) const volatile  method,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2741 of file Event.h.

Event< void(A0, A1)> event ( R(*)(B0, B1, A0, A1)  func,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2746 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1, A2, A3) volatile  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3,
B4  b4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1985 of file Event.h.

Event< void(A0, A1, A2)> event ( volatile T *  obj,
R(T::*)(B0, B1, B2, A0, A1, A2) volatile  method,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2936 of file Event.h.

Event ( const Event< void(A0, A1, A2, A3, A4)> &  e ) [inherited]

Copy constructor for events.

Definition at line 2037 of file Event.h.

Event< void(A0, A1)> event ( T *  obj,
R(T::*)(B0, B1, B2, B3, A0, A1)  method,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2801 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, B1, B2, A0, A1) const   method,
B0  b0,
B1  b1,
B2  b2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1127 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, B1, B2, A0, A1)  method,
B0  b0,
B1  b1,
B2  b2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1119 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, B1, B2, B3, B4) volatile  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3,
B4  b4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 413 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4) const volatile  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3,
B4  b4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 2386 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, B1, A0, A1) const   method,
B0  b0,
B1  b1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1095 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, B1, A0, A1)  method,
B0  b0,
B1  b1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1087 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, A0, A1) const volatile  method,
B0  b0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1079 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, B1, B2, A0, A1, A2, A3, A4) const volatile  method,
B0  b0,
B1  b1,
B2  b2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 2322 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, A0, A1) const   method,
B0  b0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1063 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, A0, A1)  method,
B0  b0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1055 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1047 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, A0, A1, A2, A3, A4) const volatile  method,
B0  b0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 2258 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1031 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0,
C1  c1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1023 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 2210 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0,
C1  c1 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 2202 of file Event.h.

Event< void(A0, A1, A2)> event ( const T *  obj,
R(T::*)(B0, A0, A1, A2) const   method,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2881 of file Event.h.

Event< void(A0, A1, A2)> event ( volatile T *  obj,
R(T::*)(A0, A1, A2) volatile  method 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2861 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( R(*)(A0, A1, A2, A3, A4)  func ) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3146 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( const T *  obj,
R(T::*)(A0, A1, A2, A3, A4) const   method 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3156 of file Event.h.

Event< void(A0, A1)> event ( R(*)(B0, B1, B2, B3, B4, A0, A1)  func,
C0  c0,
C1  c1,
C2  c2,
C3  c3,
C4  c4 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2821 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, B1, B2) volatile  method,
B0  b0,
B1  b1,
B2  b2 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 349 of file Event.h.

Event ( const Event< void()> &  e ) [inherited]

Copy constructor for events.

Definition at line 72 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, B1, B2, B3)  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 365 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1015 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 2194 of file Event.h.

Event< void(A0, A1, A2)> event ( T *  obj,
R(T::*)(B0, B1, A0, A1, A2)  method,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2901 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, B1, B2, B3) const   method,
B0  b0,
B1  b1,
B2  b2,
B3  b3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 373 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, B1, B2, B3) volatile  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 381 of file Event.h.

Event ( EventQueue *  q,
F  f,
C0  c0,
C1  c1,
C2  c2,
C3  c3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1039 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, B1, B2, B3) const volatile  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 389 of file Event.h.

Event< void(A0, A1, A2)> event ( const volatile T *  obj,
R(T::*)(B0, B1, A0, A1, A2) const volatile  method,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2916 of file Event.h.

Event ( EventQueue *  q,
T *  obj,
R(T::*)(B0, B1, B2, B3, B4)  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3,
B4  b4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 397 of file Event.h.

Event ( EventQueue *  q,
volatile T *  obj,
R(T::*)(B0, A0, A1) volatile  method,
B0  b0 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 1071 of file Event.h.

Event ( EventQueue *  q,
const T *  obj,
R(T::*)(B0, B1, B2, B3, B4) const   method,
B0  b0,
B1  b1,
B2  b2,
B3  b3,
B4  b4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 405 of file Event.h.

Event< void(A0, A1, A2)> event ( T *  obj,
R(T::*)(B0, B1, B2, A0, A1, A2)  method,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2926 of file Event.h.

Event< void(A0, A1, A2)> event ( const T *  obj,
R(T::*)(B0, B1, B2, A0, A1, A2) const   method,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2931 of file Event.h.

Event ( EventQueue *  q,
const volatile T *  obj,
R(T::*)(B0, B1, B2, B3, B4) const volatile  method,
B0  b0,
B1  b1,
B2  b2,
B3  b3,
B4  b4 
) [inherited]

Create an event.

See also:
Event::Event

Definition at line 421 of file Event.h.

void operator() ( A0  a0,
A1  a1,
A2  a2,
A3  a3,
A4  a4 
) const [inherited]

Posts an event onto the underlying event queue, returning void.

Parameters:
a0..a4Arguments to pass to the event

Definition at line 2123 of file Event.h.

void operator() ( A0  a0 ) const [inherited]

Posts an event onto the underlying event queue, returning void.

Parameters:
a0..a4Arguments to pass to the event

Definition at line 551 of file Event.h.

void operator() ( A0  a0,
A1  a1,
A2  a2 
) const [inherited]

Posts an event onto the underlying event queue, returning void.

Parameters:
a0..a4Arguments to pass to the event

Definition at line 1337 of file Event.h.

void operator() ( A0  a0,
A1  a1,
A2  a2,
A3  a3 
) const [inherited]

Posts an event onto the underlying event queue, returning void.

Parameters:
a0..a4Arguments to pass to the event

Definition at line 1730 of file Event.h.

void operator() ( A0  a0,
A1  a1 
) const [inherited]

Posts an event onto the underlying event queue, returning void.

Parameters:
a0..a4Arguments to pass to the event

Definition at line 944 of file Event.h.

void operator() (  ) const [inherited]

Posts an event onto the underlying event queue, returning void.

Parameters:
a0..a4Arguments to pass to the event

Definition at line 158 of file Event.h.

Event& operator= ( const Event< void(A0, A1, A2, A3, A4)> &  that ) [inherited]

Assignment operator for events.

Definition at line 2047 of file Event.h.

Event& operator= ( const Event< void()> &  that ) [inherited]

Assignment operator for events.

Definition at line 82 of file Event.h.

Event& operator= ( const Event< void(A0)> &  that ) [inherited]

Assignment operator for events.

Definition at line 475 of file Event.h.

Event& operator= ( const Event< void(A0, A1)> &  that ) [inherited]

Assignment operator for events.

Definition at line 868 of file Event.h.

Event& operator= ( const Event< void(A0, A1, A2, A3)> &  that ) [inherited]

Assignment operator for events.

Definition at line 1654 of file Event.h.

Event& operator= ( const Event< void(A0, A1, A2)> &  that ) [inherited]

Assignment operator for events.

Definition at line 1261 of file Event.h.

void period ( int  period ) [inherited]

Configure the period of an event.

Parameters:
periodMillisecond period for repeatedly dispatching an event

Definition at line 1689 of file Event.h.

void period ( int  period ) [inherited]

Configure the period of an event.

Parameters:
periodMillisecond period for repeatedly dispatching an event

Definition at line 117 of file Event.h.

void period ( int  period ) [inherited]

Configure the period of an event.

Parameters:
periodMillisecond period for repeatedly dispatching an event

Definition at line 510 of file Event.h.

void period ( int  period ) [inherited]

Configure the period of an event.

Parameters:
periodMillisecond period for repeatedly dispatching an event

Definition at line 1296 of file Event.h.

void period ( int  period ) [inherited]

Configure the period of an event.

Parameters:
periodMillisecond period for repeatedly dispatching an event

Definition at line 903 of file Event.h.

void period ( int  period ) [inherited]

Configure the period of an event.

Parameters:
periodMillisecond period for repeatedly dispatching an event

Definition at line 2082 of file Event.h.

int post ( A0  a0,
A1  a1,
A2  a2,
A3  a3 
) const [inherited]

Posts an event onto the underlying event queue.

The event is posted to the underlying queue and is executed in the context of the event queue's dispatch loop.

The post function is irq safe and can act as a mechanism for moving events out of irq contexts.

Parameters:
a0..a4Arguments to pass to the event
Returns:
A unique id that represents the posted event and can be passed to EventQueue::cancel, or an id of 0 if there is not enough memory to allocate the event.

Definition at line 1708 of file Event.h.

int post ( A0  a0,
A1  a1,
A2  a2,
A3  a3,
A4  a4 
) const [inherited]

Posts an event onto the underlying event queue.

The event is posted to the underlying queue and is executed in the context of the event queue's dispatch loop.

The post function is irq safe and can act as a mechanism for moving events out of irq contexts.

Parameters:
a0..a4Arguments to pass to the event
Returns:
A unique id that represents the posted event and can be passed to EventQueue::cancel, or an id of 0 if there is not enough memory to allocate the event.

Definition at line 2101 of file Event.h.

int post ( A0  a0,
A1  a1,
A2  a2 
) const [inherited]

Posts an event onto the underlying event queue.

The event is posted to the underlying queue and is executed in the context of the event queue's dispatch loop.

The post function is irq safe and can act as a mechanism for moving events out of irq contexts.

Parameters:
a0..a4Arguments to pass to the event
Returns:
A unique id that represents the posted event and can be passed to EventQueue::cancel, or an id of 0 if there is not enough memory to allocate the event.

Definition at line 1315 of file Event.h.

int post ( A0  a0,
A1  a1 
) const [inherited]

Posts an event onto the underlying event queue.

The event is posted to the underlying queue and is executed in the context of the event queue's dispatch loop.

The post function is irq safe and can act as a mechanism for moving events out of irq contexts.

Parameters:
a0..a4Arguments to pass to the event
Returns:
A unique id that represents the posted event and can be passed to EventQueue::cancel, or an id of 0 if there is not enough memory to allocate the event.

Definition at line 922 of file Event.h.

int post (  ) const [inherited]

Posts an event onto the underlying event queue.

The event is posted to the underlying queue and is executed in the context of the event queue's dispatch loop.

The post function is irq safe and can act as a mechanism for moving events out of irq contexts.

Parameters:
a0..a4Arguments to pass to the event
Returns:
A unique id that represents the posted event and can be passed to EventQueue::cancel, or an id of 0 if there is not enough memory to allocate the event.

Definition at line 136 of file Event.h.

int post ( A0  a0 ) const [inherited]

Posts an event onto the underlying event queue.

The event is posted to the underlying queue and is executed in the context of the event queue's dispatch loop.

The post function is irq safe and can act as a mechanism for moving events out of irq contexts.

Parameters:
a0..a4Arguments to pass to the event
Returns:
A unique id that represents the posted event and can be passed to EventQueue::cancel, or an id of 0 if there is not enough memory to allocate the event.

Definition at line 529 of file Event.h.

static void thunk ( void *  func,
A0  a0 
) [static, inherited]

Static thunk for passing as C-style function.

Parameters:
funcEvent to call passed as a void pointer
a0..a4Arguments to pass to the event

Definition at line 560 of file Event.h.

static void thunk ( void *  func,
A0  a0,
A1  a1,
A2  a2,
A3  a3,
A4  a4 
) [static, inherited]

Static thunk for passing as C-style function.

Parameters:
funcEvent to call passed as a void pointer
a0..a4Arguments to pass to the event

Definition at line 2132 of file Event.h.

static void thunk ( void *  func,
A0  a0,
A1  a1 
) [static, inherited]

Static thunk for passing as C-style function.

Parameters:
funcEvent to call passed as a void pointer
a0..a4Arguments to pass to the event

Definition at line 953 of file Event.h.

static void thunk ( void *  func ) [static, inherited]

Static thunk for passing as C-style function.

Parameters:
funcEvent to call passed as a void pointer
a0..a4Arguments to pass to the event

Definition at line 167 of file Event.h.

static void thunk ( void *  func,
A0  a0,
A1  a1,
A2  a2 
) [static, inherited]

Static thunk for passing as C-style function.

Parameters:
funcEvent to call passed as a void pointer
a0..a4Arguments to pass to the event

Definition at line 1346 of file Event.h.

static void thunk ( void *  func,
A0  a0,
A1  a1,
A2  a2,
A3  a3 
) [static, inherited]

Static thunk for passing as C-style function.

Parameters:
funcEvent to call passed as a void pointer
a0..a4Arguments to pass to the event

Definition at line 1739 of file Event.h.

unsigned tick (  ) [inherited]

Millisecond counter.

Returns the underlying tick of the event queue represented as the number of milliseconds that have passed since an arbitrary point in time. Intentionally overflows to 0 after 2^32-1.

Returns:
The underlying tick of the event queue in milliseconds
~Event (  ) [inherited]

Destructor for events.

Definition at line 93 of file Event.h.

~Event (  ) [inherited]

Destructor for events.

Definition at line 486 of file Event.h.

~Event (  ) [inherited]

Destructor for events.

Definition at line 1665 of file Event.h.

~Event (  ) [inherited]

Destructor for events.

Definition at line 879 of file Event.h.

~Event (  ) [inherited]

Destructor for events.

Definition at line 2058 of file Event.h.

~Event (  ) [inherited]

Destructor for events.

Definition at line 1272 of file Event.h.

~EventQueue (  ) [inherited]

Destroy an EventQueue.

Generated on Tue Jul 12 2022 11:03:15 by  doxygen 1.7.2