Daiki Kato / mbed-os-lychee

Important changes to repositories hosted on mbed.com

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

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

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

Dependents:   mbed-os-example-blinky-gr-lychee GR-Boads_Camera_sample GR-Boards_Audio_Recoder GR-Boads_Camera_DisplayApp ... more

Embed: (wiki syntax)

« Back to documentation index

Events
Data Structures | Functions

Events

Data Structures

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

Functions

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

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

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

Passing a null function disables the existing update function.

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

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

Break out of a running event loop.

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

void call ( A0  a0 ) const [inherited]

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

Parameters:
a0..a4Arguments to pass to the event

Definition at line 548 of file Event.h.

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

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

Parameters:
a0..a4Arguments to pass to the event

Definition at line 1340 of file Event.h.

int call ( F  f ) [inherited]

Calls an event on the queue.

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

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

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

Definition at line 176 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 191 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 199 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 207 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 215 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 223 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 231 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 239 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 247 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 255 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 263 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 271 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 279 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 287 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 295 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 303 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 311 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 319 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 327 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 335 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 343 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 351 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 359 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 367 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 375 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 383 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 391 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 399 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 407 of file EventQueue.h.

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

Calls an event on the queue.

See also:
EventQueue::call

Definition at line 415 of file EventQueue.h.

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

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

Parameters:
a0..a4Arguments to pass to the event

Definition at line 1736 of file Event.h.

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

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

Parameters:
a0..a4Arguments to pass to the event

Definition at line 2132 of file Event.h.

void call (  ) const [inherited]

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

Parameters:
a0..a4Arguments to pass to the event

Definition at line 152 of file Event.h.

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

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

Parameters:
a0..a4Arguments to pass to the event

Definition at line 944 of file Event.h.

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

Calls an event on the queue periodically.

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

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

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

Definition at line 695 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 712 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 720 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 728 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 736 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 744 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 752 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 760 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 768 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 776 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 784 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 792 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 800 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 808 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 816 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 824 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 832 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 840 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 848 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 856 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 864 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 872 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 880 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 888 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 896 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 904 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 912 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 920 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 928 of file EventQueue.h.

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

Calls an event on the queue periodically.

See also:
EventQueue::call_every

Definition at line 936 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

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

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

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

Definition at line 435 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 459 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 467 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 475 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 483 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 491 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 499 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 507 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 515 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 523 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 531 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 539 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 547 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 555 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 563 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 571 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 587 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 595 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 603 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 611 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 619 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 627 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 635 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 651 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 659 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 667 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 451 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 675 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 579 of file EventQueue.h.

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

Calls an event on the queue after a specified delay.

See also:
EventQueue::call_in

Definition at line 643 of file EventQueue.h.

void cancel (  ) const [inherited]

Cancels the most recently posted event.

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

The cancel function is irq safe.

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

Definition at line 1373 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 185 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 581 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 1769 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 977 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 2165 of file Event.h.

void cancel ( int  id ) [inherited]

Cancel an in-flight event.

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

The cancel function is irq safe.

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

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

Chain an event queue onto another event queue.

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

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

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

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

Configure the delay of an event.

Parameters:
delayMillisecond delay before dispatching the event

Definition at line 110 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 506 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 1298 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 1694 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 2090 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 902 of file Event.h.

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

Dispatch events.

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

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

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

Dispatch events without a timeout.

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

See also:
EventQueue::dispatch

Definition at line 91 of file EventQueue.h.

Event< void(A0, A1, 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 2984 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 2979 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 2974 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 2969 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 2964 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 2959 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 2954 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 2949 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 2944 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 2989 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 2934 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 2929 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 2924 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 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 2914 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 3064 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 3104 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 3174 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 2894 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 2889 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 3194 of file Event.h.

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

Copy constructor for events.

Definition at line 471 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 2874 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 3239 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 2864 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 1144 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 2854 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 1152 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 3259 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 3269 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 2834 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 2829 of file Event.h.

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

Create an event.

See also:
Event::Event

Definition at line 652 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 3279 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 2814 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 3284 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 2804 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 1160 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 2794 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 2789 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 2784 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 1484 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 2774 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 2769 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 2764 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 2759 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 2754 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 2749 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 2744 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 1168 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 2734 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 2729 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 2724 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 3309 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 2714 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 2709 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 2704 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 2699 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 2694 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 2689 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 2684 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 2679 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 2674 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 2669 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 2664 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 2659 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 2654 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 2649 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 2644 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 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 2634 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 2629 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 2624 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 2619 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 2614 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 2609 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 2604 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 3149 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 2594 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 2589 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 2584 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 2579 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 2574 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 2569 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 2564 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 2559 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 2554 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 2549 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 2544 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 3319 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 2534 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 3324 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 2524 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 1176 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 2514 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 1476 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 2504 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 1184 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 2494 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 2489 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 2484 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 3349 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 2474 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 3154 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 2464 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 2459 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 2454 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 1192 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 2444 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 3359 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 2434 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 2429 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 2424 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 2419 of file Event.h.

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

Creates an event bound to the event queue.

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

Parameters:
fFunction to execute when the event is dispatched
c0..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.
Returns:
Event that will dispatch on the specific queue

Definition at line 2414 of file Event.h.

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

Create an event.

See also:
Event::Event

Definition at line 644 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 1468 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 1200 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 3389 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 3094 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 3109 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 3224 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 1208 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 3399 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 692 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 1564 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 1216 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 3419 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 3424 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 1460 of file Event.h.

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

Create an event.

See also:
Event::Event

Definition at line 636 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 3439 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 676 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 3444 of file Event.h.

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

Copy constructor for events.

Definition at line 1263 of file Event.h.

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

Create an event.

See also:
Event::Event

Definition at line 1452 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 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 3469 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 3164 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 3479 of file Event.h.

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

Create an event.

See also:
Event::Event

Definition at line 660 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 1500 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 3414 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 1492 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 3314 of file Event.h.

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

Create an event.

See also:
Event::Event

Definition at line 1444 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 3254 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 3429 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 3369 of file Event.h.

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

Create an event.

See also:
Event::Event

Definition at line 1436 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 3449 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 3189 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 3334 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 3384 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 3374 of file Event.h.

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

Create an event.

See also:
Event::Event

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

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

Create an event.

See also:
Event::Event

Definition at line 628 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 3484 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 3464 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 3379 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 3234 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 3274 of file Event.h.

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

Create an event.

See also:
Event::Event

Definition at line 1420 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 3289 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 3489 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 3474 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 3339 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 3179 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 3204 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 3214 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 3264 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 3434 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 3249 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 3454 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 3294 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 3184 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 3304 of file Event.h.

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

Create an event.

See also:
Event::Event

Definition at line 232 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 3329 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 3404 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 3409 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 3009 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 3019 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 3034 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 3139 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 3299 of file Event.h.

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

Create an event.

See also:
Event::Event

Definition at line 240 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 1508 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 1516 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 668 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 1524 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 3074 of file Event.h.

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

Create an event.

See also:
Event::Event

Definition at line 248 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 1532 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 1540 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 1548 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 684 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 1556 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 3054 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 3144 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 3364 of file Event.h.

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

Create an event.

See also:
Event::Event

Definition at line 256 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 1572 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 1580 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 700 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 3229 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 3219 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 3209 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 3199 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 1112 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 1120 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 3169 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 3159 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 2396 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 2388 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 2380 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 2372 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 2364 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 2356 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 2348 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 2340 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 2332 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 2324 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 2316 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 2308 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 2300 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 2292 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 2284 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 2999 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 2268 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 2260 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 2252 of file Event.h.

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

Create an event.

See also:
Event::Event

Definition at line 2244 of file Event.h.

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

Create an event.

See also:
Event::Event

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

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

Create an event.

See also:
Event::Event

Definition at line 2220 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 2919 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 2909 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 2904 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 360 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 2884 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 2869 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 2859 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 2849 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 2844 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 344 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 2824 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 2809 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 2799 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 2008 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 2779 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 1992 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 1984 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 1976 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 2739 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 1960 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 2719 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 1944 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 1936 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 1928 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 1920 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 1912 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 1904 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 1896 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 1888 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 1880 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 1872 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 1864 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 2599 of file Event.h.

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

Create an event.

See also:
Event::Event

Definition at line 1848 of file Event.h.

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

Create an event.

See also:
Event::Event

Definition at line 1840 of file Event.h.

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

Create an event.

See also:
Event::Event

Definition at line 1832 of file Event.h.

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

Create an event.

See also:
Event::Event

Definition at line 1824 of file Event.h.

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

Create an event.

See also:
Event::Event

Definition at line 1816 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 2539 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 2529 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 2519 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 2509 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 2499 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 740 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 2479 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 2469 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 732 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 2449 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 2439 of file Event.h.

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

Copy constructor for events.

Definition at line 1659 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 1612 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 1588 of file Event.h.

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

Create an event.

See also:
Event::Event

Definition at line 264 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 1596 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 708 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 1604 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 716 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 3024 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 3069 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 3079 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 724 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 272 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 3244 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 280 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 748 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 3029 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 288 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 756 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 764 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 296 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 772 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 780 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 2994 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 3014 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 3059 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 304 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 788 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 1856 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 796 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 312 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 804 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 812 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 3044 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 320 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 820 of file Event.h.

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

Copy constructor for events.

Definition at line 867 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 328 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 1952 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 1968 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 3004 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 3084 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 3119 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 336 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 2000 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 3134 of file Event.h.

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

Copy constructor for events.

Definition at line 2055 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 2819 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 1136 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 1128 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 416 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 2404 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 1104 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 1096 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 1088 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 1080 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 1072 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 1064 of file Event.h.

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

Create an event.

See also:
Event::Event

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

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

Create an event.

See also:
Event::Event

Definition at line 1040 of file Event.h.

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

Create an event.

See also:
Event::Event

Definition at line 1032 of file Event.h.

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

Create an event.

See also:
Event::Event

Definition at line 2228 of file Event.h.

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

Create an event.

See also:
Event::Event

Definition at line 2212 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 2899 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 2879 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 3344 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 3354 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 2839 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 352 of file Event.h.

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

Copy constructor for events.

Definition at line 75 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 3039 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 3089 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 368 of file Event.h.

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

Create an event.

See also:
Event::Event

Definition at line 1024 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 376 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 384 of file Event.h.

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

Create an event.

See also:
Event::Event

Definition at line 1048 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 392 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 3099 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 3114 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 400 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 408 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 3124 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 3129 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 424 of file Event.h.

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

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

Parameters:
a0..a4Arguments to pass to the event

Definition at line 2141 of file Event.h.

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

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

Parameters:
a0..a4Arguments to pass to the event

Definition at line 557 of file Event.h.

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

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

Parameters:
a0..a4Arguments to pass to the event

Definition at line 1349 of file Event.h.

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

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

Parameters:
a0..a4Arguments to pass to the event

Definition at line 953 of file Event.h.

void operator() (  ) const [inherited]

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

Parameters:
a0..a4Arguments to pass to the event

Definition at line 161 of file Event.h.

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

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

Parameters:
a0..a4Arguments to pass to the event

Definition at line 1745 of file Event.h.

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

Assignment operator for events.

Definition at line 1669 of file Event.h.

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

Assignment operator for events.

Definition at line 877 of file Event.h.

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

Assignment operator for events.

Definition at line 85 of file Event.h.

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

Assignment operator for events.

Definition at line 2065 of file Event.h.

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

Assignment operator for events.

Definition at line 481 of file Event.h.

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

Assignment operator for events.

Definition at line 1273 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 516 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 2100 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 1308 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 1704 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 912 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 120 of file Event.h.

int post ( A0  a0 ) const [inherited]

Posts an event onto the underlying event queue.

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

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

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

Definition at line 535 of file Event.h.

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

Posts an event onto the underlying event queue.

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

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

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

Definition at line 1327 of file Event.h.

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

Posts an event onto the underlying event queue.

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

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

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

Definition at line 931 of file Event.h.

int post (  ) const [inherited]

Posts an event onto the underlying event queue.

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

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

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

Definition at line 139 of file Event.h.

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

Posts an event onto the underlying event queue.

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

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

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

Definition at line 1723 of file Event.h.

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

Posts an event onto the underlying event queue.

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

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

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

Definition at line 2119 of file Event.h.

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

Static thunk for passing as C-style function.

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

Definition at line 170 of file Event.h.

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

Static thunk for passing as C-style function.

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

Definition at line 962 of file Event.h.

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

Static thunk for passing as C-style function.

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

Definition at line 1754 of file Event.h.

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

Static thunk for passing as C-style function.

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

Definition at line 566 of file Event.h.

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

Static thunk for passing as C-style function.

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

Definition at line 1358 of file Event.h.

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

Static thunk for passing as C-style function.

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

Definition at line 2150 of file Event.h.

unsigned tick (  ) [inherited]

Millisecond counter.

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

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

Destructor for events.

Definition at line 492 of file Event.h.

~Event (  ) [inherited]

Destructor for events.

Definition at line 1680 of file Event.h.

~Event (  ) [inherited]

Destructor for events.

Definition at line 888 of file Event.h.

~Event (  ) [inherited]

Destructor for events.

Definition at line 1284 of file Event.h.

~Event (  ) [inherited]

Destructor for events.

Definition at line 96 of file Event.h.

~Event (  ) [inherited]

Destructor for events.

Definition at line 2076 of file Event.h.

~EventQueue (  ) [inherited]

Destroy an EventQueue.

Generated on Tue Jul 12 2022 11:02:39 by  doxygen 1.7.2