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

最新推荐文章于 2018-09-20 22:05:14 发布
最新推荐文章于 2018-09-20 22:05:14 发布
阅读量758 收藏 1
点赞数 1
分类专栏： Mbed OS 文章标签： Mbed Mbed OS Mbed OS 5

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）：

  1. 在中断上下文中，当在 SW2（rise_handler）上检测到上升沿时。
  2. 在 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();
}
MBEDOS参考手册
02-24
应用代码采用C++编写，使用MbedOS提供的API，在不同的微处理器上按照统一的编程实现。便于应用的开发。基本架构图2.1.1入口点MbedOS提供了两个入口点·main(void)-所有的标准应用都使用该代码入口点·mbed_main(void...
mbedtls官方文档离线版本
10-30
mbedtls官方文档（包括所有API说明）的离线版本，方便没网时候单机查询，chm格式，原始网站为：https://tls.mbed.org/api/，手工拉取所有网站内容制作的离线版本文档。
Mbed OS 文档翻译 之 参考（API（RTOS（Event）））
XinLiBK的博客
08-26 371
Event Event 类提供 API 来配置事件延迟和周期时间。您可以使用 post API 将事件发布到基础 EventQueue，您可以使用 cancel 取消最近发布的事件。 Event 类是线程安全的。post 和 cancel API 是 IRQ 安全的。 Event 类参考 Event.h EventQueue 示例：将事件发布到队列 下面的代码演示了如何实例化，配置和...
Mbed OS 文档翻译 之 参考（API（RTOS（Queue）））
XinLiBK的博客
08-24 465
Queue                                                                                                                                                          Queue 类层次结构 Queue 允许您将指向生产者线程的数据的指针排队...
漫谈Mbed OS（2）
姚家湾博客
09-20 2870
我们来聊聊为什么要使用Mbed OS。 因为使用MbedOS 感觉不错，不免向别人推荐它，我们遇到的程序员有两种类型：  1 没有嵌入式程序设计经验的人，比如大学生，或者是学校的教师。 他们问的问题大多数是。是否流行？是否有教材？并不关心是否好用，对他们是否合适。 2 已经具有Cortex-M 嵌入式处理器编程经验的人，企业中的程序员许多是裸机编程的程序员。      他们已经习惯于裸机...
Mbed OS 文档翻译 之 参考（API（网络套接字（概述）））
XinLiBK的博客
08-26 510
网络套接字概述 IP 网络的应用程序编程接口是 Socket API。如本书的 IP 网络部分所述，Socket API 与 OSI 第 4 层（传输层）相关。在 Mbed OS 中，Socket API 支持 TCP 和 UDP 协议。                                                                             ...
Mbed OS 文档翻译 之 参考（配置（概述））
XinLiBK的博客
08-14 2092
配置系统 Arm Mbed OS 配置系统是 Arm Mbed OS 构建工具的一部分，可自定义编译时配置参数。每个库可以在其 mbed_lib.json 中定义许多配置参数。mbed_app.json 可以覆盖这些配置参数的值。配置使用 JSON 定义。配置参数的一些示例： 数据采集应用程序的采样周期。 新创建的 OS 线程的默认栈大小。 串行通信库的接收缓冲区大小。 Mbed 目标的...
mbed_blinky_mbed创建头文件_mbedos_sincesyh_
10-01
mbed OS是一个开源的实时操作系统（RTOS），专为物联网设备设计，提供丰富的API和库，简化了微控制器（MCU）应用程序的开发。 【描述】提到的"Mbed源码和头文件"意味着这个项目中包含了用mbed编程语言编写的源代码...
MBED OS 参考手册-边读边翻译，
dongxxx的专栏
05-18 3366
 参考手册从总体上、运行时、配置、模块技术和API方面对MBED  OS进行了全面的介绍。在阅读参考手册的同时，翻译了部分资料。1  概述 1.1  Mbed OS 参考手册应用代码采用C++编写，使用Mbed OS提供的API，在不同的微处理器上按照统一的编程实现。便于应用的开发。基本架构图   2  运行时2.1  引导 2.1.1入口点Mbed OS提供了两个入口点·        main...
EventQueue事件
tan313的专栏
11-07 2155
当在其他线程中执行费时的业务处理时，
Mbed OS 文档翻译 之 参考（API（平台（Mbed statistics）））
XinLiBK的博客
08-21 731
Mbed 统计 Mbed OS 提供了一组函数，可用于在运行时捕获内存和线程统计信息。mbed_stats.h 声明了这些函数。要启用所有 Mbed OS 统计信息，必须使用 MBED_ALL_STATS_ENABLED 宏构建代码。 内存统计 您可以使用内存统计函数在运行时捕获堆使用情况，累积栈使用情况或每个线程的栈使用情况。要启用内存使用情况监视，必须使用以下宏构建 Mbed OS： ...
callqueue:提供一次运行一个命令的简单方法
06-17
呼叫队列 提供一次运行一个命令的简单方法。 为使用 1 号管道的 cron 和长期作业做好准备。 安装 npm install callqueue --save 例子 var callqueue = require ( "callqueue" ) ; //you must provide methods names to setup bindings var sendEmails = callqueue ( require . resolve ( "./lib/sendEmails.js" ) , [ "method1" , "method2" ] ) ; ... [ "email1" , "email2" ] . forEach ( function ( type ) { sendEmails . method1 ( type , function ( err , result
mbed-os：Arm Mbed OS是为物联网设计的平台操作系统
02-20
Arm Mbed OS是专门为物联网中的“事物”设计的开源嵌入式操作系统。...我们有一个用于提问，与他人互动，在电路板和组件上查找信息，使用在线IDE和编译器，阅读文档以及了解Mbed OS的新功能和下一步功能。 贡献
mbed-os-example-ble:使用mbed OS和mbed cli的BLE演示
03-18
描述了mbed OS上的BLE API。 BLE的目标 以下目标已经过测试并可以与这些示例一起使用： 北欧的： NRF52_DK NRF52840_DK 插入ST防护板的电路板： K64F NUCLEO_F401RE 带有嵌入式BlueNrg模块的ST板： DISCO_L475...
Mbed OS 文档翻译 之 参考（API（RTOS（Thread）））
XinLiBK的博客
08-24 1305
Thread                                                                                                                                                         Thread 类层次结构 Thread 类允许定义，创建和控制并行任务。 ...
Mbed OS 文档翻译 之 参考（配置（RTOS））
XinLiBK的博客
08-14 972
RTOS 线程内存模型 Mbed OS 中的所有线程共享一个全局堆。默认情况下，mbed OS 为全局堆中的线程栈动态分配内存。用户生成的线程栈可以从其他内存区域分配。全局堆的大小取决于编译器。使用 IAR 进行编译时，堆大小是静态的，并且对于 Mbed OS 中的每个目标，堆大小是不同的。您可以在嵌套在目标目录中的 IAR 链接器配置文件中找到它。例如，您可以找到 K66F 的链接器配置文件...
C++队列模板queue
callmetomato的博客
03-20 351
C++STL模板之队列的基本操作 需包含头文件：#include<queue>; 队列的声明：queue<type> q; 基本操作：q.back();//返回队尾元素 q.empty();//判断队列是否为空 q.front();//返回队首元素 q.pop();//弹出队首元素 q.push(n);//将n添加到队尾 q.size();//返回队列中元素的个数
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值