Mbed OS 文档翻译之参考（API（RTOS（EventQueue）））

最新推荐文章于 2018-09-20 22:05:14 发布

XinLiBK

最新推荐文章于 2018-09-20 22:05:14 发布

阅读量728

点赞数 1

分类专栏： Mbed OS 文章标签： Mbed Mbed OS Mbed OS 5

Mbed OS 专栏收录该内容

146 篇文章 28 订阅

订阅专栏

EventQueue

EventQueue 类层次结构

EventQueue 类为调度事件提供了灵活的队列。您可以使用 EventQueue 类在多个线程之间进行同步，或者将事件移出中断上下文（延迟执行耗时或非 ISR 安全操作）。

EventQueue 类是线程和 ISR 安全的。

您可以使用 dispatch 和 dispatch_forever API 来执行挂起事件。break_dispatch 用于终止指定 EventQueue 中事件的执行。

共享事件队列

Mbed OS 提供了两个软件可以使用的共享队列。这可以避免创建私有事件分派线程并减少使用的 RAM 总量的需要。

EventQueue 类参考

events::EventQueue 类参考

数据结构
struct	context00
struct	context01
struct	context02
struct	context03
struct	context04
struct	context05
struct	context10
struct	context11
struct	context12
struct	context13
struct	context14
struct	context15
struct	context20
struct	context21
struct	context22
struct	context23
struct	context24
struct	context25
struct	context30
struct	context31
struct	context32
struct	context33
struct	context34
struct	context35
struct	context40
struct	context41
struct	context42
struct	context43
struct	context44
struct	context45
struct	context50
struct	context51
struct	context52
struct	context53
struct	context54
struct	context55

公共成员函数
	EventQueue (unsigned size=(32 ((sizeof(struct equeue_event)+2 sizeof(void ))-2 sizeof(void )+sizeof(mbed::Callback< void()>))), unsigned char buffer=NULL)
	~EventQueue ()
void	dispatch (int ms=-1)
void	dispatch_forever ()
void	break_dispatch ()
unsigned	tick ()
void	cancel (int id)
int	time_left (int id)
void	background (mbed::Callback< void(int)> update)
void	chain (EventQueue *target)
template<typename F >
int	call (F f)
template<typename F , typename A0 >
int	call (F f, A0 a0)
template<typename F , typename A0 , typename A1 >
int	call (F f, A0 a0, A1 a1)
template<typename F , typename A0 , typename A1 , typename A2 >
int	call (F f, A0 a0, A1 a1, A2 a2)
template<typename F , typename A0 , typename A1 , typename A2 , typename A3 >
int	call (F f, A0 a0, A1 a1, A2 a2, A3 a3)
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)
template<typename T , typename R >
int	call (T obj, R(T::method)())
template<typename T , typename R >
int	call (const T obj, R(T::method)() const)
template<typename T , typename R >
int	call (volatile T obj, R(T::method)() volatile)
template<typename T , typename R >
int	call (const volatile T obj, R(T::method)() const volatile)
template<typename T , typename R , typename A0 >
int	call (T obj, R(T::method)(A0), A0 a0)
template<typename T , typename R , typename A0 >
int	call (const T obj, R(T::method)(A0) const, A0 a0)
template<typename T , typename R , typename A0 >
int	call (volatile T obj, R(T::method)(A0) volatile, A0 a0)
template<typename T , typename R , typename A0 >
int	call (const volatile T obj, R(T::method)(A0) const volatile, A0 a0)
template<typename T , typename R , typename A0 , typename A1 >
int	call (T obj, R(T::method)(A0, A1), A0 a0, A1 a1)
template<typename T , typename R , typename A0 , typename A1 >
int	call (const T obj, R(T::method)(A0, A1) const, A0 a0, A1 a1)
template<typename T , typename R , typename A0 , typename A1 >
int	call (volatile T obj, R(T::method)(A0, A1) volatile, A0 a0, A1 a1)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
template<typename F >
int	call_in (int ms, F f)
template<typename F , typename A0 >
int	call_in (int ms, F f, A0 a0)
template<typename F , typename A0 , typename A1 >
int	call_in (int ms, F f, A0 a0, A1 a1)
template<typename F , typename A0 , typename A1 , typename A2 >
int	call_in (int ms, F f, A0 a0, A1 a1, A2 a2)
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)
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)
template<typename T , typename R >
int	call_in (int ms, T obj, R(T::method)())
template<typename T , typename R >
int	call_in (int ms, const T obj, R(T::method)() const)
template<typename T , typename R >
int	call_in (int ms, volatile T obj, R(T::method)() volatile)
template<typename T , typename R >
int	call_in (int ms, const volatile T obj, R(T::method)() const volatile)
template<typename T , typename R , typename A0 >
int	call_in (int ms, T obj, R(T::method)(A0), A0 a0)
template<typename T , typename R , typename A0 >
int	call_in (int ms, const T obj, R(T::method)(A0) const, A0 a0)
template<typename T , typename R , typename A0 >
int	call_in (int ms, volatile T obj, R(T::method)(A0) volatile, A0 a0)
template<typename T , typename R , typename A0 >
int	call_in (int ms, const volatile T obj, R(T::method)(A0) const volatile, A0 a0)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
template<typename F >
int	call_every (int ms, F f)
template<typename F , typename A0 >
int	call_every (int ms, F f, A0 a0)
template<typename F , typename A0 , typename A1 >
int	call_every (int ms, F f, A0 a0, A1 a1)
template<typename F , typename A0 , typename A1 , typename A2 >
int	call_every (int ms, F f, A0 a0, A1 a1, A2 a2)
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)
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)
template<typename T , typename R >
int	call_every (int ms, T obj, R(T::method)())
template<typename T , typename R >
int	call_every (int ms, const T obj, R(T::method)() const)
template<typename T , typename R >
int	call_every (int ms, volatile T obj, R(T::method)() volatile)
template<typename T , typename R >
int	call_every (int ms, const volatile T obj, R(T::method)() const volatile)
template<typename T , typename R , typename A0 >
int	call_every (int ms, T obj, R(T::method)(A0), A0 a0)
template<typename T , typename R , typename A0 >
int	call_every (int ms, const T obj, R(T::method)(A0) const, A0 a0)
template<typename T , typename R , typename A0 >
int	call_every (int ms, volatile T obj, R(T::method)(A0) volatile, A0 a0)
template<typename T , typename R , typename A0 >
int	call_every (int ms, const volatile T obj, R(T::method)(A0) const volatile, A0 a0)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
template<typename R >
Event< void()>	event (R(*func)())
template<typename T , typename R >
Event< void()>	event (T obj, R(T::method)())
template<typename T , typename R >
Event< void()>	event (const T obj, R(T::method)() const)
template<typename T , typename R >
Event< void()>	event (volatile T obj, R(T::method)() volatile)
template<typename T , typename R >
Event< void()>	event (const volatile T obj, R(T::method)() const volatile)
template<typename R >
Event< void()>	event (mbed::Callback< R()> cb)
template<typename R , typename B0 , typename C0 >
Event< void()>	event (R(*func)(B0), C0 c0)
template<typename T , typename R , typename B0 , typename C0 >
Event< void()>	event (T obj, R(T::method)(B0), C0 c0)
template<typename T , typename R , typename B0 , typename C0 >
Event< void()>	event (const T obj, R(T::method)(B0) const, C0 c0)
template<typename T , typename R , typename B0 , typename C0 >
Event< void()>	event (volatile T obj, R(T::method)(B0) volatile, C0 c0)
template<typename T , typename R , typename B0 , typename C0 >
Event< void()>	event (const volatile T obj, R(T::method)(B0) const volatile, C0 c0)
template<typename R , typename B0 , typename C0 >
Event< void()>	event (mbed::Callback< R(B0)> cb, C0 c0)
template<typename R , typename B0 , typename B1 , typename C0 , typename C1 >
Event< void()>	event (R(*func)(B0, B1), C0 c0, C1 c1)
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)
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)
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)
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)
template<typename R , typename B0 , typename B1 , typename C0 , typename C1 >
Event< void()>	event (mbed::Callback< R(B0, B1)> cb, C0 c0, C1 c1)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
template<typename R , typename A0 >
Event< void(A0)>	event (R(*func)(A0))
template<typename T , typename R , typename A0 >
Event< void(A0)>	event (T obj, R(T::method)(A0))
template<typename T , typename R , typename A0 >
Event< void(A0)>	event (const T obj, R(T::method)(A0) const)
template<typename T , typename R , typename A0 >
Event< void(A0)>	event (volatile T obj, R(T::method)(A0) volatile)
template<typename T , typename R , typename A0 >
Event< void(A0)>	event (const volatile T obj, R(T::method)(A0) const volatile)
template<typename R , typename A0 >
Event< void(A0)>	event (mbed::Callback< R(A0)> cb)
template<typename R , typename B0 , typename C0 , typename A0 >
Event< void(A0)>	event (R(*func)(B0, A0), C0 c0)
template<typename T , typename R , typename B0 , typename C0 , typename A0 >
Event< void(A0)>	event (T obj, R(T::method)(B0, A0), C0 c0)
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)
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)
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)
template<typename R , typename B0 , typename C0 , typename A0 >
Event< void(A0)>	event (mbed::Callback< R(B0, A0)> cb, C0 c0)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
template<typename R , typename A0 , typename A1 >
Event< void(A0, A1)>	event (R(*func)(A0, A1))
template<typename T , typename R , typename A0 , typename A1 >
Event< void(A0, A1)>	event (T obj, R(T::method)(A0, A1))
template<typename T , typename R , typename A0 , typename A1 >
Event< void(A0, A1)>	event (const T obj, R(T::method)(A0, A1) const)
template<typename T , typename R , typename A0 , typename A1 >
Event< void(A0, A1)>	event (volatile T obj, R(T::method)(A0, A1) volatile)
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)
template<typename R , typename A0 , typename A1 >
Event< void(A0, A1)>	event (mbed::Callback< R(A0, A1)> cb)
template<typename R , typename B0 , typename C0 , typename A0 , typename A1 >
Event< void(A0, A1)>	event (R(*func)(B0, A0, A1), C0 c0)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
template<typename R , typename A0 , typename A1 , typename A2 >
Event< void(A0, A1, A2)>	event (R(*func)(A0, A1, A2))
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))
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)
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)
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)
template<typename R , typename A0 , typename A1 , typename A2 >
Event< void(A0, A1, A2)>	event (mbed::Callback< R(A0, A1, A2)> cb)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
template<typename R , typename A0 , typename A1 , typename A2 , typename A3 >
Event< void(A0, A1, A2, A3)>	event (R(*func)(A0, A1, A2, A3))
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))
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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))
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))
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)

静态保护的成员函数
template<typename F >
static void	function_call (void *p)
template<typename F >
static void	function_dtor (void *p)

受保护的属性
struct equeue	_equeue
mbed::Callback< void(int)>	_update

友元
template<typename F >
class	Event

共享事件队列参考

mbed_shared_queues.h

EventQueue 示例: 推迟中断上下文

代码在两个不同的上下文中执行两个处理函数（rise_handler 和 fall_handler）：

在中断上下文中，当在 SW2（rise_handler）上检测到上升沿时。
在 SW2（fall_handler）上检测到下降沿时，在事件循环的线程函数的上下文中。您可以使用 fall_handler 函数作为 queue.event() 的参数来指定 fall_handler 在用户上下文中运行而不是在中断上下文中运行。

main.cpp 导入到 Mbed IDE

#include "mbed.h"
#include "mbed_events.h"

DigitalOut led1(LED1);
InterruptIn sw(SW2);
EventQueue queue(32 * EVENTS_EVENT_SIZE);
Thread t;

void rise_handler(void) {
    // Toggle LED
    led1 = !led1;
}

void fall_handler(void) {
    printf("fall_handler in context %p\r\n", Thread::gettid());
    // Toggle LED
    led1 = !led1;
}

int main() {
    // Start the event queue
    t.start(callback(&queue, &EventQueue::dispatch_forever));
    printf("Starting in context %p\r\n", Thread::gettid());
    // The 'rise' handler will execute in IRQ context
    sw.rise(rise_handler);
    // The 'fall' handler will execute in the context of thread 't'
    sw.fall(queue.event(fall_handler));
}

共享事件示例：推迟中断上下文

与前面的示例一样，这会从中断延迟到事件队列线程。但是，它不是创建自己的线程，而是使用共享事件队列 - 可能与其他系统组件共享并保存 RAM。

在共享事件队列时，您应该限制事件函数的执行时间，以避免过度延迟其他用户的事件。

main.cpp 导入到 Mbed IDE

#include "mbed.h"
#include "mbed_events.h"
 
DigitalOut led1(LED1);
InterruptIn sw(SW2);
 
void rise_handler(void) {
    // Toggle LED
    led1 = !led1;
}
 
void fall_handler(void) {
    printf("fall_handler in context %p\r\n", Thread::gettid());
    // Toggle LED
    led1 = !led1;
}
 
int main() {
    // Request the shared queue
    EventQueue *queue = mbed_event_queue();
    printf("Starting in context %p\r\n", Thread::gettid());
    // The 'rise' handler will execute in IRQ context
    sw.rise(rise_handler);
    // The 'fall' handler will execute in the context of the shared queue thread
    sw.fall(queue->event(fall_handler));
}

EventQueue 示例: 将事件发布到队列中

下面的代码演示了在延迟之后调用的排队函数以及定期调用的排队函数。

main.cpp 导入到 Mbed IDE

#include "mbed_events.h"
#include <stdio.h>

int main() {
    // creates a queue with the default size
    EventQueue queue;

    // events are simple callbacks
    queue.call(printf, "called immediately\n");
    queue.call_in(2000, printf, "called in 2 seconds\n");
    queue.call_every(1000, printf, "called every 1 seconds\n");

    // events are executed by the dispatch method
    queue.dispatch();
}

EventQueue 示例: 链接来自多个队列的事件

事件队列很容易与模块边界对齐，事件调度可以隐式地同步内部状态。多个模块可以使用独立的事件队列，但仍然可以通过EventQueue :: chain 函数组成。

main.cpp 导入到 Mbed IDE

#include "mbed_events.h"
#include <stdio.h>

/**
Event queues easily align with module boundaries, where internal state can be 
implicitly synchronized through event dispatch. Multiple modules can use 
independent event queues, but still be composed through the EventQueue::chain function.
**/

int main() {
    // Create some event queues with pending events
    EventQueue a;
    a.call(printf, "hello from a!\n");
    
    EventQueue b;
    b.call(printf, "hello from b!\n");
    
    EventQueue c;
    c.call(printf, "hello from c!\n");
    
    // Chain c and b onto a's event queue. Both c and b will be dispatched
    // in the context of a's dispatch function.
    c.chain(&a);
    b.chain(&a);
    
    // Dispatching a will in turn dispatch b and c, printing hello from
    // all three queues
    a.dispatch();
}

共享事件示例：从 main 运行共享队列

为了进一步节省 RAM，如果初始化后在 main 函数中没有其他工作要做，则可以从那里调度全局事件队列，从而无需创建单独的调度线程。

为此，请将 mbed_app.json 配置选项 events.shared-dispatch-from-application 设置为 true，并向 main 添加调度调用，如本例所示。（打印现在显示启动和 fall_handler 的相同上下文）。

main.cpp 导入到 Mbed IDE

#include "mbed.h"
#include "mbed_events.h"
 
DigitalOut led1(LED1);
InterruptIn sw(SW2);
 
void rise_handler(void) {
    // Toggle LED
    led1 = !led1;
}
 
void fall_handler(void) {
    printf("fall_handler in context %p\r\n", Thread::gettid());
    // Toggle LED
    led1 = !led1;
}
 
int main() {
    // Request the shared queue
    EventQueue *queue = mbed_event_queue();
    printf("Starting in context %p\r\n", Thread::gettid());
    // The 'rise' handler will execute in IRQ context
    sw.rise(rise_handler);
    // The 'fall' handler will execute in the context of the shared queue (actually the main thread)
    sw.fall(queue->event(fall_handler));
    // Setup complete, so we now dispatch the shared queue from main
    queue->dispatch_forever();
}