Rtos API example

Embed: (wiki syntax)

« Back to documentation index

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.
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 >
Event< void()> event (mbed::Callback< R()> cb)
 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 C0 >
Event< void()> event (mbed::Callback< R(B0)> cb, 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 C0 , typename C1 >
Event< void()> event (mbed::Callback< R(B0, B1)> cb, 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 C0 , typename C1 , typename C2 >
Event< void()> event (mbed::Callback< R(B0, B1, B2)> cb, 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 C0 , typename C1 , typename C2 , typename C3 >
Event< void()> event (mbed::Callback< R(B0, B1, B2, B3)> cb, 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 B0 , typename B1 , typename B2 , typename B3 , typename B4 , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 >
Event< void()> event (mbed::Callback< R(B0, B1, B2, B3, B4)> cb, 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 A0 >
Event< void(A0)> event (mbed::Callback< R(A0)> cb)
 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 C0 , typename A0 >
Event< void(A0)> event (mbed::Callback< R(B0, A0)> cb, 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 C0 , typename C1 , typename A0 >
Event< void(A0)> event (mbed::Callback< R(B0, B1, A0)> cb, 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 C0 , typename C1 , typename C2 , typename A0 >
Event< void(A0)> event (mbed::Callback< R(B0, B1, B2, A0)> cb, 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 C0 , typename C1 , typename C2 , typename C3 , typename A0 >
Event< void(A0)> event (mbed::Callback< R(B0, B1, B2, B3, A0)> cb, 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 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 (mbed::Callback< R(B0, B1, B2, B3, B4, A0)> cb, 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 A0 , typename A1 >
Event< void(A0, A1)> event (mbed::Callback< R(A0, A1)> cb)
 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 C0 , typename A0 , typename A1 >
Event< void(A0, A1)> event (mbed::Callback< R(B0, A0, A1)> cb, 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 C0 , typename C1 , typename A0 , typename A1 >
Event< void(A0, A1)> event (mbed::Callback< R(B0, B1, A0, A1)> cb, 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 C0 , typename C1 , typename C2 , typename A0 , typename A1 >
Event< void(A0, A1)> event (mbed::Callback< R(B0, B1, B2, A0, A1)> cb, 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 C0 , typename C1 , typename C2 , typename C3 , typename A0 , typename A1 >
Event< void(A0, A1)> event (mbed::Callback< R(B0, B1, B2, B3, A0, A1)> cb, 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 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 (mbed::Callback< R(B0, B1, B2, B3, B4, A0, A1)> cb, 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 A0 , typename A1 , typename A2 >
Event< void(A0, A1, A2)> event (mbed::Callback< R(A0, A1, A2)> cb)
 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 C0 , typename A0 , typename A1 , typename A2 >
Event< void(A0, A1, A2)> event (mbed::Callback< R(B0, A0, A1, A2)> cb, 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 C0 , typename C1 , typename A0 , typename A1 , typename A2 >
Event< void(A0, A1, A2)> event (mbed::Callback< R(B0, B1, A0, A1, A2)> cb, 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 C0 , typename C1 , typename C2 , typename A0 , typename A1 , typename A2 >
Event< void(A0, A1, A2)> event (mbed::Callback< R(B0, B1, B2, A0, A1, A2)> cb, 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 C0 , typename C1 , typename C2 , typename C3 , typename A0 , typename A1 , typename A2 >
Event< void(A0, A1, A2)> event (mbed::Callback< R(B0, B1, B2, B3, A0, A1, A2)> cb, C0 c0, C1 c1, C2 c2, C3 c3)
 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 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 (mbed::Callback< R(B0, B1, B2, B3, B4, A0, A1, A2)> cb, 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 A0 , typename A1 , typename A2 , typename A3 >
Event< void(A0, A1, A2, A3)> event (mbed::Callback< R(A0, A1, A2, A3)> cb)
 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 C0 , typename A0 , typename A1 , typename A2 , typename A3 >
Event< void(A0, A1, A2, A3)> event (mbed::Callback< R(B0, A0, A1, A2, A3)> cb, 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 C0 , typename C1 , typename A0 , typename A1 , typename A2 , typename A3 >
Event< void(A0, A1, A2, A3)> event (mbed::Callback< R(B0, B1, A0, A1, A2, A3)> cb, 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 C0 , typename C1 , typename C2 , typename A0 , typename A1 , typename A2 , typename A3 >
Event< void(A0, A1, A2, A3)> event (mbed::Callback< R(B0, B1, B2, A0, A1, A2, A3)> cb, 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 C0 , typename C1 , typename C2 , typename C3 , typename A0 , typename A1 , typename A2 , typename A3 >
Event< void(A0, A1, A2, A3)> event (mbed::Callback< R(B0, B1, B2, B3, A0, A1, A2, A3)> cb, C0 c0, C1 c1, C2 c2, C3 c3)
 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 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 (mbed::Callback< R(B0, B1, B2, B3, B4, A0, A1, A2, A3)> cb, 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 A0 , typename A1 , typename A2 , typename A3 , typename A4 >
Event< void(A0, A1, A2, A3, A4)> event (mbed::Callback< R(A0, A1, A2, A3, A4)> cb)
 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 C0 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
Event< void(A0, A1, A2, A3, A4)> event (mbed::Callback< R(B0, A0, A1, A2, A3, A4)> cb, 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 C0 , typename C1 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
Event< void(A0, A1, A2, A3, A4)> event (mbed::Callback< R(B0, B1, A0, A1, A2, A3, A4)> cb, 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 C0 , typename C1 , typename C2 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
Event< void(A0, A1, A2, A3, A4)> event (mbed::Callback< R(B0, B1, B2, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1, C2 c2)
 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 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 (mbed::Callback< R(B0, B1, B2, B3, A0, A1, A2, A3, A4)> cb, 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.
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 (mbed::Callback< R(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
 Creates an event bound to the event queue.

Function Documentation

void call (  ) const [inherited]

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

Definition at line 147 of file Event.h.

void call ( A0  a0 ) const [inherited]

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

Parameters:
a0Argument to pass to the event

Definition at line 563 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,a1,a2Arguments to pass to the event

Definition at line 1399 of file Event.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,a1,a2,a3Arguments to pass to the event

Definition at line 1817 of file Event.h.

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

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

Parameters:
a0,a1Arguments to pass to the event

Definition at line 981 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,a1,a2,a3,a4Arguments to pass to the event

Definition at line 2235 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 178 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 596 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 1432 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 1850 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 1014 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 2268 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 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 521 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 1357 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 1775 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 2193 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 939 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 3404 of file Event.h.

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

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3409 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 3394 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 3389 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 3384 of file Event.h.

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

Copy constructor for events.

Definition at line 486 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 3374 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 3369 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 3364 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 1206 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 3354 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( mbed::Callback< R(B0, B1, A0, A1, A2, A3)>  cb,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3349 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 3344 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 2579 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 3334 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 3329 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 3324 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( mbed::Callback< R(B0, A0, A1, A2, A3)>  cb,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3319 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 3314 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 3309 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 3304 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 2584 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 3294 of file Event.h.

Event< void(A0, A1, A2, A3)> event ( mbed::Callback< R(A0, A1, A2, A3)>  cb ) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3289 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 3284 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 3279 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 3274 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 3269 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 3264 of file Event.h.

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

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3259 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 3254 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 3249 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 3244 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 3239 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 3234 of file Event.h.

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

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3229 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 1214 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 2589 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 3214 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 3209 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 3204 of file Event.h.

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

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3199 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 3194 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 3189 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 3184 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 3179 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 3174 of file Event.h.

Event< void(A0, A1, A2)> event ( mbed::Callback< R(B0, B1, A0, A1, A2)>  cb,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3169 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 3164 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 2594 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 3154 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 1222 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 3144 of file Event.h.

Event< void(A0, A1, A2)> event ( mbed::Callback< R(B0, A0, A1, A2)>  cb,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3139 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 3134 of file Event.h.

Event< void()> event ( mbed::Callback< R(B0)>  cb,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2599 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 3124 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 2604 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 3114 of file Event.h.

Event< void(A0, A1, A2)> event ( mbed::Callback< R(A0, A1, A2)>  cb ) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3109 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 3104 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 1230 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 3094 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 2609 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 3084 of file Event.h.

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

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3079 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 3074 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 2614 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 3549 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 1238 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 3054 of file Event.h.

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

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3049 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 3044 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 3039 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 3034 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 3029 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 3024 of file Event.h.

Event< void(A0, A1)> event ( mbed::Callback< R(B0, B1, B2, A0, A1)>  cb,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3019 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 3014 of file Event.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 3009 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 3004 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 2999 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 2994 of file Event.h.

Event< void(A0, A1)> event ( mbed::Callback< R(B0, B1, A0, A1)>  cb,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2989 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 2984 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 2979 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 2974 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 2969 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 2964 of file Event.h.

Event< void(A0, A1)> event ( mbed::Callback< R(B0, A0, A1)>  cb,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2959 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 2954 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 2949 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 2944 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 2939 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 2934 of file Event.h.

Event< void(A0, A1)> event ( mbed::Callback< R(A0, A1)>  cb ) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2929 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 2924 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 2919 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 2914 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 2909 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 2904 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 2619 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 2894 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 2889 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 2884 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 2879 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 2874 of file Event.h.

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

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2869 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 2864 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 2859 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 2854 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 2849 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 2844 of file Event.h.

Event< void(A0)> event ( mbed::Callback< R(B0, B1, B2, A0)>  cb,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2839 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 2834 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 2829 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 2824 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 2624 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 2814 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 1246 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 2804 of file Event.h.

Event< void()> event ( mbed::Callback< R(B0, B1)>  cb,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2629 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 2794 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 2634 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 3564 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 1254 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 2774 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 2639 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 2764 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 2644 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 2754 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 1262 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 2649 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 2654 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 2734 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 1270 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 1278 of file Event.h.

Event< void()> event ( mbed::Callback< R(B0, B1, B2)>  cb,
C0  c0,
C1  c1,
C2  c2 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2659 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 2714 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 2664 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 2704 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 2669 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 2674 of file Event.h.

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

Copy constructor for events.

Definition at line 1322 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 2679 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 2684 of file Event.h.

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

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2689 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 2694 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 3579 of file Event.h.

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

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3589 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 2699 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 2709 of file Event.h.

Event< void()> event ( mbed::Callback< R(B0, B1, B2, B3, B4)>  cb,
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 2719 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 2724 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 2729 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 3484 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 3609 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 2739 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 2744 of file Event.h.

Event< void(A0)> event ( mbed::Callback< R(A0)>  cb ) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2749 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 3594 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 2759 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 2769 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0Argument to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0, the arguments to the underlying callback.

Definition at line 1484 of file Event.h.

Event< void(A0)> event ( mbed::Callback< R(B0, A0)>  cb,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2779 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 2784 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 2574 of file Event.h.

Event< void()> event ( mbed::Callback< R()>  cb ) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2569 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 2564 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 2559 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 2554 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 2549 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:
funcFunction to execute when the event is dispatched
Returns:
Event that will dispatch on the specific queue

Definition at line 2544 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 2789 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 2524 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 2516 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 2508 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 2500 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 2492 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 2484 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 2476 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0,c1Arguments to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0..b1, the arguments to the underlying callback.

Definition at line 1497 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 2460 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 2452 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 2444 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 2436 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 2428 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 2420 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 2412 of file Event.h.

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

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3619 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 2396 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 2388 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 2380 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0,c1,c2,c3,c4Arguments to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0..b4, the arguments to the underlying callback.

Definition at line 2372 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0,c1,c2,c3Arguments to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0..b3, the arguments to the underlying callback.

Definition at line 2359 of file Event.h.

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

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3559 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0,c1Arguments to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0..b1, the arguments to the underlying callback.

Definition at line 2333 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 2799 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( mbed::Callback< R(B0, B1, A0, A1, A2, A3, A4)>  cb,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3529 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 3524 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 378 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( mbed::Callback< R(B0, A0, A1, A2, A3, A4)>  cb,
C0  c0 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3499 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 3489 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 3479 of file Event.h.

Event< void(A0, A1, A2, A3, A4)> event ( mbed::Callback< R(A0, A1, A2, A3, A4)>  cb ) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3469 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 3464 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 362 of file Event.h.

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

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3439 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 3429 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 3419 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 2114 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 3399 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 2098 of file Event.h.

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

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 3379 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 2082 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 3359 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 2066 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 3339 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 2050 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 2042 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 2034 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 3299 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 2018 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 2010 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 2002 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 1994 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 1986 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 1978 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 1970 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 3224 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0,c1,c2,c3,c4Arguments to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0..b4, the arguments to the underlying callback.

Definition at line 1954 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0,c1,c2,c3Arguments to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0..b3, the arguments to the underlying callback.

Definition at line 1941 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0,c1,c2Arguments to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0..b2, the arguments to the underlying callback.

Definition at line 1928 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0,c1Arguments to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0..b1, the arguments to the underlying callback.

Definition at line 1915 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0Argument to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0, the arguments to the underlying callback.

Definition at line 1902 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 3159 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 3149 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 796 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 3129 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 3119 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 780 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 3099 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 3089 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 772 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 3069 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 3064 of file Event.h.

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

Copy constructor for events.

Definition at line 1740 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 1696 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 1688 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 1680 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 1672 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 1664 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 1656 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 1648 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 1640 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 1632 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 1624 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 1616 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 1608 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 1600 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 1592 of file Event.h.

Event< void(A0)> event ( mbed::Callback< R(B0, B1, B2, B3, B4, A0)>  cb,
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 2899 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 1576 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 1568 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 1560 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 1552 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 1544 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0,c1,c2,c3,c4Arguments to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0..b4, the arguments to the underlying callback.

Definition at line 1536 of file Event.h.

Event< void(A0)> event ( mbed::Callback< R(B0, B1, A0)>  cb,
C0  c0,
C1  c1 
) [inherited]

Creates an event bound to the event queue.

See also:
EventQueue::event

Definition at line 2809 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 3514 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0Argument to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0, the arguments to the underlying callback.

Definition at line 648 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0,c1,c2Arguments to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0..b2, the arguments to the underlying callback.

Definition at line 1510 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 2819 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0,c1,c2,c3Arguments to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0..b3, the arguments to the underlying callback.

Definition at line 1523 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0,c1Arguments to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0..b1, the arguments to the underlying callback.

Definition at line 661 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0Argument to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0, the arguments to the underlying callback.

Definition at line 230 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0,c1,c2Arguments to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0..b2, the arguments to the underlying callback.

Definition at line 674 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0,c1,c2,c3Arguments to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0..b3, the arguments to the underlying callback.

Definition at line 687 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 3454 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 3494 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0,c1Arguments to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0..b1, the arguments to the underlying callback.

Definition at line 243 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0,c1,c2,c3,c4Arguments to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0..b4, the arguments to the underlying callback.

Definition at line 700 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 1584 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 708 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0,c1,c2Arguments to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0..b2, the arguments to the underlying callback.

Definition at line 256 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 716 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 724 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 3474 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0,c1,c2,c3Arguments to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0..b3, the arguments to the underlying callback.

Definition at line 269 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 732 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 740 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0,c1,c2,c3,c4Arguments to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0..b4, the arguments to the underlying callback.

Definition at line 282 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 748 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 756 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 1198 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 1190 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 1182 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 2532 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 1166 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 1158 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 1150 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 2468 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 1134 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 1126 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0,c1,c2,c3,c4Arguments to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0..b4, the arguments to the underlying callback.

Definition at line 1118 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 2404 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0,c1,c2Arguments to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0..b2, the arguments to the underlying callback.

Definition at line 1092 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0,c1Arguments to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0..b1, the arguments to the underlying callback.

Definition at line 1079 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0,c1,c2Arguments to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0..b2, the arguments to the underlying callback.

Definition at line 2346 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 3539 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 3519 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,
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 370 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 3459 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 3599 of file Event.h.

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

Copy constructor for events.

Definition at line 2158 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 2106 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 2090 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 2074 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 2058 of file Event.h.

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

Copy constructor for events.

Definition at line 904 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 2026 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 852 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 844 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 836 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 3219 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 820 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 812 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 804 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 306 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 788 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 298 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 3444 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 3554 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 764 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 3059 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 290 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 3584 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 3449 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 3614 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 314 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 3414 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 3434 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 322 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 828 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 1962 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 330 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 338 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 860 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 346 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 3424 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 3504 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 354 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 3544 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 3569 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 3574 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 3604 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 3509 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 442 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 1174 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 426 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 1142 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 410 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0,c1,c2,c3Arguments to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0..b3, the arguments to the underlying callback.

Definition at line 1105 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 386 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0Argument to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0, the arguments to the underlying callback.

Definition at line 1066 of file Event.h.

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

Create an event.

Parameters:
qEvent queue to dispatch on
fFunction to execute when the event is dispatched
c0Argument to bind to the callback, these arguments are allocated on an irq-safe allocator from the event queue's memory pool. Must be type-compatible with b0, the arguments to the underlying callback.

Definition at line 2320 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 394 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 402 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 3534 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 418 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 434 of file Event.h.

void operator() (  ) const [inherited]

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

Definition at line 155 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,a1,a2,a3,a4Arguments to pass to the event

Definition at line 2244 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,a1,a2,a3Arguments to pass to the event

Definition at line 1826 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,a1,a2Arguments to pass to the event

Definition at line 1408 of file Event.h.

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

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

Parameters:
a0Argument to pass to the event

Definition at line 572 of file Event.h.

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

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

Parameters:
a0,a1Arguments to pass to the event

Definition at line 990 of file Event.h.

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

Assignment operator for events.

Definition at line 496 of file Event.h.

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

Assignment operator for events.

Definition at line 914 of file Event.h.

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

Assignment operator for events.

Definition at line 1332 of file Event.h.

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

Assignment operator for events.

Definition at line 2168 of file Event.h.

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

Assignment operator for events.

Definition at line 1750 of file Event.h.

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

Assignment operator for events.

Definition at line 82 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 531 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 1367 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 2203 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 949 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 1785 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:
a0Argument 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 550 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,a1Arguments 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 968 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,a1,a2,a3Arguments 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 1804 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.

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 135 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,a1,a2Arguments 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 1386 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,a1,a2,a3,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 2222 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
a0Argument to pass to the event

Definition at line 581 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,a1Arguments to pass to the event

Definition at line 999 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,a1,a2Arguments to pass to the event

Definition at line 1417 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,a1,a2,a3,a4Arguments to pass to the event

Definition at line 2253 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

Definition at line 163 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,a1,a2,a3Arguments to pass to the event

Definition at line 1835 of file Event.h.

~Event (  ) [inherited]

Destructor for events.

Definition at line 2179 of file Event.h.

~Event (  ) [inherited]

Destructor for events.

Definition at line 1761 of file Event.h.

~Event (  ) [inherited]

Destructor for events.

Definition at line 93 of file Event.h.

~Event (  ) [inherited]

Destructor for events.

Definition at line 1343 of file Event.h.

~Event (  ) [inherited]

Destructor for events.

Definition at line 507 of file Event.h.

~Event (  ) [inherited]

Destructor for events.

Definition at line 925 of file Event.h.