diff --git a/events/Event.h b/events/Event.h
index a8a2ff62348..2ce282a7489 100644
--- a/events/Event.h
+++ b/events/Event.h
@@ -36,8 +36,8 @@ class Event;
* Representation of an event for fine-grain dispatch control
* @ingroup events
*/
-template <>
-class Event<void()> {
+template <typename... ArgTs>
+class Event<void(ArgTs...)> {
public:
/** Create an event
*
@@ -45,8 +45,8 @@ class Event<void()> {
* callback acts as the target for the event and is executed in the
* context of the event queue's dispatch loop once posted.
*
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
+ * @param q Event queue to dispatch on
+ * @param f Function to execute when the event is dispatched
*/
template <typename F>
Event(EventQueue *q, F f)
@@ -135,44 +135,48 @@ class Event<void()> {
* The post function is IRQ safe and can act as a mechanism for moving
* events out of IRQ contexts.
*
+ * @param args Arguments to pass to the event
* @return A unique id that represents the posted event and can
* be passed to EventQueue::cancel, or an id of 0 if
* there is not enough memory to allocate the event.
*/
- int post() const
+ int post(ArgTs... args) const
{
if (!_event) {
return 0;
}
- _event->id = _event->post(_event);
+ _event->id = _event->post(_event, args...);
return _event->id;
}
/** Posts an event onto the underlying event queue, returning void
*
+ * @param args Arguments to pass to the event
*/
- void call() const
+ void call(ArgTs... args) const
{
- MBED_UNUSED int id = post();
+ MBED_UNUSED int id = post(args...);
MBED_ASSERT(id);
}
/** Posts an event onto the underlying event queue, returning void
*
+ * @param args Arguments to pass to the event
*/
- void operator()() const
+ void operator()(ArgTs... args) const
{
- return call();
+ return call(args...);
}
/** Static thunk for passing as C-style function
*
* @param func Event to call passed as a void pointer
+ * @param args Arguments to pass to the event
*/
- static void thunk(void *func)
+ static void thunk(void *func, ArgTs... args)
{
- return static_cast<Event *>(func)->call();
+ return static_cast<Event *>(func)->call(args...);
}
/** Cancels the most recently posted event
@@ -202,7 +206,7 @@ class Event<void()> {
int delay;
int period;
- int (*post)(struct event *);
+ int (*post)(struct event *, ArgTs... args);
void (*dtor)(struct event *);
// F follows
@@ -210,15 +214,15 @@ class Event<void()> {
// Event attributes
template <typename F>
- static int event_post(struct event *e)
+ static int event_post(struct event *e, ArgTs... args)
{
- typedef EventQueue::context00<F> C;
+ typedef EventQueue::context<F, ArgTs...> C;
void *p = equeue_alloc(e->equeue, sizeof(C));
if (!p) {
return 0;
}
- new (p) C(*(F *)(e + 1));
+ new (p) C(*(F *)(e + 1), args...);
equeue_event_delay(p, e->delay);
equeue_event_period(p, e->period);
equeue_event_dtor(p, &EventQueue::function_dtor<C>);
@@ -235,3837 +239,377 @@ class Event<void()> {
/** Create an event
* @param q Event queue to dispatch on
* @param f Function to execute when the event is dispatched
- * @param c0 Argument to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0>
- Event(EventQueue *q, F f, C0 c0)
- {
- new (this) Event(q, EventQueue::context10<F, C0>(f, c0));
- }
-
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0,c1 Arguments to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0..b1, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0, typename C1>
- Event(EventQueue *q, F f, C0 c0, C1 c1)
- {
- new (this) Event(q, EventQueue::context20<F, C0, C1>(f, c0, c1));
- }
-
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0,c1,c2 Arguments to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0..b2, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0, typename C1, typename C2>
- Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2)
- {
- new (this) Event(q, EventQueue::context30<F, C0, C1, C2>(f, c0, c1, c2));
- }
-
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0,c1,c2,c3 Arguments to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0..b3, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0, typename C1, typename C2, typename C3>
- Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3)
- {
- new (this) Event(q, EventQueue::context40<F, C0, C1, C2, C3>(f, c0, c1, c2, c3));
- }
-
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0,c1,c2,c3,c4 Arguments to bind to the callback, these arguments are
+ * @param context_args Arguments to bind to the callback, these arguments are
* allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0..b4, the
+ * memory pool. Must be type-compatible with bound_args, the
* arguments to the underlying callback.
*/
- template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4>
- Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
- {
- new (this) Event(q, EventQueue::context50<F, C0, C1, C2, C3, C4>(f, c0, c1, c2, c3, c4));
- }
+ template <typename F, typename... ContextArgTs>
+ Event(EventQueue *q, F f, ContextArgTs... context_args) :
+ Event(q, EventQueue::context<F, ContextArgTs...>(f, context_args...)) { }
/** Create an event
* @see Event::Event
*/
template <typename T, typename R, typename B0>
- Event(EventQueue *q, T *obj, R(T::*method)(B0), B0 b0)
- {
- new (this) Event(q, mbed::callback(obj, method), b0);
- }
+ Event(EventQueue *q, T *obj, R(T::*method)(B0, ArgTs...), B0 b0) :
+ Event(q, mbed::callback(obj, method), b0) { }
/** Create an event
* @see Event::Event
*/
template <typename T, typename R, typename B0>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0) const, B0 b0)
- {
- new (this) Event(q, mbed::callback(obj, method), b0);
- }
+ Event(EventQueue *q, const T *obj, R(T::*method)(B0, ArgTs...) const, B0 b0) :
+ Event(q, mbed::callback(obj, method), b0) { }
/** Create an event
* @see Event::Event
*/
template <typename T, typename R, typename B0>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0) volatile, B0 b0)
- {
- new (this) Event(q, mbed::callback(obj, method), b0);
- }
+ Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, ArgTs...) volatile, B0 b0) :
+ Event(q, mbed::callback(obj, method), b0) { }
/** Create an event
* @see Event::Event
*/
template <typename T, typename R, typename B0>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0) const volatile, B0 b0)
- {
- new (this) Event(q, mbed::callback(obj, method), b0);
- }
+ Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, ArgTs...) const volatile, B0 b0) :
+ Event(q, mbed::callback(obj, method), b0) { }
/** Create an event
* @see Event::Event
*/
template <typename T, typename R, typename B0, typename B1>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, B1), B0 b0, B1 b1)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1);
- }
+ Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, ArgTs...), B0 b0, B1 b1) :
+ Event(q, mbed::callback(obj, method), b0, b1) { }
/** Create an event
* @see Event::Event
*/
template <typename T, typename R, typename B0, typename B1>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1) const, B0 b0, B1 b1)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1);
- }
+ Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, ArgTs...) const, B0 b0, B1 b1) :
+ Event(q, mbed::callback(obj, method), b0, b1) { }
/** Create an event
* @see Event::Event
*/
template <typename T, typename R, typename B0, typename B1>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1) volatile, B0 b0, B1 b1)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1);
- }
+ Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, ArgTs...) volatile, B0 b0, B1 b1) :
+ Event(q, mbed::callback(obj, method), b0, b1) { }
/** Create an event
* @see Event::Event
*/
template <typename T, typename R, typename B0, typename B1>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1) const volatile, B0 b0, B1 b1)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1);
- }
+ Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, ArgTs...) const volatile, B0 b0, B1 b1) :
+ Event(q, mbed::callback(obj, method), b0, b1) { }
/** Create an event
* @see Event::Event
*/
template <typename T, typename R, typename B0, typename B1, typename B2>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, B2), B0 b0, B1 b1, B2 b2)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
- }
+ Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, ArgTs...), B0 b0, B1 b1, B2 b2) :
+ Event(q, mbed::callback(obj, method), b0, b1, b2) { }
/** Create an event
* @see Event::Event
*/
template <typename T, typename R, typename B0, typename B1, typename B2>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2) const, B0 b0, B1 b1, B2 b2)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
- }
+ Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, ArgTs...) const, B0 b0, B1 b1, B2 b2) :
+ Event(q, mbed::callback(obj, method), b0, b1, b2) { }
/** Create an event
* @see Event::Event
*/
template <typename T, typename R, typename B0, typename B1, typename B2>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2) volatile, B0 b0, B1 b1, B2 b2)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
- }
+ Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, ArgTs...) volatile, B0 b0, B1 b1, B2 b2) :
+ Event(q, mbed::callback(obj, method), b0, b1, b2) { }
/** Create an event
* @see Event::Event
*/
template <typename T, typename R, typename B0, typename B1, typename B2>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2) const volatile, B0 b0, B1 b1, B2 b2)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
- }
+ Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, ArgTs...) const volatile, B0 b0, B1 b1, B2 b2) :
+ Event(q, mbed::callback(obj, method), b0, b1, b2) { }
/** Create an event
* @see Event::Event
*/
template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3), B0 b0, B1 b1, B2 b2, B3 b3)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
- }
+ Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, ArgTs...), B0 b0, B1 b1, B2 b2, B3 b3) :
+ Event(q, mbed::callback(obj, method), b0, b1, b2, b3) { }
/** Create an event
* @see Event::Event
*/
template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3) const, B0 b0, B1 b1, B2 b2, B3 b3)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
- }
+ Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, ArgTs...) const, B0 b0, B1 b1, B2 b2, B3 b3) :
+ Event(q, mbed::callback(obj, method), b0, b1, b2, b3) { }
/** Create an event
* @see Event::Event
*/
template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3) volatile, B0 b0, B1 b1, B2 b2, B3 b3)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
- }
+ Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, ArgTs...) volatile, B0 b0, B1 b1, B2 b2, B3 b3) :
+ Event(q, mbed::callback(obj, method), b0, b1, b2, b3) { }
/** Create an event
* @see Event::Event
*/
template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3) const volatile, B0 b0, B1 b1, B2 b2, B3 b3)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
- }
+ Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, ArgTs...) const volatile, B0 b0, B1 b1, B2 b2, B3 b3) :
+ Event(q, mbed::callback(obj, method), b0, b1, b2, b3) { }
/** Create an event
* @see Event::Event
*/
template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, B4), B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
- }
+ Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, B4, ArgTs...), B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) :
+ Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4) { }
/** Create an event
* @see Event::Event
*/
template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, B4) const, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
- }
+ Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, B4, ArgTs...) const, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) :
+ Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4) { }
/** Create an event
* @see Event::Event
*/
template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4) volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
- }
+ Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, ArgTs...) volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) :
+ Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4) { }
/** Create an event
* @see Event::Event
*/
template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4) const volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
- }
+ Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, ArgTs...) const volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) :
+ Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4) { }
};
-/** Event
- *
- * Representation of an event for fine-grain dispatch control
- * @ingroup events
- */
-template <typename A0>
-class Event<void(A0)> {
-public:
- /** Create an event
- *
- * Constructs an event bound to the specified event queue. The specified
- * callback acts as the target for the event and is executed in the
- * context of the event queue's dispatch loop once posted.
- *
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- */
- template <typename F>
- Event(EventQueue *q, F f)
- {
- _event = static_cast<struct event *>(
- equeue_alloc(&q->_equeue, sizeof(struct event) + sizeof(F)));
- if (_event) {
- _event->equeue = &q->_equeue;
- _event->id = 0;
- _event->delay = 0;
- _event->period = -1;
+/** \addtogroup events */
+/** @{ */
- _event->post = &Event::event_post<F>;
- _event->dtor = &Event::event_dtor<F>;
+// Convenience functions declared here to avoid cyclic
+// dependency between Event and EventQueue
+template <typename R, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(R(*func)(ArgTs...))
+{
+ return Event<void(ArgTs...)>(this, func);
+}
- new (_event + 1) F(f);
+template <typename T, typename R, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(T *obj, R(T::*method)(ArgTs...))
+{
+ return Event<void(ArgTs...)>(this, mbed::callback(obj, method));
+}
- _event->ref = 1;
- }
- }
+template <typename T, typename R, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(const T *obj, R(T::*method)(ArgTs...) const)
+{
+ return Event<void(ArgTs...)>(this, mbed::callback(obj, method));
+}
- /** Copy constructor for events
- */
- Event(const Event &e)
- {
- _event = 0;
- if (e._event) {
- _event = e._event;
- _event->ref += 1;
- }
- }
+template <typename T, typename R, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(volatile T *obj, R(T::*method)(ArgTs...) volatile)
+{
+ return Event<void(ArgTs...)>(this, mbed::callback(obj, method));
+}
- /** Assignment operator for events
- */
- Event &operator=(const Event &that)
- {
- if (this != &that) {
- this->~Event();
- new (this) Event(that);
- }
+template <typename T, typename R, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(const volatile T *obj, R(T::*method)(ArgTs...) const volatile)
+{
+ return Event<void(ArgTs...)>(this, mbed::callback(obj, method));
+}
- return *this;
- }
+template <typename R, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(mbed::Callback<R(ArgTs...)> cb)
+{
+ return Event<void(ArgTs...)>(this, cb);
+}
- /** Destructor for events
- */
- ~Event()
- {
- if (_event) {
- _event->ref -= 1;
- if (_event->ref == 0) {
- _event->dtor(_event);
- equeue_dealloc(_event->equeue, _event);
- }
- }
- }
+template <typename R, typename B0, typename C0, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(R(*func)(B0, ArgTs...), C0 c0)
+{
+ return Event<void(ArgTs...)>(this, func, c0);
+}
- /** Configure the delay of an event
- *
- * @param delay Millisecond delay before dispatching the event
- */
- void delay(int delay)
- {
- if (_event) {
- _event->delay = delay;
- }
- }
+template <typename T, typename R, typename B0, typename C0, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(T *obj, R(T::*method)(B0, ArgTs...), C0 c0)
+{
+ return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0);
+}
- /** Configure the period of an event
- *
- * @param period Millisecond period for repeatedly dispatching an event
- */
- void period(int period)
- {
- if (_event) {
- _event->period = period;
- }
- }
+template <typename T, typename R, typename B0, typename C0, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(const T *obj, R(T::*method)(B0, ArgTs...) const, C0 c0)
+{
+ return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0);
+}
- /** Posts an event onto the underlying event queue
- *
- * The event is posted to the underlying queue and is executed in the
- * context of the event queue's dispatch loop.
- *
- * The post function is IRQ safe and can act as a mechanism for moving
- * events out of IRQ contexts.
- *
- * @param a0 Argument to pass to the event
- * @return A unique id that represents the posted event and can
- * be passed to EventQueue::cancel, or an id of 0 if
- * there is not enough memory to allocate the event.
- */
- int post(A0 a0) const
- {
- if (!_event) {
- return 0;
- }
+template <typename T, typename R, typename B0, typename C0, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(volatile T *obj, R(T::*method)(B0, ArgTs...) volatile, C0 c0)
+{
+ return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0);
+}
- _event->id = _event->post(_event, a0);
- return _event->id;
- }
+template <typename T, typename R, typename B0, typename C0, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(const volatile T *obj, R(T::*method)(B0, ArgTs...) const volatile, C0 c0)
+{
+ return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0);
+}
- /** Posts an event onto the underlying event queue, returning void
- *
- * @param a0 Argument to pass to the event
- */
- void call(A0 a0) const
- {
- MBED_UNUSED int id = post(a0);
- MBED_ASSERT(id);
- }
+template <typename R, typename B0, typename C0, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(mbed::Callback<R(B0, ArgTs...)> cb, C0 c0)
+{
+ return Event<void(ArgTs...)>(this, cb, c0);
+}
- /** Posts an event onto the underlying event queue, returning void
- *
- * @param a0 Argument to pass to the event
- */
- void operator()(A0 a0) const
- {
- return call(a0);
- }
+template <typename R, typename B0, typename B1, typename C0, typename C1, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(R(*func)(B0, B1, ArgTs...), C0 c0, C1 c1)
+{
+ return Event<void(ArgTs...)>(this, func, c0, c1);
+}
- /** Static thunk for passing as C-style function
- *
- * @param func Event to call passed as a void pointer
- * @param a0 Argument to pass to the event
- */
- static void thunk(void *func, A0 a0)
- {
- return static_cast<Event *>(func)->call(a0);
- }
+template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(T *obj, R(T::*method)(B0, B1, ArgTs...), C0 c0, C1 c1)
+{
+ return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1);
+}
- /** Cancels the most recently posted event
- *
- * Attempts to cancel the most recently posted event. It is safe to call
- * cancel after an event has already been dispatched.
- *
- * The cancel function is IRQ safe.
- *
- * If called while the event queue's dispatch loop is active, the cancel
- * function does not guarantee that the event will not execute after it
- * returns, as the event may have already begun executing.
- */
- void cancel() const
- {
- if (_event) {
- equeue_cancel(_event->equeue, _event->id);
- }
- }
+template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(const T *obj, R(T::*method)(B0, B1, ArgTs...) const, C0 c0, C1 c1)
+{
+ return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1);
+}
-private:
- struct event {
- unsigned ref;
- equeue_t *equeue;
- int id;
-
- int delay;
- int period;
-
- int (*post)(struct event *, A0 a0);
- void (*dtor)(struct event *);
-
- // F follows
- } *_event;
-
- // Event attributes
- template <typename F>
- static int event_post(struct event *e, A0 a0)
- {
- typedef EventQueue::context10<F, A0> C;
- void *p = equeue_alloc(e->equeue, sizeof(C));
- if (!p) {
- return 0;
- }
-
- new (p) C(*(F *)(e + 1), a0);
- equeue_event_delay(p, e->delay);
- equeue_event_period(p, e->period);
- equeue_event_dtor(p, &EventQueue::function_dtor<C>);
- return equeue_post(e->equeue, &EventQueue::function_call<C>, p);
- }
-
- template <typename F>
- static void event_dtor(struct event *e)
- {
- ((F *)(e + 1))->~F();
- }
-
-public:
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0 Argument to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0>
- Event(EventQueue *q, F f, C0 c0)
- {
- new (this) Event(q, EventQueue::context11<F, C0, A0>(f, c0));
- }
-
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0,c1 Arguments to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0..b1, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0, typename C1>
- Event(EventQueue *q, F f, C0 c0, C1 c1)
- {
- new (this) Event(q, EventQueue::context21<F, C0, C1, A0>(f, c0, c1));
- }
-
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0,c1,c2 Arguments to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0..b2, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0, typename C1, typename C2>
- Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2)
- {
- new (this) Event(q, EventQueue::context31<F, C0, C1, C2, A0>(f, c0, c1, c2));
- }
-
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0,c1,c2,c3 Arguments to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0..b3, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0, typename C1, typename C2, typename C3>
- Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3)
- {
- new (this) Event(q, EventQueue::context41<F, C0, C1, C2, C3, A0>(f, c0, c1, c2, c3));
- }
-
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0,c1,c2,c3,c4 Arguments to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0..b4, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4>
- Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
- {
- new (this) Event(q, EventQueue::context51<F, C0, C1, C2, C3, C4, A0>(f, c0, c1, c2, c3, c4));
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, A0), B0 b0)
- {
- new (this) Event(q, mbed::callback(obj, method), b0);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, A0) const, B0 b0)
- {
- new (this) Event(q, mbed::callback(obj, method), b0);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, A0) volatile, B0 b0)
- {
- new (this) Event(q, mbed::callback(obj, method), b0);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, A0) const volatile, B0 b0)
- {
- new (this) Event(q, mbed::callback(obj, method), b0);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, A0), B0 b0, B1 b1)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, A0) const, B0 b0, B1 b1)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, A0) volatile, B0 b0, B1 b1)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, A0) const volatile, B0 b0, B1 b1)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, A0), B0 b0, B1 b1, B2 b2)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, A0) const, B0 b0, B1 b1, B2 b2)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, A0) volatile, B0 b0, B1 b1, B2 b2)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, A0) const volatile, B0 b0, B1 b1, B2 b2)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, A0), B0 b0, B1 b1, B2 b2, B3 b3)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, A0) const, B0 b0, B1 b1, B2 b2, B3 b3)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0) volatile, B0 b0, B1 b1, B2 b2, B3 b3)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0) const volatile, B0 b0, B1 b1, B2 b2, B3 b3)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0), B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0) const, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0) volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0) const volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
- }
-};
-
-/** Event
- *
- * Representation of an event for fine-grain dispatch control
- * @ingroup events
- */
-template <typename A0, typename A1>
-class Event<void(A0, A1)> {
-public:
- /** Create an event
- *
- * Constructs an event bound to the specified event queue. The specified
- * callback acts as the target for the event and is executed in the
- * context of the event queue's dispatch loop once posted.
- *
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- */
- template <typename F>
- Event(EventQueue *q, F f)
- {
- _event = static_cast<struct event *>(
- equeue_alloc(&q->_equeue, sizeof(struct event) + sizeof(F)));
-
- if (_event) {
- _event->equeue = &q->_equeue;
- _event->id = 0;
- _event->delay = 0;
- _event->period = -1;
-
- _event->post = &Event::event_post<F>;
- _event->dtor = &Event::event_dtor<F>;
-
- new (_event + 1) F(f);
-
- _event->ref = 1;
- }
- }
-
- /** Copy constructor for events
- */
- Event(const Event &e)
- {
- _event = 0;
- if (e._event) {
- _event = e._event;
- _event->ref += 1;
- }
- }
-
- /** Assignment operator for events
- */
- Event &operator=(const Event &that)
- {
- if (this != &that) {
- this->~Event();
- new (this) Event(that);
- }
-
- return *this;
- }
-
- /** Destructor for events
- */
- ~Event()
- {
- if (_event) {
- _event->ref -= 1;
- if (_event->ref == 0) {
- _event->dtor(_event);
- equeue_dealloc(_event->equeue, _event);
- }
- }
- }
-
- /** Configure the delay of an event
- *
- * @param delay Millisecond delay before dispatching the event
- */
- void delay(int delay)
- {
- if (_event) {
- _event->delay = delay;
- }
- }
-
- /** Configure the period of an event
- *
- * @param period Millisecond period for repeatedly dispatching an event
- */
- void period(int period)
- {
- if (_event) {
- _event->period = period;
- }
- }
-
- /** Posts an event onto the underlying event queue
- *
- * The event is posted to the underlying queue and is executed in the
- * context of the event queue's dispatch loop.
- *
- * The post function is IRQ safe and can act as a mechanism for moving
- * events out of IRQ contexts.
- *
- * @param a0,a1 Arguments to pass to the event
- * @return A unique id that represents the posted event and can
- * be passed to EventQueue::cancel, or an id of 0 if
- * there is not enough memory to allocate the event.
- */
- int post(A0 a0, A1 a1) const
- {
- if (!_event) {
- return 0;
- }
-
- _event->id = _event->post(_event, a0, a1);
- return _event->id;
- }
-
- /** Posts an event onto the underlying event queue, returning void
- *
- * @param a0,a1 Arguments to pass to the event
- */
- void call(A0 a0, A1 a1) const
- {
- MBED_UNUSED int id = post(a0, a1);
- MBED_ASSERT(id);
- }
-
- /** Posts an event onto the underlying event queue, returning void
- *
- * @param a0,a1 Arguments to pass to the event
- */
- void operator()(A0 a0, A1 a1) const
- {
- return call(a0, a1);
- }
-
- /** Static thunk for passing as C-style function
- *
- * @param func Event to call passed as a void pointer
- * @param a0,a1 Arguments to pass to the event
- */
- static void thunk(void *func, A0 a0, A1 a1)
- {
- return static_cast<Event *>(func)->call(a0, a1);
- }
-
- /** Cancels the most recently posted event
- *
- * Attempts to cancel the most recently posted event. It is safe to call
- * cancel after an event has already been dispatched.
- *
- * The cancel function is IRQ safe.
- *
- * If called while the event queue's dispatch loop is active, the cancel
- * function does not guarantee that the event will not execute after it
- * returns, as the event may have already begun executing.
- */
- void cancel() const
- {
- if (_event) {
- equeue_cancel(_event->equeue, _event->id);
- }
- }
-
-private:
- struct event {
- unsigned ref;
- equeue_t *equeue;
- int id;
-
- int delay;
- int period;
-
- int (*post)(struct event *, A0 a0, A1 a1);
- void (*dtor)(struct event *);
-
- // F follows
- } *_event;
-
- // Event attributes
- template <typename F>
- static int event_post(struct event *e, A0 a0, A1 a1)
- {
- typedef EventQueue::context20<F, A0, A1> C;
- void *p = equeue_alloc(e->equeue, sizeof(C));
- if (!p) {
- return 0;
- }
-
- new (p) C(*(F *)(e + 1), a0, a1);
- equeue_event_delay(p, e->delay);
- equeue_event_period(p, e->period);
- equeue_event_dtor(p, &EventQueue::function_dtor<C>);
- return equeue_post(e->equeue, &EventQueue::function_call<C>, p);
- }
-
- template <typename F>
- static void event_dtor(struct event *e)
- {
- ((F *)(e + 1))->~F();
- }
-
-public:
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0 Argument to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0>
- Event(EventQueue *q, F f, C0 c0)
- {
- new (this) Event(q, EventQueue::context12<F, C0, A0, A1>(f, c0));
- }
-
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0,c1 Arguments to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0..b1, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0, typename C1>
- Event(EventQueue *q, F f, C0 c0, C1 c1)
- {
- new (this) Event(q, EventQueue::context22<F, C0, C1, A0, A1>(f, c0, c1));
- }
-
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0,c1,c2 Arguments to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0..b2, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0, typename C1, typename C2>
- Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2)
- {
- new (this) Event(q, EventQueue::context32<F, C0, C1, C2, A0, A1>(f, c0, c1, c2));
- }
-
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0,c1,c2,c3 Arguments to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0..b3, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0, typename C1, typename C2, typename C3>
- Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3)
- {
- new (this) Event(q, EventQueue::context42<F, C0, C1, C2, C3, A0, A1>(f, c0, c1, c2, c3));
- }
-
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0,c1,c2,c3,c4 Arguments to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0..b4, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4>
- Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
- {
- new (this) Event(q, EventQueue::context52<F, C0, C1, C2, C3, C4, A0, A1>(f, c0, c1, c2, c3, c4));
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, A0, A1), B0 b0)
- {
- new (this) Event(q, mbed::callback(obj, method), b0);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, A0, A1) const, B0 b0)
- {
- new (this) Event(q, mbed::callback(obj, method), b0);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, A0, A1) volatile, B0 b0)
- {
- new (this) Event(q, mbed::callback(obj, method), b0);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, A0, A1) const volatile, B0 b0)
- {
- new (this) Event(q, mbed::callback(obj, method), b0);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, A0, A1), B0 b0, B1 b1)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, A0, A1) const, B0 b0, B1 b1)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, A0, A1) volatile, B0 b0, B1 b1)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, A0, A1) const volatile, B0 b0, B1 b1)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, A0, A1), B0 b0, B1 b1, B2 b2)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, A0, A1) const, B0 b0, B1 b1, B2 b2)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1) volatile, B0 b0, B1 b1, B2 b2)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1) const volatile, B0 b0, B1 b1, B2 b2)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1), B0 b0, B1 b1, B2 b2, B3 b3)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1) const, B0 b0, B1 b1, B2 b2, B3 b3)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1) volatile, B0 b0, B1 b1, B2 b2, B3 b3)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1) const volatile, B0 b0, B1 b1, B2 b2, B3 b3)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1), B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1) const, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1) volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1) const volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
- }
-};
-
-/** Event
- *
- * Representation of an event for fine-grain dispatch control
- * @ingroup events
- */
-template <typename A0, typename A1, typename A2>
-class Event<void(A0, A1, A2)> {
-public:
- /** Create an event
- *
- * Constructs an event bound to the specified event queue. The specified
- * callback acts as the target for the event and is executed in the
- * context of the event queue's dispatch loop once posted.
- *
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- */
- template <typename F>
- Event(EventQueue *q, F f)
- {
- _event = static_cast<struct event *>(
- equeue_alloc(&q->_equeue, sizeof(struct event) + sizeof(F)));
-
- if (_event) {
- _event->equeue = &q->_equeue;
- _event->id = 0;
- _event->delay = 0;
- _event->period = -1;
-
- _event->post = &Event::event_post<F>;
- _event->dtor = &Event::event_dtor<F>;
-
- new (_event + 1) F(f);
-
- _event->ref = 1;
- }
- }
-
- /** Copy constructor for events
- */
- Event(const Event &e)
- {
- _event = 0;
- if (e._event) {
- _event = e._event;
- _event->ref += 1;
- }
- }
-
- /** Assignment operator for events
- */
- Event &operator=(const Event &that)
- {
- if (this != &that) {
- this->~Event();
- new (this) Event(that);
- }
-
- return *this;
- }
-
- /** Destructor for events
- */
- ~Event()
- {
- if (_event) {
- _event->ref -= 1;
- if (_event->ref == 0) {
- _event->dtor(_event);
- equeue_dealloc(_event->equeue, _event);
- }
- }
- }
-
- /** Configure the delay of an event
- *
- * @param delay Millisecond delay before dispatching the event
- */
- void delay(int delay)
- {
- if (_event) {
- _event->delay = delay;
- }
- }
-
- /** Configure the period of an event
- *
- * @param period Millisecond period for repeatedly dispatching an event
- */
- void period(int period)
- {
- if (_event) {
- _event->period = period;
- }
- }
-
- /** Posts an event onto the underlying event queue
- *
- * The event is posted to the underlying queue and is executed in the
- * context of the event queue's dispatch loop.
- *
- * The post function is IRQ safe and can act as a mechanism for moving
- * events out of IRQ contexts.
- *
- * @param a0,a1,a2 Arguments to pass to the event
- * @return A unique id that represents the posted event and can
- * be passed to EventQueue::cancel, or an id of 0 if
- * there is not enough memory to allocate the event.
- */
- int post(A0 a0, A1 a1, A2 a2) const
- {
- if (!_event) {
- return 0;
- }
-
- _event->id = _event->post(_event, a0, a1, a2);
- return _event->id;
- }
-
- /** Posts an event onto the underlying event queue, returning void
- *
- * @param a0,a1,a2 Arguments to pass to the event
- */
- void call(A0 a0, A1 a1, A2 a2) const
- {
- MBED_UNUSED int id = post(a0, a1, a2);
- MBED_ASSERT(id);
- }
-
- /** Posts an event onto the underlying event queue, returning void
- *
- * @param a0,a1,a2 Arguments to pass to the event
- */
- void operator()(A0 a0, A1 a1, A2 a2) const
- {
- return call(a0, a1, a2);
- }
-
- /** Static thunk for passing as C-style function
- *
- * @param func Event to call passed as a void pointer
- * @param a0,a1,a2 Arguments to pass to the event
- */
- static void thunk(void *func, A0 a0, A1 a1, A2 a2)
- {
- return static_cast<Event *>(func)->call(a0, a1, a2);
- }
-
- /** Cancels the most recently posted event
- *
- * Attempts to cancel the most recently posted event. It is safe to call
- * cancel after an event has already been dispatched.
- *
- * The cancel function is IRQ safe.
- *
- * If called while the event queue's dispatch loop is active, the cancel
- * function does not guarantee that the event will not execute after it
- * returns, as the event may have already begun executing.
- */
- void cancel() const
- {
- if (_event) {
- equeue_cancel(_event->equeue, _event->id);
- }
- }
-
-private:
- struct event {
- unsigned ref;
- equeue_t *equeue;
- int id;
-
- int delay;
- int period;
-
- int (*post)(struct event *, A0 a0, A1 a1, A2 a2);
- void (*dtor)(struct event *);
-
- // F follows
- } *_event;
-
- // Event attributes
- template <typename F>
- static int event_post(struct event *e, A0 a0, A1 a1, A2 a2)
- {
- typedef EventQueue::context30<F, A0, A1, A2> C;
- void *p = equeue_alloc(e->equeue, sizeof(C));
- if (!p) {
- return 0;
- }
-
- new (p) C(*(F *)(e + 1), a0, a1, a2);
- equeue_event_delay(p, e->delay);
- equeue_event_period(p, e->period);
- equeue_event_dtor(p, &EventQueue::function_dtor<C>);
- return equeue_post(e->equeue, &EventQueue::function_call<C>, p);
- }
-
- template <typename F>
- static void event_dtor(struct event *e)
- {
- ((F *)(e + 1))->~F();
- }
-
-public:
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0 Argument to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0>
- Event(EventQueue *q, F f, C0 c0)
- {
- new (this) Event(q, EventQueue::context13<F, C0, A0, A1, A2>(f, c0));
- }
-
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0,c1 Arguments to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0..b1, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0, typename C1>
- Event(EventQueue *q, F f, C0 c0, C1 c1)
- {
- new (this) Event(q, EventQueue::context23<F, C0, C1, A0, A1, A2>(f, c0, c1));
- }
-
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0,c1,c2 Arguments to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0..b2, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0, typename C1, typename C2>
- Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2)
- {
- new (this) Event(q, EventQueue::context33<F, C0, C1, C2, A0, A1, A2>(f, c0, c1, c2));
- }
-
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0,c1,c2,c3 Arguments to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0..b3, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0, typename C1, typename C2, typename C3>
- Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3)
- {
- new (this) Event(q, EventQueue::context43<F, C0, C1, C2, C3, A0, A1, A2>(f, c0, c1, c2, c3));
- }
-
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0,c1,c2,c3,c4 Arguments to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0..b4, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4>
- Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
- {
- new (this) Event(q, EventQueue::context53<F, C0, C1, C2, C3, C4, A0, A1, A2>(f, c0, c1, c2, c3, c4));
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, A0, A1, A2), B0 b0)
- {
- new (this) Event(q, mbed::callback(obj, method), b0);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, A0, A1, A2) const, B0 b0)
- {
- new (this) Event(q, mbed::callback(obj, method), b0);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, A0, A1, A2) volatile, B0 b0)
- {
- new (this) Event(q, mbed::callback(obj, method), b0);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, A0, A1, A2) const volatile, B0 b0)
- {
- new (this) Event(q, mbed::callback(obj, method), b0);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, A0, A1, A2), B0 b0, B1 b1)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, A0, A1, A2) const, B0 b0, B1 b1)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, A0, A1, A2) volatile, B0 b0, B1 b1)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, A0, A1, A2) const volatile, B0 b0, B1 b1)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2), B0 b0, B1 b1, B2 b2)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2) const, B0 b0, B1 b1, B2 b2)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2) volatile, B0 b0, B1 b1, B2 b2)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2) const volatile, B0 b0, B1 b1, B2 b2)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2), B0 b0, B1 b1, B2 b2, B3 b3)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2) const, B0 b0, B1 b1, B2 b2, B3 b3)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2) volatile, B0 b0, B1 b1, B2 b2, B3 b3)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2) const volatile, B0 b0, B1 b1, B2 b2, B3 b3)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2), B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2) const, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2) volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2) const volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
- }
-};
-
-/** Event
- *
- * Representation of an event for fine-grain dispatch control
- * @ingroup events
- */
-template <typename A0, typename A1, typename A2, typename A3>
-class Event<void(A0, A1, A2, A3)> {
-public:
- /** Create an event
- *
- * Constructs an event bound to the specified event queue. The specified
- * callback acts as the target for the event and is executed in the
- * context of the event queue's dispatch loop once posted.
- *
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- */
- template <typename F>
- Event(EventQueue *q, F f)
- {
- _event = static_cast<struct event *>(
- equeue_alloc(&q->_equeue, sizeof(struct event) + sizeof(F)));
-
- if (_event) {
- _event->equeue = &q->_equeue;
- _event->id = 0;
- _event->delay = 0;
- _event->period = -1;
-
- _event->post = &Event::event_post<F>;
- _event->dtor = &Event::event_dtor<F>;
-
- new (_event + 1) F(f);
-
- _event->ref = 1;
- }
- }
-
- /** Copy constructor for events
- */
- Event(const Event &e)
- {
- _event = 0;
- if (e._event) {
- _event = e._event;
- _event->ref += 1;
- }
- }
-
- /** Assignment operator for events
- */
- Event &operator=(const Event &that)
- {
- if (this != &that) {
- this->~Event();
- new (this) Event(that);
- }
-
- return *this;
- }
-
- /** Destructor for events
- */
- ~Event()
- {
- if (_event) {
- _event->ref -= 1;
- if (_event->ref == 0) {
- _event->dtor(_event);
- equeue_dealloc(_event->equeue, _event);
- }
- }
- }
-
- /** Configure the delay of an event
- *
- * @param delay Millisecond delay before dispatching the event
- */
- void delay(int delay)
- {
- if (_event) {
- _event->delay = delay;
- }
- }
-
- /** Configure the period of an event
- *
- * @param period Millisecond period for repeatedly dispatching an event
- */
- void period(int period)
- {
- if (_event) {
- _event->period = period;
- }
- }
-
- /** Posts an event onto the underlying event queue
- *
- * The event is posted to the underlying queue and is executed in the
- * context of the event queue's dispatch loop.
- *
- * The post function is IRQ safe and can act as a mechanism for moving
- * events out of IRQ contexts.
- *
- * @param a0,a1,a2,a3 Arguments to pass to the event
- * @return A unique id that represents the posted event and can
- * be passed to EventQueue::cancel, or an id of 0 if
- * there is not enough memory to allocate the event.
- */
- int post(A0 a0, A1 a1, A2 a2, A3 a3) const
- {
- if (!_event) {
- return 0;
- }
-
- _event->id = _event->post(_event, a0, a1, a2, a3);
- return _event->id;
- }
-
- /** Posts an event onto the underlying event queue, returning void
- *
- * @param a0,a1,a2,a3 Arguments to pass to the event
- */
- void call(A0 a0, A1 a1, A2 a2, A3 a3) const
- {
- MBED_UNUSED int id = post(a0, a1, a2, a3);
- MBED_ASSERT(id);
- }
-
- /** Posts an event onto the underlying event queue, returning void
- *
- * @param a0,a1,a2,a3 Arguments to pass to the event
- */
- void operator()(A0 a0, A1 a1, A2 a2, A3 a3) const
- {
- return call(a0, a1, a2, a3);
- }
-
- /** Static thunk for passing as C-style function
- *
- * @param func Event to call passed as a void pointer
- * @param a0,a1,a2,a3 Arguments to pass to the event
- */
- static void thunk(void *func, A0 a0, A1 a1, A2 a2, A3 a3)
- {
- return static_cast<Event *>(func)->call(a0, a1, a2, a3);
- }
-
- /** Cancels the most recently posted event
- *
- * Attempts to cancel the most recently posted event. It is safe to call
- * cancel after an event has already been dispatched.
- *
- * The cancel function is IRQ safe.
- *
- * If called while the event queue's dispatch loop is active, the cancel
- * function does not guarantee that the event will not execute after it
- * returns, as the event may have already begun executing.
- */
- void cancel() const
- {
- if (_event) {
- equeue_cancel(_event->equeue, _event->id);
- }
- }
-
-private:
- struct event {
- unsigned ref;
- equeue_t *equeue;
- int id;
-
- int delay;
- int period;
-
- int (*post)(struct event *, A0 a0, A1 a1, A2 a2, A3 a3);
- void (*dtor)(struct event *);
-
- // F follows
- } *_event;
-
- // Event attributes
- template <typename F>
- static int event_post(struct event *e, A0 a0, A1 a1, A2 a2, A3 a3)
- {
- typedef EventQueue::context40<F, A0, A1, A2, A3> C;
- void *p = equeue_alloc(e->equeue, sizeof(C));
- if (!p) {
- return 0;
- }
-
- new (p) C(*(F *)(e + 1), a0, a1, a2, a3);
- equeue_event_delay(p, e->delay);
- equeue_event_period(p, e->period);
- equeue_event_dtor(p, &EventQueue::function_dtor<C>);
- return equeue_post(e->equeue, &EventQueue::function_call<C>, p);
- }
-
- template <typename F>
- static void event_dtor(struct event *e)
- {
- ((F *)(e + 1))->~F();
- }
-
-public:
-#if !defined(DOXYGEN_ONLY)
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0 Argument to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0>
- Event(EventQueue *q, F f, C0 c0)
- {
- new (this) Event(q, EventQueue::context14<F, C0, A0, A1, A2, A3>(f, c0));
- }
-
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0,c1 Arguments to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0..b1, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0, typename C1>
- Event(EventQueue *q, F f, C0 c0, C1 c1)
- {
- new (this) Event(q, EventQueue::context24<F, C0, C1, A0, A1, A2, A3>(f, c0, c1));
- }
-
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0,c1,c2 Arguments to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0..b2, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0, typename C1, typename C2>
- Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2)
- {
- new (this) Event(q, EventQueue::context34<F, C0, C1, C2, A0, A1, A2, A3>(f, c0, c1, c2));
- }
-
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0,c1,c2,c3 Arguments to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0..b3, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0, typename C1, typename C2, typename C3>
- Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3)
- {
- new (this) Event(q, EventQueue::context44<F, C0, C1, C2, C3, A0, A1, A2, A3>(f, c0, c1, c2, c3));
- }
-
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0,c1,c2,c3,c4 Arguments to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0..b4, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4>
- Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
- {
- new (this) Event(q, EventQueue::context54<F, C0, C1, C2, C3, C4, A0, A1, A2, A3>(f, c0, c1, c2, c3, c4));
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, A0, A1, A2, A3), B0 b0)
- {
- new (this) Event(q, mbed::callback(obj, method), b0);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, A0, A1, A2, A3) const, B0 b0)
- {
- new (this) Event(q, mbed::callback(obj, method), b0);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, A0, A1, A2, A3) volatile, B0 b0)
- {
- new (this) Event(q, mbed::callback(obj, method), b0);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, A0, A1, A2, A3) const volatile, B0 b0)
- {
- new (this) Event(q, mbed::callback(obj, method), b0);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3), B0 b0, B1 b1)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3) const, B0 b0, B1 b1)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3) volatile, B0 b0, B1 b1)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3) const volatile, B0 b0, B1 b1)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3), B0 b0, B1 b1, B2 b2)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3) const, B0 b0, B1 b1, B2 b2)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3) volatile, B0 b0, B1 b1, B2 b2)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3) const volatile, B0 b0, B1 b1, B2 b2)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3), B0 b0, B1 b1, B2 b2, B3 b3)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3) const, B0 b0, B1 b1, B2 b2, B3 b3)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3) volatile, B0 b0, B1 b1, B2 b2, B3 b3)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3) const volatile, B0 b0, B1 b1, B2 b2, B3 b3)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3), B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3) const, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3) volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3) const volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
- }
-};
-
-/** Event
- *
- * Representation of an event for fine-grain dispatch control
- * @ingroup events
- */
-template <typename A0, typename A1, typename A2, typename A3, typename A4>
-class Event<void(A0, A1, A2, A3, A4)> {
-public:
- /** Create an event
- *
- * Constructs an event bound to the specified event queue. The specified
- * callback acts as the target for the event and is executed in the
- * context of the event queue's dispatch loop once posted.
- *
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- */
- template <typename F>
- Event(EventQueue *q, F f)
- {
- _event = static_cast<struct event *>(
- equeue_alloc(&q->_equeue, sizeof(struct event) + sizeof(F)));
-
- if (_event) {
- _event->equeue = &q->_equeue;
- _event->id = 0;
- _event->delay = 0;
- _event->period = -1;
-
- _event->post = &Event::event_post<F>;
- _event->dtor = &Event::event_dtor<F>;
-
- new (_event + 1) F(f);
-
- _event->ref = 1;
- }
- }
-
- /** Copy constructor for events
- */
- Event(const Event &e)
- {
- _event = 0;
- if (e._event) {
- _event = e._event;
- _event->ref += 1;
- }
- }
-
- /** Assignment operator for events
- */
- Event &operator=(const Event &that)
- {
- if (this != &that) {
- this->~Event();
- new (this) Event(that);
- }
-
- return *this;
- }
-
- /** Destructor for events
- */
- ~Event()
- {
- if (_event) {
- _event->ref -= 1;
- if (_event->ref == 0) {
- _event->dtor(_event);
- equeue_dealloc(_event->equeue, _event);
- }
- }
- }
-
- /** Configure the delay of an event
- *
- * @param delay Millisecond delay before dispatching the event
- */
- void delay(int delay)
- {
- if (_event) {
- _event->delay = delay;
- }
- }
-
- /** Configure the period of an event
- *
- * @param period Millisecond period for repeatedly dispatching an event
- */
- void period(int period)
- {
- if (_event) {
- _event->period = period;
- }
- }
-
- /** Posts an event onto the underlying event queue
- *
- * The event is posted to the underlying queue and is executed in the
- * context of the event queue's dispatch loop.
- *
- * The post function is IRQ safe and can act as a mechanism for moving
- * events out of IRQ contexts.
- *
- * @param a0,a1,a2,a3,a4 Arguments to pass to the event
- * @return A unique id that represents the posted event and can
- * be passed to EventQueue::cancel, or an id of 0 if
- * there is not enough memory to allocate the event.
- */
- int post(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const
- {
- if (!_event) {
- return 0;
- }
-
- _event->id = _event->post(_event, a0, a1, a2, a3, a4);
- return _event->id;
- }
-
- /** Posts an event onto the underlying event queue, returning void
- *
- * @param a0,a1,a2,a3,a4 Arguments to pass to the event
- */
- void call(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const
- {
- MBED_UNUSED int id = post(a0, a1, a2, a3, a4);
- MBED_ASSERT(id);
- }
-
- /** Posts an event onto the underlying event queue, returning void
- *
- * @param a0,a1,a2,a3,a4 Arguments to pass to the event
- */
- void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const
- {
- return call(a0, a1, a2, a3, a4);
- }
-
- /** Static thunk for passing as C-style function
- *
- * @param func Event to call passed as a void pointer
- * @param a0,a1,a2,a3,a4 Arguments to pass to the event
- */
- static void thunk(void *func, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4)
- {
- return static_cast<Event *>(func)->call(a0, a1, a2, a3, a4);
- }
-
- /** Cancels the most recently posted event
- *
- * Attempts to cancel the most recently posted event. It is safe to call
- * cancel after an event has already been dispatched.
- *
- * The cancel function is IRQ safe.
- *
- * If called while the event queue's dispatch loop is active, the cancel
- * function does not guarantee that the event will not execute after it
- * returns, as the event may have already begun executing.
- */
- void cancel() const
- {
- if (_event) {
- equeue_cancel(_event->equeue, _event->id);
- }
- }
-
-private:
- struct event {
- unsigned ref;
- equeue_t *equeue;
- int id;
-
- int delay;
- int period;
-
- int (*post)(struct event *, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4);
- void (*dtor)(struct event *);
-
- // F follows
- } *_event;
-
- // Event attributes
- template <typename F>
- static int event_post(struct event *e, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4)
- {
- typedef EventQueue::context50<F, A0, A1, A2, A3, A4> C;
- void *p = equeue_alloc(e->equeue, sizeof(C));
- if (!p) {
- return 0;
- }
-
- new (p) C(*(F *)(e + 1), a0, a1, a2, a3, a4);
- equeue_event_delay(p, e->delay);
- equeue_event_period(p, e->period);
- equeue_event_dtor(p, &EventQueue::function_dtor<C>);
- return equeue_post(e->equeue, &EventQueue::function_call<C>, p);
- }
-
- template <typename F>
- static void event_dtor(struct event *e)
- {
- ((F *)(e + 1))->~F();
- }
-
-public:
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0 Argument to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0>
- Event(EventQueue *q, F f, C0 c0)
- {
- new (this) Event(q, EventQueue::context15<F, C0, A0, A1, A2, A3, A4>(f, c0));
- }
-
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0,c1 Arguments to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0..b1, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0, typename C1>
- Event(EventQueue *q, F f, C0 c0, C1 c1)
- {
- new (this) Event(q, EventQueue::context25<F, C0, C1, A0, A1, A2, A3, A4>(f, c0, c1));
- }
-
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0,c1,c2 Arguments to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0..b2, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0, typename C1, typename C2>
- Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2)
- {
- new (this) Event(q, EventQueue::context35<F, C0, C1, C2, A0, A1, A2, A3, A4>(f, c0, c1, c2));
- }
-
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0,c1,c2,c3 Arguments to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0..b3, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0, typename C1, typename C2, typename C3>
- Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3)
- {
- new (this) Event(q, EventQueue::context45<F, C0, C1, C2, C3, A0, A1, A2, A3, A4>(f, c0, c1, c2, c3));
- }
-
- /** Create an event
- * @param q Event queue to dispatch on
- * @param f Function to execute when the event is dispatched
- * @param c0,c1,c2,c3,c4 Arguments to bind to the callback, these arguments are
- * allocated on an IRQ-safe allocator from the event queue's
- * memory pool. Must be type-compatible with b0..b4, the
- * arguments to the underlying callback.
- */
- template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4>
- Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
- {
- new (this) Event(q, EventQueue::context55<F, C0, C1, C2, C3, C4, A0, A1, A2, A3, A4>(f, c0, c1, c2, c3, c4));
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, A0, A1, A2, A3, A4), B0 b0)
- {
- new (this) Event(q, mbed::callback(obj, method), b0);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, A0, A1, A2, A3, A4) const, B0 b0)
- {
- new (this) Event(q, mbed::callback(obj, method), b0);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, A0, A1, A2, A3, A4) volatile, B0 b0)
- {
- new (this) Event(q, mbed::callback(obj, method), b0);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, A0, A1, A2, A3, A4) const volatile, B0 b0)
- {
- new (this) Event(q, mbed::callback(obj, method), b0);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3, A4), B0 b0, B1 b1)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3, A4) const, B0 b0, B1 b1)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3, A4) volatile, B0 b0, B1 b1)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3, A4) const volatile, B0 b0, B1 b1)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3, A4), B0 b0, B1 b1, B2 b2)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3, A4) const, B0 b0, B1 b1, B2 b2)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3, A4) volatile, B0 b0, B1 b1, B2 b2)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3, A4) const volatile, B0 b0, B1 b1, B2 b2)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3, A4), B0 b0, B1 b1, B2 b2, B3 b3)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3, A4) const, B0 b0, B1 b1, B2 b2, B3 b3)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3, A4) volatile, B0 b0, B1 b1, B2 b2, B3 b3)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3, A4) const volatile, B0 b0, B1 b1, B2 b2, B3 b3)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
- Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4), B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
- Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4) const, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
- Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4) volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
- }
-
- /** Create an event
- * @see Event::Event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
- Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4) const volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
- {
- new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
- }
-};
-
-
-/** \addtogroup events */
-/** @{ */
-
-// Convenience functions declared here to avoid cyclic
-// dependency between Event and EventQueue
-template <typename R>
-Event<void()> EventQueue::event(R(*func)())
-{
- return Event<void()>(this, func);
-}
-
-template <typename T, typename R>
-Event<void()> EventQueue::event(T *obj, R(T::*method)())
-{
- return Event<void()>(this, mbed::callback(obj, method));
-}
-
-template <typename T, typename R>
-Event<void()> EventQueue::event(const T *obj, R(T::*method)() const)
-{
- return Event<void()>(this, mbed::callback(obj, method));
-}
-
-template <typename T, typename R>
-Event<void()> EventQueue::event(volatile T *obj, R(T::*method)() volatile)
-{
- return Event<void()>(this, mbed::callback(obj, method));
-}
-
-template <typename T, typename R>
-Event<void()> EventQueue::event(const volatile T *obj, R(T::*method)() const volatile)
-{
- return Event<void()>(this, mbed::callback(obj, method));
-}
-
-template <typename R>
-Event<void()> EventQueue::event(mbed::Callback<R()> cb)
-{
- return Event<void()>(this, cb);
-}
-
-template <typename R, typename B0, typename C0>
-Event<void()> EventQueue::event(R(*func)(B0), C0 c0)
-{
- return Event<void()>(this, func, c0);
-}
-
-template <typename T, typename R, typename B0, typename C0>
-Event<void()> EventQueue::event(T *obj, R(T::*method)(B0), C0 c0)
-{
- return Event<void()>(this, mbed::callback(obj, method), c0);
-}
-
-template <typename T, typename R, typename B0, typename C0>
-Event<void()> EventQueue::event(const T *obj, R(T::*method)(B0) const, C0 c0)
-{
- return Event<void()>(this, mbed::callback(obj, method), c0);
-}
-
-template <typename T, typename R, typename B0, typename C0>
-Event<void()> EventQueue::event(volatile T *obj, R(T::*method)(B0) volatile, C0 c0)
-{
- return Event<void()>(this, mbed::callback(obj, method), c0);
-}
-
-template <typename T, typename R, typename B0, typename C0>
-Event<void()> EventQueue::event(const volatile T *obj, R(T::*method)(B0) const volatile, C0 c0)
-{
- return Event<void()>(this, mbed::callback(obj, method), c0);
-}
-
-template <typename R, typename B0, typename C0>
-Event<void()> EventQueue::event(mbed::Callback<R(B0)> cb, C0 c0)
-{
- return Event<void()>(this, cb, c0);
-}
-
-template <typename R, typename B0, typename B1, typename C0, typename C1>
-Event<void()> EventQueue::event(R(*func)(B0, B1), C0 c0, C1 c1)
-{
- return Event<void()>(this, func, c0, c1);
-}
-
-template <typename T, typename R, typename B0, typename B1, typename C0, typename C1>
-Event<void()> EventQueue::event(T *obj, R(T::*method)(B0, B1), C0 c0, C1 c1)
-{
- return Event<void()>(this, mbed::callback(obj, method), c0, c1);
-}
-
-template <typename T, typename R, typename B0, typename B1, typename C0, typename C1>
-Event<void()> EventQueue::event(const T *obj, R(T::*method)(B0, B1) const, C0 c0, C1 c1)
-{
- return Event<void()>(this, mbed::callback(obj, method), c0, c1);
-}
-
-template <typename T, typename R, typename B0, typename B1, typename C0, typename C1>
-Event<void()> EventQueue::event(volatile T *obj, R(T::*method)(B0, B1) volatile, C0 c0, C1 c1)
-{
- return Event<void()>(this, mbed::callback(obj, method), c0, c1);
-}
-
-template <typename T, typename R, typename B0, typename B1, typename C0, typename C1>
-Event<void()> EventQueue::event(const volatile T *obj, R(T::*method)(B0, B1) const volatile, C0 c0, C1 c1)
-{
- return Event<void()>(this, mbed::callback(obj, method), c0, c1);
-}
-
-template <typename R, typename B0, typename B1, typename C0, typename C1>
-Event<void()> EventQueue::event(mbed::Callback<R(B0, B1)> cb, C0 c0, C1 c1)
-{
- return Event<void()>(this, cb, c0, c1);
-}
-
-template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
-Event<void()> EventQueue::event(R(*func)(B0, B1, B2), C0 c0, C1 c1, C2 c2)
-{
- return Event<void()>(this, func, c0, c1, c2);
-}
-
-template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
-Event<void()> EventQueue::event(T *obj, R(T::*method)(B0, B1, B2), C0 c0, C1 c1, C2 c2)
-{
- return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2);
-}
-
-template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
-Event<void()> EventQueue::event(const T *obj, R(T::*method)(B0, B1, B2) const, C0 c0, C1 c1, C2 c2)
-{
- return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2);
-}
-
-template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
-Event<void()> EventQueue::event(volatile T *obj, R(T::*method)(B0, B1, B2) volatile, C0 c0, C1 c1, C2 c2)
-{
- return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2);
-}
-
-template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
-Event<void()> EventQueue::event(const volatile T *obj, R(T::*method)(B0, B1, B2) const volatile, C0 c0, C1 c1, C2 c2)
-{
- return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2);
-}
-
-template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
-Event<void()> EventQueue::event(mbed::Callback<R(B0, B1, B2)> cb, C0 c0, C1 c1, C2 c2)
-{
- return Event<void()>(this, cb, c0, c1, c2);
-}
-
-template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
-Event<void()> EventQueue::event(R(*func)(B0, B1, B2, B3), C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void()>(this, func, c0, c1, c2, c3);
-}
-
-template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
-Event<void()> EventQueue::event(T *obj, R(T::*method)(B0, B1, B2, B3), C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2, c3);
-}
-
-template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
-Event<void()> EventQueue::event(const T *obj, R(T::*method)(B0, B1, B2, B3) const, C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2, c3);
-}
-
-template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
-Event<void()> EventQueue::event(volatile T *obj, R(T::*method)(B0, B1, B2, B3) volatile, C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2, c3);
-}
-
-template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
-Event<void()> EventQueue::event(const volatile T *obj, R(T::*method)(B0, B1, B2, B3) const volatile, C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2, c3);
-}
-
-template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
-Event<void()> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3)> cb, C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void()>(this, cb, c0, c1, c2, 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()> EventQueue::event(R(*func)(B0, B1, B2, B3, B4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
-{
- return Event<void()>(this, func, c0, c1, c2, c3, 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()> EventQueue::event(T *obj, R(T::*method)(B0, B1, B2, B3, B4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
-{
- return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2, c3, 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()> EventQueue::event(const T *obj, R(T::*method)(B0, B1, B2, B3, B4) const, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
-{
- return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2, c3, 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()> EventQueue::event(volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4) volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
-{
- return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2, c3, 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()> EventQueue::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)
-{
- return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2, c3, 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()> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, B4)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
-{
- return Event<void()>(this, cb, c0, c1, c2, c3, c4);
-}
-
-template <typename R, typename A0>
-Event<void(A0)> EventQueue::event(R(*func)(A0))
-{
- return Event<void(A0)>(this, func);
-}
-
-template <typename T, typename R, typename A0>
-Event<void(A0)> EventQueue::event(T *obj, R(T::*method)(A0))
-{
- return Event<void(A0)>(this, mbed::callback(obj, method));
-}
-
-template <typename T, typename R, typename A0>
-Event<void(A0)> EventQueue::event(const T *obj, R(T::*method)(A0) const)
-{
- return Event<void(A0)>(this, mbed::callback(obj, method));
-}
-
-template <typename T, typename R, typename A0>
-Event<void(A0)> EventQueue::event(volatile T *obj, R(T::*method)(A0) volatile)
-{
- return Event<void(A0)>(this, mbed::callback(obj, method));
-}
-
-template <typename T, typename R, typename A0>
-Event<void(A0)> EventQueue::event(const volatile T *obj, R(T::*method)(A0) const volatile)
-{
- return Event<void(A0)>(this, mbed::callback(obj, method));
-}
-
-template <typename R, typename A0>
-Event<void(A0)> EventQueue::event(mbed::Callback<R(A0)> cb)
-{
- return Event<void(A0)>(this, cb);
-}
-
-template <typename R, typename B0, typename C0, typename A0>
-Event<void(A0)> EventQueue::event(R(*func)(B0, A0), C0 c0)
-{
- return Event<void(A0)>(this, func, c0);
-}
-
-template <typename T, typename R, typename B0, typename C0, typename A0>
-Event<void(A0)> EventQueue::event(T *obj, R(T::*method)(B0, A0), C0 c0)
-{
- return Event<void(A0)>(this, mbed::callback(obj, method), c0);
-}
-
-template <typename T, typename R, typename B0, typename C0, typename A0>
-Event<void(A0)> EventQueue::event(const T *obj, R(T::*method)(B0, A0) const, C0 c0)
-{
- return Event<void(A0)>(this, mbed::callback(obj, method), c0);
-}
-
-template <typename T, typename R, typename B0, typename C0, typename A0>
-Event<void(A0)> EventQueue::event(volatile T *obj, R(T::*method)(B0, A0) volatile, C0 c0)
-{
- return Event<void(A0)>(this, mbed::callback(obj, method), c0);
-}
-
-template <typename T, typename R, typename B0, typename C0, typename A0>
-Event<void(A0)> EventQueue::event(const volatile T *obj, R(T::*method)(B0, A0) const volatile, C0 c0)
-{
- return Event<void(A0)>(this, mbed::callback(obj, method), c0);
-}
-
-template <typename R, typename B0, typename C0, typename A0>
-Event<void(A0)> EventQueue::event(mbed::Callback<R(B0, A0)> cb, C0 c0)
-{
- return Event<void(A0)>(this, cb, c0);
-}
-
-template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
-Event<void(A0)> EventQueue::event(R(*func)(B0, B1, A0), C0 c0, C1 c1)
-{
- return Event<void(A0)>(this, func, c0, c1);
-}
-
-template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
-Event<void(A0)> EventQueue::event(T *obj, R(T::*method)(B0, B1, A0), C0 c0, C1 c1)
-{
- return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1);
-}
-
-template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
-Event<void(A0)> EventQueue::event(const T *obj, R(T::*method)(B0, B1, A0) const, C0 c0, C1 c1)
-{
- return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1);
-}
-
-template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
-Event<void(A0)> EventQueue::event(volatile T *obj, R(T::*method)(B0, B1, A0) volatile, C0 c0, C1 c1)
-{
- return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1);
-}
-
-template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
-Event<void(A0)> EventQueue::event(const volatile T *obj, R(T::*method)(B0, B1, A0) const volatile, C0 c0, C1 c1)
-{
- return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1);
-}
-
-template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
-Event<void(A0)> EventQueue::event(mbed::Callback<R(B0, B1, A0)> cb, C0 c0, C1 c1)
-{
- return Event<void(A0)>(this, cb, c0, c1);
-}
-
-template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
-Event<void(A0)> EventQueue::event(R(*func)(B0, B1, B2, A0), C0 c0, C1 c1, C2 c2)
-{
- return Event<void(A0)>(this, func, c0, c1, c2);
-}
-
-template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
-Event<void(A0)> EventQueue::event(T *obj, R(T::*method)(B0, B1, B2, A0), C0 c0, C1 c1, C2 c2)
-{
- return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2);
-}
-
-template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
-Event<void(A0)> EventQueue::event(const T *obj, R(T::*method)(B0, B1, B2, A0) const, C0 c0, C1 c1, C2 c2)
-{
- return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2);
-}
-
-template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
-Event<void(A0)> EventQueue::event(volatile T *obj, R(T::*method)(B0, B1, B2, A0) volatile, C0 c0, C1 c1, C2 c2)
-{
- return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2);
-}
-
-template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
-Event<void(A0)> EventQueue::event(const volatile T *obj, R(T::*method)(B0, B1, B2, A0) const volatile, C0 c0, C1 c1, C2 c2)
-{
- return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2);
-}
-
-template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
-Event<void(A0)> EventQueue::event(mbed::Callback<R(B0, B1, B2, A0)> cb, C0 c0, C1 c1, C2 c2)
-{
- return Event<void(A0)>(this, cb, c0, c1, 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)> EventQueue::event(R(*func)(B0, B1, B2, B3, A0), C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void(A0)>(this, func, c0, c1, c2, 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)> EventQueue::event(T *obj, R(T::*method)(B0, B1, B2, B3, A0), C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2, 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)> EventQueue::event(const T *obj, R(T::*method)(B0, B1, B2, B3, A0) const, C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2, 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)> EventQueue::event(volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0) volatile, C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2, 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)> EventQueue::event(const volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0) const volatile, C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2, 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)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, A0)> cb, C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void(A0)>(this, cb, c0, c1, c2, 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)> EventQueue::event(R(*func)(B0, B1, B2, B3, B4, A0), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
-{
- return Event<void(A0)>(this, func, c0, c1, c2, c3, 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)> EventQueue::event(T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
-{
- return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2, c3, 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)> EventQueue::event(const T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0) const, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
-{
- return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2, c3, 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)> EventQueue::event(volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0) volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
-{
- return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2, c3, 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)> EventQueue::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)
-{
- return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2, c3, 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)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, B4, A0)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
-{
- return Event<void(A0)>(this, cb, c0, c1, c2, c3, c4);
-}
-
-template <typename R, typename A0, typename A1>
-Event<void(A0, A1)> EventQueue::event(R(*func)(A0, A1))
-{
- return Event<void(A0, A1)>(this, func);
-}
-
-template <typename T, typename R, typename A0, typename A1>
-Event<void(A0, A1)> EventQueue::event(T *obj, R(T::*method)(A0, A1))
-{
- return Event<void(A0, A1)>(this, mbed::callback(obj, method));
-}
-
-template <typename T, typename R, typename A0, typename A1>
-Event<void(A0, A1)> EventQueue::event(const T *obj, R(T::*method)(A0, A1) const)
-{
- return Event<void(A0, A1)>(this, mbed::callback(obj, method));
-}
-
-template <typename T, typename R, typename A0, typename A1>
-Event<void(A0, A1)> EventQueue::event(volatile T *obj, R(T::*method)(A0, A1) volatile)
-{
- return Event<void(A0, A1)>(this, mbed::callback(obj, method));
-}
-
-template <typename T, typename R, typename A0, typename A1>
-Event<void(A0, A1)> EventQueue::event(const volatile T *obj, R(T::*method)(A0, A1) const volatile)
-{
- return Event<void(A0, A1)>(this, mbed::callback(obj, method));
-}
-
-template <typename R, typename A0, typename A1>
-Event<void(A0, A1)> EventQueue::event(mbed::Callback<R(A0, A1)> cb)
-{
- return Event<void(A0, A1)>(this, cb);
-}
-
-template <typename R, typename B0, typename C0, typename A0, typename A1>
-Event<void(A0, A1)> EventQueue::event(R(*func)(B0, A0, A1), C0 c0)
-{
- return Event<void(A0, A1)>(this, func, c0);
-}
-
-template <typename T, typename R, typename B0, typename C0, typename A0, typename A1>
-Event<void(A0, A1)> EventQueue::event(T *obj, R(T::*method)(B0, A0, A1), C0 c0)
-{
- return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0);
-}
-
-template <typename T, typename R, typename B0, typename C0, typename A0, typename A1>
-Event<void(A0, A1)> EventQueue::event(const T *obj, R(T::*method)(B0, A0, A1) const, C0 c0)
-{
- return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0);
-}
-
-template <typename T, typename R, typename B0, typename C0, typename A0, typename A1>
-Event<void(A0, A1)> EventQueue::event(volatile T *obj, R(T::*method)(B0, A0, A1) volatile, C0 c0)
-{
- return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0);
-}
-
-template <typename T, typename R, typename B0, typename C0, typename A0, typename A1>
-Event<void(A0, A1)> EventQueue::event(const volatile T *obj, R(T::*method)(B0, A0, A1) const volatile, C0 c0)
-{
- return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0);
-}
-
-template <typename R, typename B0, typename C0, typename A0, typename A1>
-Event<void(A0, A1)> EventQueue::event(mbed::Callback<R(B0, A0, A1)> cb, C0 c0)
-{
- return Event<void(A0, A1)>(this, cb, c0);
-}
-
-template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
-Event<void(A0, A1)> EventQueue::event(R(*func)(B0, B1, A0, A1), C0 c0, C1 c1)
-{
- return Event<void(A0, A1)>(this, func, c0, c1);
-}
-
-template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
-Event<void(A0, A1)> EventQueue::event(T *obj, R(T::*method)(B0, B1, A0, A1), C0 c0, C1 c1)
-{
- return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1);
-}
-
-template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
-Event<void(A0, A1)> EventQueue::event(const T *obj, R(T::*method)(B0, B1, A0, A1) const, C0 c0, C1 c1)
-{
- return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1);
-}
-
-template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
-Event<void(A0, A1)> EventQueue::event(volatile T *obj, R(T::*method)(B0, B1, A0, A1) volatile, C0 c0, C1 c1)
-{
- return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1);
-}
-
-template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
-Event<void(A0, A1)> EventQueue::event(const volatile T *obj, R(T::*method)(B0, B1, A0, A1) const volatile, C0 c0, C1 c1)
-{
- return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1);
-}
-
-template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
-Event<void(A0, A1)> EventQueue::event(mbed::Callback<R(B0, B1, A0, A1)> cb, C0 c0, C1 c1)
-{
- return Event<void(A0, A1)>(this, cb, c0, c1);
-}
-
-template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
-Event<void(A0, A1)> EventQueue::event(R(*func)(B0, B1, B2, A0, A1), C0 c0, C1 c1, C2 c2)
-{
- return Event<void(A0, A1)>(this, func, c0, c1, 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)> EventQueue::event(T *obj, R(T::*method)(B0, B1, B2, A0, A1), C0 c0, C1 c1, C2 c2)
-{
- return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, 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)> EventQueue::event(const T *obj, R(T::*method)(B0, B1, B2, A0, A1) const, C0 c0, C1 c1, C2 c2)
-{
- return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, 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)> EventQueue::event(volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1) volatile, C0 c0, C1 c1, C2 c2)
-{
- return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, 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)> EventQueue::event(const volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1) const volatile, C0 c0, C1 c1, C2 c2)
-{
- return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2);
-}
-
-template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
-Event<void(A0, A1)> EventQueue::event(mbed::Callback<R(B0, B1, B2, A0, A1)> cb, C0 c0, C1 c1, C2 c2)
-{
- return Event<void(A0, A1)>(this, cb, c0, c1, 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)> EventQueue::event(R(*func)(B0, B1, B2, B3, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void(A0, A1)>(this, func, c0, c1, c2, 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)> EventQueue::event(T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2, 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)> EventQueue::event(const T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1) const, C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2, 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)> EventQueue::event(volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1) volatile, C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2, 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)> EventQueue::event(const volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1) const volatile, C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2, 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)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, A0, A1)> cb, C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void(A0, A1)>(this, cb, c0, c1, c2, 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)> EventQueue::event(R(*func)(B0, B1, B2, B3, B4, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
-{
- return Event<void(A0, A1)>(this, func, c0, c1, c2, c3, 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)> EventQueue::event(T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
-{
- return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2, c3, 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)> EventQueue::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)
-{
- return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2, c3, 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)> EventQueue::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)
-{
- return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2, c3, 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)> EventQueue::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)
-{
- return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2, c3, 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)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, B4, A0, A1)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
-{
- return Event<void(A0, A1)>(this, cb, c0, c1, c2, c3, c4);
-}
-
-template <typename R, typename A0, typename A1, typename A2>
-Event<void(A0, A1, A2)> EventQueue::event(R(*func)(A0, A1, A2))
-{
- return Event<void(A0, A1, A2)>(this, func);
-}
-
-template <typename T, typename R, typename A0, typename A1, typename A2>
-Event<void(A0, A1, A2)> EventQueue::event(T *obj, R(T::*method)(A0, A1, A2))
-{
- return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method));
-}
-
-template <typename T, typename R, typename A0, typename A1, typename A2>
-Event<void(A0, A1, A2)> EventQueue::event(const T *obj, R(T::*method)(A0, A1, A2) const)
+template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(volatile T *obj, R(T::*method)(B0, B1, ArgTs...) volatile, C0 c0, C1 c1)
{
- return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method));
+ return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1);
}
-template <typename T, typename R, typename A0, typename A1, typename A2>
-Event<void(A0, A1, A2)> EventQueue::event(volatile T *obj, R(T::*method)(A0, A1, A2) volatile)
+template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(const volatile T *obj, R(T::*method)(B0, B1, ArgTs...) const volatile, C0 c0, C1 c1)
{
- return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method));
+ return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1);
}
-template <typename T, typename R, typename A0, typename A1, typename A2>
-Event<void(A0, A1, A2)> EventQueue::event(const volatile T *obj, R(T::*method)(A0, A1, A2) const volatile)
+template <typename R, typename B0, typename B1, typename C0, typename C1, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(mbed::Callback<R(B0, B1, ArgTs...)> cb, C0 c0, C1 c1)
{
- return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method));
+ return Event<void(ArgTs...)>(this, cb, c0, c1);
}
-template <typename R, typename A0, typename A1, typename A2>
-Event<void(A0, A1, A2)> EventQueue::event(mbed::Callback<R(A0, A1, A2)> cb)
+template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(R(*func)(B0, B1, B2, ArgTs...), C0 c0, C1 c1, C2 c2)
{
- return Event<void(A0, A1, A2)>(this, cb);
+ return Event<void(ArgTs...)>(this, func, c0, c1, c2);
}
-template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
-Event<void(A0, A1, A2)> EventQueue::event(R(*func)(B0, A0, A1, A2), C0 c0)
+template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(T *obj, R(T::*method)(B0, B1, B2, ArgTs...), C0 c0, C1 c1, C2 c2)
{
- return Event<void(A0, A1, A2)>(this, func, c0);
+ return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1, c2);
}
-template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
-Event<void(A0, A1, A2)> EventQueue::event(T *obj, R(T::*method)(B0, A0, A1, A2), C0 c0)
+template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(const T *obj, R(T::*method)(B0, B1, B2, ArgTs...) const, C0 c0, C1 c1, C2 c2)
{
- return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0);
+ return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1, c2);
}
-template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
-Event<void(A0, A1, A2)> EventQueue::event(const T *obj, R(T::*method)(B0, A0, A1, A2) const, C0 c0)
+template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(volatile T *obj, R(T::*method)(B0, B1, B2, ArgTs...) volatile, C0 c0, C1 c1, C2 c2)
{
- return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0);
+ return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1, c2);
}
-template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
-Event<void(A0, A1, A2)> EventQueue::event(volatile T *obj, R(T::*method)(B0, A0, A1, A2) volatile, C0 c0)
+template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(const volatile T *obj, R(T::*method)(B0, B1, B2, ArgTs...) const volatile, C0 c0, C1 c1, C2 c2)
{
- return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0);
+ return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1, c2);
}
-template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
-Event<void(A0, A1, A2)> EventQueue::event(const volatile T *obj, R(T::*method)(B0, A0, A1, A2) const volatile, C0 c0)
+template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(mbed::Callback<R(B0, B1, B2, ArgTs...)> cb, C0 c0, C1 c1, C2 c2)
{
- return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0);
+ return Event<void(ArgTs...)>(this, cb, c0, c1, c2);
}
-template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
-Event<void(A0, A1, A2)> EventQueue::event(mbed::Callback<R(B0, A0, A1, A2)> cb, C0 c0)
+template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(R(*func)(B0, B1, B2, B3, ArgTs...), C0 c0, C1 c1, C2 c2, C3 c3)
{
- return Event<void(A0, A1, A2)>(this, cb, c0);
+ return Event<void(ArgTs...)>(this, func, c0, c1, c2, c3);
}
-template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
-Event<void(A0, A1, A2)> EventQueue::event(R(*func)(B0, B1, A0, A1, A2), C0 c0, C1 c1)
+template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(T *obj, R(T::*method)(B0, B1, B2, B3, ArgTs...), C0 c0, C1 c1, C2 c2, C3 c3)
{
- return Event<void(A0, A1, A2)>(this, func, c0, c1);
+ return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
}
-template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
-Event<void(A0, A1, A2)> EventQueue::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 B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(const T *obj, R(T::*method)(B0, B1, B2, B3, ArgTs...) const, C0 c0, C1 c1, C2 c2, C3 c3)
{
- return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1);
+ return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
}
-template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
-Event<void(A0, A1, A2)> EventQueue::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 B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(volatile T *obj, R(T::*method)(B0, B1, B2, B3, ArgTs...) volatile, C0 c0, C1 c1, C2 c2, C3 c3)
{
- return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1);
+ return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
}
-template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
-Event<void(A0, A1, A2)> EventQueue::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 B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(const volatile T *obj, R(T::*method)(B0, B1, B2, B3, ArgTs...) const volatile, C0 c0, C1 c1, C2 c2, C3 c3)
{
- return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1);
+ return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
}
-template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
-Event<void(A0, A1, A2)> EventQueue::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 B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, ArgTs...)> cb, C0 c0, C1 c1, C2 c2, C3 c3)
{
- return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1);
+ return Event<void(ArgTs...)>(this, cb, c0, c1, c2, c3);
}
-template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
-Event<void(A0, A1, A2)> EventQueue::event(mbed::Callback<R(B0, B1, A0, A1, A2)> cb, C0 c0, C1 c1)
+template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(R(*func)(B0, B1, B2, B3, B4, ArgTs...), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
{
- return Event<void(A0, A1, A2)>(this, cb, c0, c1);
+ return Event<void(ArgTs...)>(this, func, c0, c1, c2, c3, c4);
}
-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)> EventQueue::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 B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(T *obj, R(T::*method)(B0, B1, B2, B3, B4, ArgTs...), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
{
- return Event<void(A0, A1, A2)>(this, func, c0, c1, c2);
+ return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
}
-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)> EventQueue::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 B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(const T *obj, R(T::*method)(B0, B1, B2, B3, B4, ArgTs...) const, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
{
- return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2);
+ return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
}
-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)> EventQueue::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 B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, ArgTs...) volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
{
- return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2);
+ return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
}
-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)> EventQueue::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 B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(const volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, ArgTs...) const volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
{
- return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2);
+ return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
}
-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)> EventQueue::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 B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename... ArgTs>
+Event<void(ArgTs...)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, B4, ArgTs...)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
{
- return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2);
+ return Event<void(ArgTs...)>(this, cb, c0, c1, c2, c3, c4);
}
-
-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)> EventQueue::event(mbed::Callback<R(B0, B1, B2, A0, A1, A2)> cb, C0 c0, C1 c1, C2 c2)
-{
- return Event<void(A0, A1, A2)>(this, cb, c0, c1, 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)> EventQueue::event(R(*func)(B0, B1, B2, B3, A0, A1, A2), C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void(A0, A1, A2)>(this, func, c0, c1, c2, 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)> EventQueue::event(T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2), C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2, 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)> EventQueue::event(const T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2) const, C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2, 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)> EventQueue::event(volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2) volatile, C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2, 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)> EventQueue::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)
-{
- return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2, 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)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, A0, A1, A2)> cb, C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void(A0, A1, A2)>(this, cb, c0, c1, c2, 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)> EventQueue::event(R(*func)(B0, B1, B2, B3, B4, A0, A1, A2), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
-{
- return Event<void(A0, A1, A2)>(this, func, c0, c1, c2, c3, 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)> EventQueue::event(T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
-{
- return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2, c3, 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)> EventQueue::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)
-{
- return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2, c3, 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)> EventQueue::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)
-{
- return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2, c3, 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)> EventQueue::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)
-{
- return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2, c3, 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)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, B4, A0, A1, A2)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
-{
- return Event<void(A0, A1, A2)>(this, cb, c0, c1, c2, c3, c4);
-}
-
-template <typename R, typename A0, typename A1, typename A2, typename A3>
-Event<void(A0, A1, A2, A3)> EventQueue::event(R(*func)(A0, A1, A2, A3))
-{
- return Event<void(A0, A1, A2, A3)>(this, func);
-}
-
-template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
-Event<void(A0, A1, A2, A3)> EventQueue::event(T *obj, R(T::*method)(A0, A1, A2, A3))
-{
- return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method));
-}
-
-template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
-Event<void(A0, A1, A2, A3)> EventQueue::event(const T *obj, R(T::*method)(A0, A1, A2, A3) const)
-{
- return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method));
-}
-
-template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
-Event<void(A0, A1, A2, A3)> EventQueue::event(volatile T *obj, R(T::*method)(A0, A1, A2, A3) volatile)
-{
- return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method));
-}
-
-template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
-Event<void(A0, A1, A2, A3)> EventQueue::event(const volatile T *obj, R(T::*method)(A0, A1, A2, A3) const volatile)
-{
- return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method));
-}
-
-template <typename R, typename A0, typename A1, typename A2, typename A3>
-Event<void(A0, A1, A2, A3)> EventQueue::event(mbed::Callback<R(A0, A1, A2, A3)> cb)
-{
- return Event<void(A0, A1, A2, A3)>(this, cb);
-}
-
-template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
-Event<void(A0, A1, A2, A3)> EventQueue::event(R(*func)(B0, A0, A1, A2, A3), C0 c0)
-{
- return Event<void(A0, A1, A2, A3)>(this, func, c0);
-}
-
-template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
-Event<void(A0, A1, A2, A3)> EventQueue::event(T *obj, R(T::*method)(B0, A0, A1, A2, A3), C0 c0)
-{
- return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0);
-}
-
-template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
-Event<void(A0, A1, A2, A3)> EventQueue::event(const T *obj, R(T::*method)(B0, A0, A1, A2, A3) const, C0 c0)
-{
- return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0);
-}
-
-template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
-Event<void(A0, A1, A2, A3)> EventQueue::event(volatile T *obj, R(T::*method)(B0, A0, A1, A2, A3) volatile, C0 c0)
-{
- return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0);
-}
-
-template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
-Event<void(A0, A1, A2, A3)> EventQueue::event(const volatile T *obj, R(T::*method)(B0, A0, A1, A2, A3) const volatile, C0 c0)
-{
- return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0);
-}
-
-template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
-Event<void(A0, A1, A2, A3)> EventQueue::event(mbed::Callback<R(B0, A0, A1, A2, A3)> cb, C0 c0)
-{
- return Event<void(A0, A1, A2, A3)>(this, cb, 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)> EventQueue::event(R(*func)(B0, B1, A0, A1, A2, A3), C0 c0, C1 c1)
-{
- return Event<void(A0, A1, A2, A3)>(this, func, c0, 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)> EventQueue::event(T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3), C0 c0, C1 c1)
-{
- return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, 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)> EventQueue::event(const T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3) const, C0 c0, C1 c1)
-{
- return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, 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)> EventQueue::event(volatile T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3) volatile, C0 c0, C1 c1)
-{
- return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, 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)> EventQueue::event(const volatile T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3) const volatile, C0 c0, C1 c1)
-{
- return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, 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)> EventQueue::event(mbed::Callback<R(B0, B1, A0, A1, A2, A3)> cb, C0 c0, C1 c1)
-{
- return Event<void(A0, A1, A2, A3)>(this, cb, c0, 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)> EventQueue::event(R(*func)(B0, B1, B2, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2)
-{
- return Event<void(A0, A1, A2, A3)>(this, func, c0, c1, 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)> EventQueue::event(T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2)
-{
- return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, 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)> EventQueue::event(const T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3) const, C0 c0, C1 c1, C2 c2)
-{
- return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, 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)> EventQueue::event(volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3) volatile, C0 c0, C1 c1, C2 c2)
-{
- return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, 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)> EventQueue::event(const volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3) const volatile, C0 c0, C1 c1, C2 c2)
-{
- return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, 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)> EventQueue::event(mbed::Callback<R(B0, B1, B2, A0, A1, A2, A3)> cb, C0 c0, C1 c1, C2 c2)
-{
- return Event<void(A0, A1, A2, A3)>(this, cb, c0, c1, 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)> EventQueue::event(R(*func)(B0, B1, B2, B3, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void(A0, A1, A2, A3)>(this, func, c0, c1, c2, 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)> EventQueue::event(T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2, 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)> EventQueue::event(const T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3) const, C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2, 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)> EventQueue::event(volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3) volatile, C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2, 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)> EventQueue::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)
-{
- return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2, 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)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, A0, A1, A2, A3)> cb, C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void(A0, A1, A2, A3)>(this, cb, c0, c1, c2, 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)> EventQueue::event(R(*func)(B0, B1, B2, B3, B4, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
-{
- return Event<void(A0, A1, A2, A3)>(this, func, c0, c1, c2, c3, 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)> EventQueue::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)
-{
- return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2, c3, 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)> EventQueue::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)
-{
- return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2, c3, 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)> EventQueue::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)
-{
- return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2, c3, 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)> EventQueue::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)
-{
- return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2, c3, 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)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, B4, A0, A1, A2, A3)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
-{
- return Event<void(A0, A1, A2, A3)>(this, cb, c0, c1, c2, c3, c4);
-}
-
-template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
-Event<void(A0, A1, A2, A3, A4)> EventQueue::event(R(*func)(A0, A1, A2, A3, A4))
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, func);
-}
-
-template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
-Event<void(A0, A1, A2, A3, A4)> EventQueue::event(T *obj, R(T::*method)(A0, A1, A2, A3, A4))
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method));
-}
-
-template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
-Event<void(A0, A1, A2, A3, A4)> EventQueue::event(const T *obj, R(T::*method)(A0, A1, A2, A3, A4) const)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method));
-}
-
-template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
-Event<void(A0, A1, A2, A3, A4)> EventQueue::event(volatile T *obj, R(T::*method)(A0, A1, A2, A3, A4) volatile)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method));
-}
-
-template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
-Event<void(A0, A1, A2, A3, A4)> EventQueue::event(const volatile T *obj, R(T::*method)(A0, A1, A2, A3, A4) const volatile)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method));
-}
-
-template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
-Event<void(A0, A1, A2, A3, A4)> EventQueue::event(mbed::Callback<R(A0, A1, A2, A3, A4)> cb)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, 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)> EventQueue::event(R(*func)(B0, A0, A1, A2, A3, A4), C0 c0)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, func, 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)> EventQueue::event(T *obj, R(T::*method)(B0, A0, A1, A2, A3, A4), C0 c0)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), 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)> EventQueue::event(const T *obj, R(T::*method)(B0, A0, A1, A2, A3, A4) const, C0 c0)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), 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)> EventQueue::event(volatile T *obj, R(T::*method)(B0, A0, A1, A2, A3, A4) volatile, C0 c0)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), 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)> EventQueue::event(const volatile T *obj, R(T::*method)(B0, A0, A1, A2, A3, A4) const volatile, C0 c0)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), 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)> EventQueue::event(mbed::Callback<R(B0, A0, A1, A2, A3, A4)> cb, C0 c0)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, cb, 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)> EventQueue::event(R(*func)(B0, B1, A0, A1, A2, A3, A4), C0 c0, C1 c1)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, func, c0, 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)> EventQueue::event(T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3, A4), C0 c0, C1 c1)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, 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)> EventQueue::event(const T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3, A4) const, C0 c0, C1 c1)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, 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)> EventQueue::event(volatile T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3, A4) volatile, C0 c0, C1 c1)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, 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)> EventQueue::event(const volatile T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3, A4) const volatile, C0 c0, C1 c1)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, 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)> EventQueue::event(mbed::Callback<R(B0, B1, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, cb, c0, 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)> EventQueue::event(R(*func)(B0, B1, B2, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, func, c0, c1, 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)> EventQueue::event(T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, 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)> EventQueue::event(const T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3, A4) const, C0 c0, C1 c1, C2 c2)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, 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)> EventQueue::event(volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3, A4) volatile, C0 c0, C1 c1, C2 c2)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, 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)> EventQueue::event(const volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3, A4) const volatile, C0 c0, C1 c1, C2 c2)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, 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)> EventQueue::event(mbed::Callback<R(B0, B1, B2, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1, C2 c2)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, cb, c0, c1, 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)> EventQueue::event(R(*func)(B0, B1, B2, B3, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, func, c0, c1, c2, 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)> EventQueue::event(T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2, 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)> EventQueue::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)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2, 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)> EventQueue::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)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2, 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)> EventQueue::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)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2, 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)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1, C2 c2, C3 c3)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, cb, c0, c1, c2, 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)> EventQueue::event(R(*func)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, func, c0, c1, c2, c3, 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)> EventQueue::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)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2, c3, 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)> EventQueue::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)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2, c3, 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)> EventQueue::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)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2, c3, 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)> EventQueue::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)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2, c3, 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)> EventQueue::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)
-{
- return Event<void(A0, A1, A2, A3, A4)>(this, cb, c0, c1, c2, c3, c4);
-}
-#endif
}
#endif
diff --git a/events/EventQueue.h b/events/EventQueue.h
index 2b6b200a779..b5d567943a4 100644
--- a/events/EventQueue.h
+++ b/events/EventQueue.h
@@ -462,9 +462,9 @@ class EventQueue : private mbed::NonCopyable<EventQueue> {
* callback acts as the target for the event and is executed in the
* context of the event queue's dispatch loop once posted.
*
- * @param func Function to execute when the event is dispatched
- * @param args Arguments to pass to the callback
- * @return Event that dispatches on the specific queue
+ * @param func Function to execute when the event is dispatched
+ * @param context_args Arguments to pass to the callback
+ * @return Event that dispatches on the specific queue
*
* @code
* #include "mbed.h"
@@ -498,8 +498,8 @@ class EventQueue : private mbed::NonCopyable<EventQueue> {
*/
// AStyle ignore, not handling correctly below
// *INDENT-OFF*
- template <typename R, typename ...BoundArgs, typename ...Args>
- Event<void(Args...)> event(R (*func)(BoundArgs...), Args ...args);
+ template <typename R, typename ...BoundArgs, typename ...ContextArgs, typename ...Args>
+ Event<void(Args...)> event(R (*func)(BoundArgs..., Args...), ContextArgs ...context_args);
// *INDENT-ON*
/** Creates an event bound to the event queue
@@ -638,272 +638,48 @@ class EventQueue : private mbed::NonCopyable<EventQueue> {
/** Calls an event on the queue
* @see EventQueue::call
* @param f Function to execute in the context of the dispatch loop
- * @param a0 Argument to pass to the callback
- */
- template <typename F, typename A0>
- int call(F f, A0 a0)
- {
- return call(context10<F, A0>(f, a0));
- }
-
- /** Calls an event on the queue
- * @see EventQueue::call
- * @param f Function to execute in the context of the dispatch loop
- * @param a0,a1 Arguments to pass to the callback
- */
- template <typename F, typename A0, typename A1>
- int call(F f, A0 a0, A1 a1)
- {
- return call(context20<F, A0, A1>(f, a0, a1));
- }
-
- /** Calls an event on the queue
- * @see EventQueue::call
- * @param f Function to execute in the context of the dispatch loop
- * @param a0,a1,a2 Arguments to pass to the callback
- */
- template <typename F, typename A0, typename A1, typename A2>
- int call(F f, A0 a0, A1 a1, A2 a2)
- {
- return call(context30<F, A0, A1, A2>(f, a0, a1, a2));
- }
-
- /** Calls an event on the queue
- * @see EventQueue::call
- * @param f Function to execute in the context of the dispatch loop
- * @param a0,a1,a2,a3 Arguments to pass to the callback
- */
- template <typename F, typename A0, typename A1, typename A2, typename A3>
- int call(F f, A0 a0, A1 a1, A2 a2, A3 a3)
- {
- return call(context40<F, A0, A1, A2, A3>(f, a0, a1, a2, a3));
- }
-
- /** Calls an event on the queue
- * @see EventQueue::call
- * @param f Function to execute in the context of the dispatch loop
- * @param a0,a1,a2,a3,a4 Arguments to pass to the callback
- */
- 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)
- {
- return call(context50<F, A0, A1, A2, A3, A4>(f, a0, a1, a2, a3, a4));
- }
-
- /** Calls an event on the queue
- * @see EventQueue::call
- */
- template <typename T, typename R>
- int call(T *obj, R(T::*method)())
- {
- return call(mbed::callback(obj, method));
- }
-
- /** Calls an event on the queue
- * @see EventQueue::call
- */
- template <typename T, typename R>
- int call(const T *obj, R(T::*method)() const)
- {
- return call(mbed::callback(obj, method));
- }
-
- /** Calls an event on the queue
- * @see EventQueue::call
- */
- template <typename T, typename R>
- int call(volatile T *obj, R(T::*method)() volatile)
- {
- return call(mbed::callback(obj, method));
- }
-
- /** Calls an event on the queue
- * @see EventQueue::call
- */
- template <typename T, typename R>
- int call(const volatile T *obj, R(T::*method)() const volatile)
- {
- return call(mbed::callback(obj, method));
- }
-
- /** Calls an event on the queue
- * @see EventQueue::call
- */
- template <typename T, typename R, typename A0>
- int call(T *obj, R(T::*method)(A0), A0 a0)
- {
- return call(mbed::callback(obj, method), a0);
- }
-
- /** Calls an event on the queue
- * @see EventQueue::call
- */
- template <typename T, typename R, typename A0>
- int call(const T *obj, R(T::*method)(A0) const, A0 a0)
- {
- return call(mbed::callback(obj, method), a0);
- }
-
- /** Calls an event on the queue
- * @see EventQueue::call
- */
- template <typename T, typename R, typename A0>
- int call(volatile T *obj, R(T::*method)(A0) volatile, A0 a0)
- {
- return call(mbed::callback(obj, method), a0);
- }
-
- /** Calls an event on the queue
- * @see EventQueue::call
- */
- template <typename T, typename R, typename A0>
- int call(const volatile T *obj, R(T::*method)(A0) const volatile, A0 a0)
- {
- return call(mbed::callback(obj, method), a0);
- }
-
- /** Calls an event on the queue
- * @see EventQueue::call
- */
- template <typename T, typename R, typename A0, typename A1>
- int call(T *obj, R(T::*method)(A0, A1), A0 a0, A1 a1)
- {
- return call(mbed::callback(obj, method), a0, a1);
- }
-
- /** Calls an event on the queue
- * @see EventQueue::call
- */
- template <typename T, typename R, typename A0, typename A1>
- int call(const T *obj, R(T::*method)(A0, A1) const, A0 a0, A1 a1)
- {
- return call(mbed::callback(obj, method), a0, a1);
- }
-
- /** Calls an event on the queue
- * @see EventQueue::call
- */
- template <typename T, typename R, typename A0, typename A1>
- int call(volatile T *obj, R(T::*method)(A0, A1) volatile, A0 a0, A1 a1)
- {
- return call(mbed::callback(obj, method), a0, a1);
- }
-
- /** Calls an event on the queue
- * @see EventQueue::call
- */
- 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)
- {
- return call(mbed::callback(obj, method), a0, a1);
- }
-
- /** Calls an event on the queue
- * @see EventQueue::call
- */
- 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)
- {
- return call(mbed::callback(obj, method), a0, a1, a2);
- }
-
- /** Calls an event on the queue
- * @see EventQueue::call
- */
- 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)
- {
- return call(mbed::callback(obj, method), a0, a1, a2);
- }
-
- /** Calls an event on the queue
- * @see EventQueue::call
- */
- 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)
- {
- return call(mbed::callback(obj, method), a0, a1, a2);
- }
-
- /** Calls an event on the queue
- * @see EventQueue::call
- */
- 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)
- {
- return call(mbed::callback(obj, method), a0, a1, a2);
- }
-
- /** Calls an event on the queue
- * @see EventQueue::call
- */
- 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)
- {
- return call(mbed::callback(obj, method), a0, a1, a2, a3);
- }
-
- /** Calls an event on the queue
- * @see EventQueue::call
- */
- 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)
- {
- return call(mbed::callback(obj, method), a0, a1, a2, a3);
- }
-
- /** Calls an event on the queue
- * @see EventQueue::call
- */
- 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)
- {
- return call(mbed::callback(obj, method), a0, a1, a2, a3);
- }
-
- /** Calls an event on the queue
- * @see EventQueue::call
+ * @param args Arguments to pass to the callback
*/
- 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 F, typename... ArgTs>
+ int call(F f, ArgTs... args)
{
- return call(mbed::callback(obj, method), a0, a1, a2, a3);
+ return call(context<F, ArgTs...>(f, args...));
}
/** Calls an event on the queue
* @see EventQueue::call
*/
- 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... ArgTs>
+ int call(T *obj, R(T::*method)(ArgTs...), ArgTs... args)
{
- return call(mbed::callback(obj, method), a0, a1, a2, a3, a4);
+ return call(mbed::callback(obj, method), args...);
}
/** Calls an event on the queue
* @see EventQueue::call
*/
- 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... ArgTs>
+ int call(const T *obj, R(T::*method)(ArgTs...) const, ArgTs... args)
{
- return call(mbed::callback(obj, method), a0, a1, a2, a3, a4);
+ return call(mbed::callback(obj, method), args...);
}
/** Calls an event on the queue
* @see EventQueue::call
*/
- 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... ArgTs>
+ int call(volatile T *obj, R(T::*method)(ArgTs...) volatile, ArgTs... args)
{
- return call(mbed::callback(obj, method), a0, a1, a2, a3, a4);
+ return call(mbed::callback(obj, method), args...);
}
/** Calls an event on the queue
* @see EventQueue::call
*/
- 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 T, typename R, typename... ArgTs>
+ int call(const volatile T *obj, R(T::*method)(ArgTs...) const volatile, ArgTs... args)
{
- return call(mbed::callback(obj, method), a0, a1, a2, a3, a4);
+ return call(mbed::callback(obj, method), args...);
}
/** Calls an event on the queue after a specified delay
@@ -938,2452 +714,459 @@ class EventQueue : private mbed::NonCopyable<EventQueue> {
* @see EventQueue::call_in
* @param ms Time to delay in milliseconds
* @param f Function to execute in the context of the dispatch loop
- * @param a0 Argument to pass to the callback
- */
- template <typename F, typename A0>
- int call_in(int ms, F f, A0 a0)
- {
- return call_in(ms, context10<F, A0>(f, a0));
- }
-
- /** Calls an event on the queue after a specified delay
- * @see EventQueue::call_in
- * @param ms Time to delay in milliseconds
- * @param f Function to execute in the context of the dispatch loop
- * @param a0,a1 Arguments to pass to the callback
+ * @param args Arguments to pass to the callback
*/
- template <typename F, typename A0, typename A1>
- int call_in(int ms, F f, A0 a0, A1 a1)
+ template <typename F, typename... ArgTs>
+ int call_in(int ms, F f, ArgTs... args)
{
- return call_in(ms, context20<F, A0, A1>(f, a0, a1));
+ return call_in(ms, context<F, ArgTs...>(f, args...));
}
/** Calls an event on the queue after a specified delay
- * @see EventQueue::call_in
- * @param ms Time to delay in milliseconds
- * @param f Function to execute in the context of the dispatch loop
- * @param a0,a1,a2 Arguments to pass to the callback
+ * @see EventQueue::call_in
*/
- template <typename F, typename A0, typename A1, typename A2>
- int call_in(int ms, F f, A0 a0, A1 a1, A2 a2)
+ template <typename T, typename R, typename... ArgTs>
+ int call_in(int ms, T *obj, R(T::*method)(ArgTs...), ArgTs... args)
{
- return call_in(ms, context30<F, A0, A1, A2>(f, a0, a1, a2));
+ return call_in(ms, mbed::callback(obj, method), args...);
}
/** Calls an event on the queue after a specified delay
- * @see EventQueue::call_in
- * @param ms Time to delay in milliseconds
- * @param f Function to execute in the context of the dispatch loop
- * @param a0,a1,a2,a3 Arguments to pass to the callback
+ * @see EventQueue::call_in
*/
- 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 T, typename R, typename... ArgTs>
+ int call_in(int ms, const T *obj, R(T::*method)(ArgTs...) const, ArgTs... args)
{
- return call_in(ms, context40<F, A0, A1, A2, A3>(f, a0, a1, a2, a3));
+ return call_in(ms, mbed::callback(obj, method), args...);
}
/** Calls an event on the queue after a specified delay
- * @see EventQueue::call_in
- * @param ms Time to delay in milliseconds
- * @param f Function to execute in the context of the dispatch loop
- * @param a0,a1,a2,a3,a4 Arguments to pass to the callback
+ * @see EventQueue::call_in
*/
- 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, typename... ArgTs>
+ int call_in(int ms, volatile T *obj, R(T::*method)(ArgTs...) volatile, ArgTs... args)
{
- return call_in(ms, context50<F, A0, A1, A2, A3, A4>(f, a0, a1, a2, a3, a4));
+ return call_in(ms, mbed::callback(obj, method), args...);
}
/** Calls an event on the queue after a specified delay
* @see EventQueue::call_in
*/
- template <typename T, typename R>
- int call_in(int ms, T *obj, R(T::*method)())
+ template <typename T, typename R, typename... ArgTs>
+ int call_in(int ms, const volatile T *obj, R(T::*method)(ArgTs...) const volatile, ArgTs... args)
{
- return call_in(ms, mbed::callback(obj, method));
+ return call_in(ms, mbed::callback(obj, method), args...);
}
- /** Calls an event on the queue after a specified delay
- * @see EventQueue::call_in
+ /** Calls an event on the queue periodically
+ *
+ * @note The first call_every event occurs after the specified delay.
+ * To create a periodic event that fires immediately, @see Event.
+ *
+ * The specified callback will be executed in the context of the event
+ * queue's dispatch loop.
+ *
+ * The call_every function is IRQ safe and can act as a mechanism for
+ * moving events out of IRQ contexts.
+ *
+ * @param f Function to execute in the context of the dispatch loop
+ * @param ms Period of the event in milliseconds
+ * @return A unique id that represents the posted event and can
+ * be passed to cancel, or an id of 0 if there is not
+ * enough memory to allocate the event.
*/
- template <typename T, typename R>
- int call_in(int ms, const T *obj, R(T::*method)() const)
+ template <typename F>
+ int call_every(int ms, F f)
{
- return call_in(ms, mbed::callback(obj, method));
+ void *p = equeue_alloc(&_equeue, sizeof(F));
+ if (!p) {
+ return 0;
+ }
+
+ F *e = new (p) F(f);
+ equeue_event_delay(e, ms);
+ equeue_event_period(e, ms);
+ equeue_event_dtor(e, &EventQueue::function_dtor<F>);
+ return equeue_post(&_equeue, &EventQueue::function_call<F>, e);
}
- /** Calls an event on the queue after a specified delay
- * @see EventQueue::call_in
+ /** Calls an event on the queue periodically
+ * @see EventQueue::call_every
+ * @param f Function to execute in the context of the dispatch loop
+ * @param args Arguments to pass to the callback
+ * @param ms Period of the event in milliseconds
*/
- template <typename T, typename R>
- int call_in(int ms, volatile T *obj, R(T::*method)() volatile)
+ template <typename F, typename... ArgTs>
+ int call_every(int ms, F f, ArgTs... args)
{
- return call_in(ms, mbed::callback(obj, method));
+ return call_every(ms, context<F, ArgTs...>(f, args...));
}
- /** Calls an event on the queue after a specified delay
- * @see EventQueue::call_in
+ /** Calls an event on the queue periodically
+ * @see EventQueue::call_every
*/
- 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... ArgTs>
+ int call_every(int ms, T *obj, R(T::*method)(ArgTs...), ArgTs... args)
{
- return call_in(ms, mbed::callback(obj, method));
+ return call_every(ms, mbed::callback(obj, method), args...);
}
- /** Calls an event on the queue after a specified delay
- * @see EventQueue::call_in
+ /** Calls an event on the queue periodically
+ * @see EventQueue::call_every
*/
- 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... ArgTs>
+ int call_every(int ms, const T *obj, R(T::*method)(ArgTs...) const, ArgTs... args)
{
- return call_in(ms, mbed::callback(obj, method), a0);
+ return call_every(ms, mbed::callback(obj, method), args...);
}
- /** Calls an event on the queue after a specified delay
- * @see EventQueue::call_in
+ /** Calls an event on the queue periodically
+ * @see EventQueue::call_every
*/
- 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... ArgTs>
+ int call_every(int ms, volatile T *obj, R(T::*method)(ArgTs...) volatile, ArgTs... args)
{
- return call_in(ms, mbed::callback(obj, method), a0);
+ return call_every(ms, mbed::callback(obj, method), args...);
}
- /** Calls an event on the queue after a specified delay
- * @see EventQueue::call_in
+ /** Calls an event on the queue periodically
+ * @see EventQueue::call_every
*/
- 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... ArgTs>
+ int call_every(int ms, const volatile T *obj, R(T::*method)(ArgTs...) const volatile, ArgTs... args)
{
- return call_in(ms, mbed::callback(obj, method), a0);
+ return call_every(ms, mbed::callback(obj, method), args...);
}
- /** Calls an event on the queue after a specified delay
- * @see EventQueue::call_in
+ /** Creates an event bound to the event queue
+ *
+ * Constructs an event bound to the specified event queue. The specified
+ * callback acts as the target for the event and is executed in the
+ * context of the event queue's dispatch loop once posted.
+ *
+ * @param func Function to execute when the event is dispatched
+ * @return Event that will dispatch on the specific queue
*/
- template <typename T, typename R, typename A0>
- int call_in(int ms, const volatile T *obj, R(T::*method)(A0) const volatile, A0 a0)
- {
- return call_in(ms, mbed::callback(obj, method), a0);
- }
+ template <typename R, typename... ArgTs>
+ Event<void(ArgTs...)> event(R(*func)(ArgTs...));
- /** Calls an event on the queue after a specified delay
- * @see EventQueue::call_in
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
*/
- 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)
- {
- return call_in(ms, mbed::callback(obj, method), a0, a1);
- }
+ template <typename T, typename R, typename... ArgTs>
+ Event<void(ArgTs...)> event(T *obj, R(T::*method)(ArgTs...));
- /** Calls an event on the queue after a specified delay
- * @see EventQueue::call_in
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
*/
- 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)
- {
- return call_in(ms, mbed::callback(obj, method), a0, a1);
- }
+ template <typename T, typename R, typename... ArgTs>
+ Event<void(ArgTs...)> event(const T *obj, R(T::*method)(ArgTs...) const);
- /** Calls an event on the queue after a specified delay
- * @see EventQueue::call_in
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
*/
- 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)
- {
- return call_in(ms, mbed::callback(obj, method), a0, a1);
- }
+ template <typename T, typename R, typename... ArgTs>
+ Event<void(ArgTs...)> event(volatile T *obj, R(T::*method)(ArgTs...) volatile);
- /** Calls an event on the queue after a specified delay
- * @see EventQueue::call_in
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
*/
- 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)
- {
- return call_in(ms, mbed::callback(obj, method), a0, a1);
- }
+ template <typename T, typename R, typename... ArgTs>
+ Event<void(ArgTs...)> event(const volatile T *obj, R(T::*method)(ArgTs...) const volatile);
- /** Calls an event on the queue after a specified delay
- * @see EventQueue::call_in
- */
- 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)
- {
- return call_in(ms, mbed::callback(obj, method), a0, a1, a2);
- }
-
- /** Calls an event on the queue after a specified delay
- * @see EventQueue::call_in
- */
- 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)
- {
- return call_in(ms, mbed::callback(obj, method), a0, a1, a2);
- }
-
- /** Calls an event on the queue after a specified delay
- * @see EventQueue::call_in
- */
- 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)
- {
- return call_in(ms, mbed::callback(obj, method), a0, a1, a2);
- }
-
- /** Calls an event on the queue after a specified delay
- * @see EventQueue::call_in
- */
- 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)
- {
- return call_in(ms, mbed::callback(obj, method), a0, a1, a2);
- }
-
- /** Calls an event on the queue after a specified delay
- * @see EventQueue::call_in
- */
- 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)
- {
- return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3);
- }
-
- /** Calls an event on the queue after a specified delay
- * @see EventQueue::call_in
- */
- 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)
- {
- return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3);
- }
-
- /** Calls an event on the queue after a specified delay
- * @see EventQueue::call_in
- */
- 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)
- {
- return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3);
- }
-
- /** Calls an event on the queue after a specified delay
- * @see EventQueue::call_in
- */
- 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)
- {
- return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3);
- }
-
- /** Calls an event on the queue after a specified delay
- * @see EventQueue::call_in
- */
- 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)
- {
- return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4);
- }
-
- /** Calls an event on the queue after a specified delay
- * @see EventQueue::call_in
- */
- 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)
- {
- return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4);
- }
-
- /** Calls an event on the queue after a specified delay
- * @see EventQueue::call_in
- */
- 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)
- {
- return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4);
- }
-
- /** Calls an event on the queue after a specified delay
- * @see EventQueue::call_in
- */
- 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)
- {
- return call_in(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4);
- }
-
- /** Calls an event on the queue periodically
- *
- * @note The first call_every event occurs after the specified delay.
- * To create a periodic event that fires immediately, @see Event.
- *
- * The specified callback will be executed in the context of the event
- * queue's dispatch loop.
- *
- * The call_every function is IRQ safe and can act as a mechanism for
- * moving events out of IRQ contexts.
- *
- * @param f Function to execute in the context of the dispatch loop
- * @param ms Period of the event in milliseconds
- * @return A unique id that represents the posted event and can
- * be passed to cancel, or an id of 0 if there is not
- * enough memory to allocate the event.
- */
- template <typename F>
- int call_every(int ms, F f)
- {
- void *p = equeue_alloc(&_equeue, sizeof(F));
- if (!p) {
- return 0;
- }
-
- F *e = new (p) F(f);
- equeue_event_delay(e, ms);
- equeue_event_period(e, ms);
- equeue_event_dtor(e, &EventQueue::function_dtor<F>);
- return equeue_post(&_equeue, &EventQueue::function_call<F>, e);
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- * @param f Function to execute in the context of the dispatch loop
- * @param a0 Argument to pass to the callback
- * @param ms Period of the event in milliseconds
- */
- template <typename F, typename A0>
- int call_every(int ms, F f, A0 a0)
- {
- return call_every(ms, context10<F, A0>(f, a0));
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- * @param f Function to execute in the context of the dispatch loop
- * @param a0,a1 Arguments to pass to the callback
- * @param ms Period of the event in milliseconds
- */
- template <typename F, typename A0, typename A1>
- int call_every(int ms, F f, A0 a0, A1 a1)
- {
- return call_every(ms, context20<F, A0, A1>(f, a0, a1));
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- * @param f Function to execute in the context of the dispatch loop
- * @param a0,a1,a2 Arguments to pass to the callback
- * @param ms Period of the event in milliseconds
- */
- template <typename F, typename A0, typename A1, typename A2>
- int call_every(int ms, F f, A0 a0, A1 a1, A2 a2)
- {
- return call_every(ms, context30<F, A0, A1, A2>(f, a0, a1, a2));
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- * @param f Function to execute in the context of the dispatch loop
- * @param a0,a1,a2,a3 Arguments to pass to the callback
- * @param ms Period of the event in milliseconds
- */
- 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)
- {
- return call_every(ms, context40<F, A0, A1, A2, A3>(f, a0, a1, a2, a3));
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- * @param f Function to execute in the context of the dispatch loop
- * @param a0,a1,a2,a3,a4 Arguments to pass to the callback
- * @param ms Period of the event in milliseconds
- */
- 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)
- {
- return call_every(ms, context50<F, A0, A1, A2, A3, A4>(f, a0, a1, a2, a3, a4));
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- */
- template <typename T, typename R>
- int call_every(int ms, T *obj, R(T::*method)())
- {
- return call_every(ms, mbed::callback(obj, method));
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- */
- template <typename T, typename R>
- int call_every(int ms, const T *obj, R(T::*method)() const)
- {
- return call_every(ms, mbed::callback(obj, method));
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- */
- template <typename T, typename R>
- int call_every(int ms, volatile T *obj, R(T::*method)() volatile)
- {
- return call_every(ms, mbed::callback(obj, method));
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- */
- template <typename T, typename R>
- int call_every(int ms, const volatile T *obj, R(T::*method)() const volatile)
- {
- return call_every(ms, mbed::callback(obj, method));
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- */
- template <typename T, typename R, typename A0>
- int call_every(int ms, T *obj, R(T::*method)(A0), A0 a0)
- {
- return call_every(ms, mbed::callback(obj, method), a0);
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- */
- template <typename T, typename R, typename A0>
- int call_every(int ms, const T *obj, R(T::*method)(A0) const, A0 a0)
- {
- return call_every(ms, mbed::callback(obj, method), a0);
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- */
- template <typename T, typename R, typename A0>
- int call_every(int ms, volatile T *obj, R(T::*method)(A0) volatile, A0 a0)
- {
- return call_every(ms, mbed::callback(obj, method), a0);
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- */
- template <typename T, typename R, typename A0>
- int call_every(int ms, const volatile T *obj, R(T::*method)(A0) const volatile, A0 a0)
- {
- return call_every(ms, mbed::callback(obj, method), a0);
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- */
- 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)
- {
- return call_every(ms, mbed::callback(obj, method), a0, a1);
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- */
- 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)
- {
- return call_every(ms, mbed::callback(obj, method), a0, a1);
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- */
- 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)
- {
- return call_every(ms, mbed::callback(obj, method), a0, a1);
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- */
- 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)
- {
- return call_every(ms, mbed::callback(obj, method), a0, a1);
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- */
- 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)
- {
- return call_every(ms, mbed::callback(obj, method), a0, a1, a2);
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- */
- 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)
- {
- return call_every(ms, mbed::callback(obj, method), a0, a1, a2);
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- */
- 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)
- {
- return call_every(ms, mbed::callback(obj, method), a0, a1, a2);
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- */
- 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)
- {
- return call_every(ms, mbed::callback(obj, method), a0, a1, a2);
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- */
- 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)
- {
- return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3);
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- */
- 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)
- {
- return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3);
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- */
- 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)
- {
- return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3);
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- */
- 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)
- {
- return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3);
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- */
- 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)
- {
- return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4);
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- */
- 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)
- {
- return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4);
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- */
- 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)
- {
- return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4);
- }
-
- /** Calls an event on the queue periodically
- * @see EventQueue::call_every
- */
- 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)
- {
- return call_every(ms, mbed::callback(obj, method), a0, a1, a2, a3, a4);
- }
-
- /** Creates an event bound to the event queue
- *
- * Constructs an event bound to the specified event queue. The specified
- * callback acts as the target for the event and is executed in the
- * context of the event queue's dispatch loop once posted.
- *
- * @param func Function to execute when the event is dispatched
- * @return Event that will dispatch on the specific queue
- */
- template <typename R>
- Event<void()> event(R(*func)());
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R>
- Event<void()> event(T *obj, R(T::*method)());
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R>
- Event<void()> event(const T *obj, R(T::*method)() const);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R>
- Event<void()> event(volatile T *obj, R(T::*method)() volatile);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R>
- Event<void()> event(const volatile T *obj, R(T::*method)() const volatile);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R>
- Event<void()> event(mbed::Callback<R()> cb);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename C0>
- Event<void()> event(R(*func)(B0), C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename C0>
- Event<void()> event(T *obj, R(T::*method)(B0), C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename C0>
- Event<void()> event(const T *obj, R(T::*method)(B0) const, C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename C0>
- Event<void()> event(volatile T *obj, R(T::*method)(B0) volatile, C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename C0>
- Event<void()> event(const volatile T *obj, R(T::*method)(B0) const volatile, C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename C0>
- Event<void()> event(mbed::Callback<R(B0)> cb, C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename C0, typename C1>
- Event<void()> event(R(*func)(B0, B1), C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename C0, typename C1>
- Event<void()> event(T *obj, R(T::*method)(B0, B1), C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename C0, typename C1>
- Event<void()> event(const T *obj, R(T::*method)(B0, B1) const, C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename C0, typename C1>
- Event<void()> event(volatile T *obj, R(T::*method)(B0, B1) volatile, C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename C0, typename C1>
- Event<void()> event(const volatile T *obj, R(T::*method)(B0, B1) const volatile, C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename C0, typename C1>
- Event<void()> event(mbed::Callback<R(B0, B1)> cb, C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
- Event<void()> event(R(*func)(B0, B1, B2), C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
- Event<void()> event(T *obj, R(T::*method)(B0, B1, B2), C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
- Event<void()> event(const T *obj, R(T::*method)(B0, B1, B2) const, C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
- Event<void()> event(volatile T *obj, R(T::*method)(B0, B1, B2) volatile, C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
- Event<void()> event(const volatile T *obj, R(T::*method)(B0, B1, B2) const volatile, C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
- Event<void()> event(mbed::Callback<R(B0, B1, B2)> cb, C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
- Event<void()> event(R(*func)(B0, B1, B2, B3), C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
- Event<void()> event(T *obj, R(T::*method)(B0, B1, B2, B3), C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
- Event<void()> event(const T *obj, R(T::*method)(B0, B1, B2, B3) const, C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
- Event<void()> event(volatile T *obj, R(T::*method)(B0, B1, B2, B3) volatile, C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
- Event<void()> event(const volatile T *obj, R(T::*method)(B0, B1, B2, B3) const volatile, C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
- Event<void()> event(mbed::Callback<R(B0, B1, B2, B3)> cb, C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4>
- Event<void()> event(R(*func)(B0, B1, B2, B3, B4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4>
- Event<void()> event(T *obj, R(T::*method)(B0, B1, B2, B3, B4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4>
- Event<void()> event(const T *obj, R(T::*method)(B0, B1, B2, B3, B4) const, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4>
- Event<void()> event(volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4) volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4>
- Event<void()> event(const volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4) const volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4>
- Event<void()> event(mbed::Callback<R(B0, B1, B2, B3, B4)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename A0>
- Event<void(A0)> event(R(*func)(A0));
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename A0>
- Event<void(A0)> event(T *obj, R(T::*method)(A0));
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename A0>
- Event<void(A0)> event(const T *obj, R(T::*method)(A0) const);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename A0>
- Event<void(A0)> event(volatile T *obj, R(T::*method)(A0) volatile);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename A0>
- Event<void(A0)> event(const volatile T *obj, R(T::*method)(A0) const volatile);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename A0>
- Event<void(A0)> event(mbed::Callback<R(A0)> cb);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename C0, typename A0>
- Event<void(A0)> event(R(*func)(B0, A0), C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename C0, typename A0>
- Event<void(A0)> event(T *obj, R(T::*method)(B0, A0), C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename C0, typename A0>
- Event<void(A0)> event(const T *obj, R(T::*method)(B0, A0) const, C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename C0, typename A0>
- Event<void(A0)> event(volatile T *obj, R(T::*method)(B0, A0) volatile, C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename C0, typename A0>
- Event<void(A0)> event(const volatile T *obj, R(T::*method)(B0, A0) const volatile, C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename C0, typename A0>
- Event<void(A0)> event(mbed::Callback<R(B0, A0)> cb, C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
- Event<void(A0)> event(R(*func)(B0, B1, A0), C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
- Event<void(A0)> event(T *obj, R(T::*method)(B0, B1, A0), C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
- Event<void(A0)> event(const T *obj, R(T::*method)(B0, B1, A0) const, C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
- Event<void(A0)> event(volatile T *obj, R(T::*method)(B0, B1, A0) volatile, C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
- Event<void(A0)> event(const volatile T *obj, R(T::*method)(B0, B1, A0) const volatile, C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
- Event<void(A0)> event(mbed::Callback<R(B0, B1, A0)> cb, C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
- Event<void(A0)> event(R(*func)(B0, B1, B2, A0), C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
- Event<void(A0)> event(T *obj, R(T::*method)(B0, B1, B2, A0), C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
- Event<void(A0)> event(const T *obj, R(T::*method)(B0, B1, B2, A0) const, C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
- Event<void(A0)> event(volatile T *obj, R(T::*method)(B0, B1, B2, A0) volatile, C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
- Event<void(A0)> event(const volatile T *obj, R(T::*method)(B0, B1, B2, A0) const volatile, C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
- Event<void(A0)> event(mbed::Callback<R(B0, B1, B2, A0)> cb, C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
- Event<void(A0)> event(R(*func)(B0, B1, B2, B3, A0), C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
- Event<void(A0)> event(T *obj, R(T::*method)(B0, B1, B2, B3, A0), C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
- Event<void(A0)> event(const T *obj, R(T::*method)(B0, B1, B2, B3, A0) const, C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
- Event<void(A0)> event(volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0) volatile, C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
- Event<void(A0)> event(const volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0) const volatile, C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
- Event<void(A0)> event(mbed::Callback<R(B0, B1, B2, B3, A0)> cb, C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0>
- Event<void(A0)> event(R(*func)(B0, B1, B2, B3, B4, A0), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0>
- Event<void(A0)> event(T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0>
- Event<void(A0)> event(const T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0) const, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0>
- Event<void(A0)> event(volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0) volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0>
- Event<void(A0)> event(const volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0) const volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0>
- Event<void(A0)> event(mbed::Callback<R(B0, B1, B2, B3, B4, A0)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename A0, typename A1>
- Event<void(A0, A1)> event(R(*func)(A0, A1));
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename A0, typename A1>
- Event<void(A0, A1)> event(T *obj, R(T::*method)(A0, A1));
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename A0, typename A1>
- Event<void(A0, A1)> event(const T *obj, R(T::*method)(A0, A1) const);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename A0, typename A1>
- Event<void(A0, A1)> event(volatile T *obj, R(T::*method)(A0, A1) volatile);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename A0, typename A1>
- Event<void(A0, A1)> event(const volatile T *obj, R(T::*method)(A0, A1) const volatile);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename A0, typename A1>
- Event<void(A0, A1)> event(mbed::Callback<R(A0, A1)> cb);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename C0, typename A0, typename A1>
- Event<void(A0, A1)> event(R(*func)(B0, A0, A1), C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename C0, typename A0, typename A1>
- Event<void(A0, A1)> event(T *obj, R(T::*method)(B0, A0, A1), C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename C0, typename A0, typename A1>
- Event<void(A0, A1)> event(const T *obj, R(T::*method)(B0, A0, A1) const, C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename C0, typename A0, typename A1>
- Event<void(A0, A1)> event(volatile T *obj, R(T::*method)(B0, A0, A1) volatile, C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename C0, typename A0, typename A1>
- Event<void(A0, A1)> event(const volatile T *obj, R(T::*method)(B0, A0, A1) const volatile, C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename C0, typename A0, typename A1>
- Event<void(A0, A1)> event(mbed::Callback<R(B0, A0, A1)> cb, C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
- Event<void(A0, A1)> event(R(*func)(B0, B1, A0, A1), C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
- Event<void(A0, A1)> event(T *obj, R(T::*method)(B0, B1, A0, A1), C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
- Event<void(A0, A1)> event(const T *obj, R(T::*method)(B0, B1, A0, A1) const, C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
- Event<void(A0, A1)> event(volatile T *obj, R(T::*method)(B0, B1, A0, A1) volatile, C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
- Event<void(A0, A1)> event(const volatile T *obj, R(T::*method)(B0, B1, A0, A1) const volatile, C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
- Event<void(A0, A1)> event(mbed::Callback<R(B0, B1, A0, A1)> cb, C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
- Event<void(A0, A1)> event(R(*func)(B0, B1, B2, A0, A1), C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
- Event<void(A0, A1)> event(T *obj, R(T::*method)(B0, B1, B2, A0, A1), C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
- Event<void(A0, A1)> event(const T *obj, R(T::*method)(B0, B1, B2, A0, A1) const, C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
- Event<void(A0, A1)> event(volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1) volatile, C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
- Event<void(A0, A1)> event(const volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1) const volatile, C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
- Event<void(A0, A1)> event(mbed::Callback<R(B0, B1, B2, A0, A1)> cb, C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1>
- Event<void(A0, A1)> event(R(*func)(B0, B1, B2, B3, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1>
- Event<void(A0, A1)> event(T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1>
- Event<void(A0, A1)> event(const T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1) const, C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1>
- Event<void(A0, A1)> event(volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1) volatile, C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1>
- Event<void(A0, A1)> event(const volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1) const volatile, C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1>
- Event<void(A0, A1)> event(mbed::Callback<R(B0, B1, B2, B3, A0, A1)> cb, C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1>
- Event<void(A0, A1)> event(R(*func)(B0, B1, B2, B3, B4, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1>
- Event<void(A0, A1)> event(T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1>
- Event<void(A0, A1)> event(const T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1) const, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1>
- Event<void(A0, A1)> event(volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1) volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1>
- Event<void(A0, A1)> event(const volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1) const volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1>
- Event<void(A0, A1)> event(mbed::Callback<R(B0, B1, B2, B3, B4, A0, A1)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(R(*func)(A0, A1, A2));
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(T *obj, R(T::*method)(A0, A1, A2));
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(const T *obj, R(T::*method)(A0, A1, A2) const);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(volatile T *obj, R(T::*method)(A0, A1, A2) volatile);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(const volatile T *obj, R(T::*method)(A0, A1, A2) const volatile);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(mbed::Callback<R(A0, A1, A2)> cb);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(R(*func)(B0, A0, A1, A2), C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(T *obj, R(T::*method)(B0, A0, A1, A2), C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(const T *obj, R(T::*method)(B0, A0, A1, A2) const, C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(volatile T *obj, R(T::*method)(B0, A0, A1, A2) volatile, C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(const volatile T *obj, R(T::*method)(B0, A0, A1, A2) const volatile, C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(mbed::Callback<R(B0, A0, A1, A2)> cb, C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(R(*func)(B0, B1, A0, A1, A2), C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(T *obj, R(T::*method)(B0, B1, A0, A1, A2), C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(const T *obj, R(T::*method)(B0, B1, A0, A1, A2) const, C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(volatile T *obj, R(T::*method)(B0, B1, A0, A1, A2) volatile, C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(const volatile T *obj, R(T::*method)(B0, B1, A0, A1, A2) const volatile, C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(mbed::Callback<R(B0, B1, A0, A1, A2)> cb, C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(R(*func)(B0, B1, B2, A0, A1, A2), C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2), C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(const T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2) const, C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2) volatile, C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(const volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2) const volatile, C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(mbed::Callback<R(B0, B1, B2, A0, A1, A2)> cb, C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(R(*func)(B0, B1, B2, B3, A0, A1, A2), C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2), C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(const T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2) const, C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2) volatile, C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(const volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2) const volatile, C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(mbed::Callback<R(B0, B1, B2, B3, A0, A1, A2)> cb, C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(R(*func)(B0, B1, B2, B3, B4, A0, A1, A2), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(const T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2) const, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2) volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(const volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2) const volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2>
- Event<void(A0, A1, A2)> event(mbed::Callback<R(B0, B1, B2, B3, B4, A0, A1, A2)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(R(*func)(A0, A1, A2, A3));
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(T *obj, R(T::*method)(A0, A1, A2, A3));
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(const T *obj, R(T::*method)(A0, A1, A2, A3) const);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(volatile T *obj, R(T::*method)(A0, A1, A2, A3) volatile);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R(T::*method)(A0, A1, A2, A3) const volatile);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(A0, A1, A2, A3)> cb);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(R(*func)(B0, A0, A1, A2, A3), C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(T *obj, R(T::*method)(B0, A0, A1, A2, A3), C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(const T *obj, R(T::*method)(B0, A0, A1, A2, A3) const, C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(volatile T *obj, R(T::*method)(B0, A0, A1, A2, A3) volatile, C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R(T::*method)(B0, A0, A1, A2, A3) const volatile, C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(B0, A0, A1, A2, A3)> cb, C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(R(*func)(B0, B1, A0, A1, A2, A3), C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3), C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(const T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3) const, C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(volatile T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3) volatile, C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3) const volatile, C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(B0, B1, A0, A1, A2, A3)> cb, C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(R(*func)(B0, B1, B2, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(const T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3) const, C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3) volatile, C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3) const volatile, C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(B0, B1, B2, A0, A1, A2, A3)> cb, C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(R(*func)(B0, B1, B2, B3, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(const T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3) const, C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3) volatile, C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3) const volatile, C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(B0, B1, B2, B3, A0, A1, A2, A3)> cb, C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(R(*func)(B0, B1, B2, B3, B4, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(const T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3) const, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3) volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3) const volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3>
- Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(B0, B1, B2, B3, B4, A0, A1, A2, A3)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(R(*func)(A0, A1, A2, A3, A4));
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(T *obj, R(T::*method)(A0, A1, A2, A3, A4));
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(const T *obj, R(T::*method)(A0, A1, A2, A3, A4) const);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(volatile T *obj, R(T::*method)(A0, A1, A2, A3, A4) volatile);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(const volatile T *obj, R(T::*method)(A0, A1, A2, A3, A4) const volatile);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(A0, A1, A2, A3, A4)> cb);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(R(*func)(B0, A0, A1, A2, A3, A4), C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(T *obj, R(T::*method)(B0, A0, A1, A2, A3, A4), C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(const T *obj, R(T::*method)(B0, A0, A1, A2, A3, A4) const, C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(volatile T *obj, R(T::*method)(B0, A0, A1, A2, A3, A4) volatile, C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(const volatile T *obj, R(T::*method)(B0, A0, A1, A2, A3, A4) const volatile, C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(B0, A0, A1, A2, A3, A4)> cb, C0 c0);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(R(*func)(B0, B1, A0, A1, A2, A3, A4), C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3, A4), C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(const T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3, A4) const, C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(volatile T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3, A4) volatile, C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(const volatile T *obj, R(T::*method)(B0, B1, A0, A1, A2, A3, A4) const volatile, C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(B0, B1, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(R(*func)(B0, B1, B2, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(const T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3, A4) const, C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3, A4) volatile, C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(const volatile T *obj, R(T::*method)(B0, B1, B2, A0, A1, A2, A3, A4) const volatile, C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(B0, B1, B2, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1, C2 c2);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(R(*func)(B0, B1, B2, B3, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(const T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3, A4) const, C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3, A4) volatile, C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(const volatile T *obj, R(T::*method)(B0, B1, B2, B3, A0, A1, A2, A3, A4) const volatile, C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(B0, B1, B2, B3, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1, C2 c2, C3 c3);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(R(*func)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(const T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4) const, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4) volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3, typename A4>
- Event<void(A0, A1, A2, A3, A4)> event(const volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4) const volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
-
- /** Creates an event bound to the event queue
- * @see EventQueue::event
- */
- 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);
-#endif
-
-protected:
-#if !defined(DOXYGEN_ONLY)
- template <typename F>
- friend class Event;
- struct equeue _equeue;
- mbed::Callback<void(int)> _update;
-
- // Function attributes
- template <typename F>
- static void function_call(void *p)
- {
- (*(F *)p)();
- }
-
- template <typename F>
- static void function_dtor(void *p)
- {
- ((F *)p)->~F();
- }
-
- // Context structures
- template <typename F>
- struct context00 {
- F f;
-
- context00(F f)
- : f(f) {}
-
- void operator()()
- {
- f();
- }
- };
-
- template <typename F, typename C0>
- struct context10 {
- F f;
- C0 c0;
-
- context10(F f, C0 c0)
- : f(f), c0(c0) {}
-
- void operator()()
- {
- f(c0);
- }
- };
-
- template <typename F, typename C0, typename C1>
- struct context20 {
- F f;
- C0 c0;
- C1 c1;
-
- context20(F f, C0 c0, C1 c1)
- : f(f), c0(c0), c1(c1) {}
-
- void operator()()
- {
- f(c0, c1);
- }
- };
-
- template <typename F, typename C0, typename C1, typename C2>
- struct context30 {
- F f;
- C0 c0;
- C1 c1;
- C2 c2;
-
- context30(F f, C0 c0, C1 c1, C2 c2)
- : f(f), c0(c0), c1(c1), c2(c2) {}
-
- void operator()()
- {
- f(c0, c1, c2);
- }
- };
-
- template <typename F, typename C0, typename C1, typename C2, typename C3>
- struct context40 {
- F f;
- C0 c0;
- C1 c1;
- C2 c2;
- C3 c3;
-
- context40(F f, C0 c0, C1 c1, C2 c2, C3 c3)
- : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {}
-
- void operator()()
- {
- f(c0, c1, c2, c3);
- }
- };
-
- template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4>
- struct context50 {
- F f;
- C0 c0;
- C1 c1;
- C2 c2;
- C3 c3;
- C4 c4;
-
- context50(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
- : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {}
-
- void operator()()
- {
- f(c0, c1, c2, c3, c4);
- }
- };
-
- template <typename F, typename A0>
- struct context01 {
- F f;
-
- context01(F f)
- : f(f) {}
-
- void operator()(A0 a0)
- {
- f(a0);
- }
- };
-
- template <typename F, typename C0, typename A0>
- struct context11 {
- F f;
- C0 c0;
-
- context11(F f, C0 c0)
- : f(f), c0(c0) {}
-
- void operator()(A0 a0)
- {
- f(c0, a0);
- }
- };
-
- template <typename F, typename C0, typename C1, typename A0>
- struct context21 {
- F f;
- C0 c0;
- C1 c1;
-
- context21(F f, C0 c0, C1 c1)
- : f(f), c0(c0), c1(c1) {}
-
- void operator()(A0 a0)
- {
- f(c0, c1, a0);
- }
- };
-
- template <typename F, typename C0, typename C1, typename C2, typename A0>
- struct context31 {
- F f;
- C0 c0;
- C1 c1;
- C2 c2;
-
- context31(F f, C0 c0, C1 c1, C2 c2)
- : f(f), c0(c0), c1(c1), c2(c2) {}
-
- void operator()(A0 a0)
- {
- f(c0, c1, c2, a0);
- }
- };
-
- template <typename F, typename C0, typename C1, typename C2, typename C3, typename A0>
- struct context41 {
- F f;
- C0 c0;
- C1 c1;
- C2 c2;
- C3 c3;
-
- context41(F f, C0 c0, C1 c1, C2 c2, C3 c3)
- : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {}
-
- void operator()(A0 a0)
- {
- f(c0, c1, c2, c3, a0);
- }
- };
-
- template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0>
- struct context51 {
- F f;
- C0 c0;
- C1 c1;
- C2 c2;
- C3 c3;
- C4 c4;
-
- context51(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
- : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {}
-
- void operator()(A0 a0)
- {
- f(c0, c1, c2, c3, c4, a0);
- }
- };
-
- template <typename F, typename A0, typename A1>
- struct context02 {
- F f;
-
- context02(F f)
- : f(f) {}
-
- void operator()(A0 a0, A1 a1)
- {
- f(a0, a1);
- }
- };
-
- template <typename F, typename C0, typename A0, typename A1>
- struct context12 {
- F f;
- C0 c0;
-
- context12(F f, C0 c0)
- : f(f), c0(c0) {}
-
- void operator()(A0 a0, A1 a1)
- {
- f(c0, a0, a1);
- }
- };
-
- template <typename F, typename C0, typename C1, typename A0, typename A1>
- struct context22 {
- F f;
- C0 c0;
- C1 c1;
-
- context22(F f, C0 c0, C1 c1)
- : f(f), c0(c0), c1(c1) {}
-
- void operator()(A0 a0, A1 a1)
- {
- f(c0, c1, a0, a1);
- }
- };
-
- template <typename F, typename C0, typename C1, typename C2, typename A0, typename A1>
- struct context32 {
- F f;
- C0 c0;
- C1 c1;
- C2 c2;
-
- context32(F f, C0 c0, C1 c1, C2 c2)
- : f(f), c0(c0), c1(c1), c2(c2) {}
-
- void operator()(A0 a0, A1 a1)
- {
- f(c0, c1, c2, a0, a1);
- }
- };
-
- template <typename F, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1>
- struct context42 {
- F f;
- C0 c0;
- C1 c1;
- C2 c2;
- C3 c3;
-
- context42(F f, C0 c0, C1 c1, C2 c2, C3 c3)
- : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {}
-
- void operator()(A0 a0, A1 a1)
- {
- f(c0, c1, c2, c3, a0, a1);
- }
- };
-
- template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1>
- struct context52 {
- F f;
- C0 c0;
- C1 c1;
- C2 c2;
- C3 c3;
- C4 c4;
-
- context52(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
- : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {}
-
- void operator()(A0 a0, A1 a1)
- {
- f(c0, c1, c2, c3, c4, a0, a1);
- }
- };
-
- template <typename F, typename A0, typename A1, typename A2>
- struct context03 {
- F f;
-
- context03(F f)
- : f(f) {}
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ template <typename R, typename... ArgTs>
+ Event<void(ArgTs...)> event(mbed::Callback<R(ArgTs...)> cb);
- void operator()(A0 a0, A1 a1, A2 a2)
- {
- f(a0, a1, a2);
- }
- };
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ template <typename R, typename B0, typename C0, typename... ArgTs>
+ Event<void(ArgTs...)> event(R(*func)(B0, ArgTs...), C0 c0);
- template <typename F, typename C0, typename A0, typename A1, typename A2>
- struct context13 {
- F f;
- C0 c0;
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ template <typename T, typename R, typename B0, typename C0, typename... ArgTs>
+ Event<void(ArgTs...)> event(T *obj, R(T::*method)(B0, ArgTs...), C0 c0);
- context13(F f, C0 c0)
- : f(f), c0(c0) {}
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ template <typename T, typename R, typename B0, typename C0, typename... ArgTs>
+ Event<void(ArgTs...)> event(const T *obj, R(T::*method)(B0, ArgTs...) const, C0 c0);
- void operator()(A0 a0, A1 a1, A2 a2)
- {
- f(c0, a0, a1, a2);
- }
- };
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ template <typename T, typename R, typename B0, typename C0, typename... ArgTs>
+ Event<void(ArgTs...)> event(volatile T *obj, R(T::*method)(B0, ArgTs...) volatile, C0 c0);
- template <typename F, typename C0, typename C1, typename A0, typename A1, typename A2>
- struct context23 {
- F f;
- C0 c0;
- C1 c1;
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ template <typename T, typename R, typename B0, typename C0, typename... ArgTs>
+ Event<void(ArgTs...)> event(const volatile T *obj, R(T::*method)(B0, ArgTs...) const volatile, C0 c0);
- context23(F f, C0 c0, C1 c1)
- : f(f), c0(c0), c1(c1) {}
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ template <typename R, typename B0, typename C0, typename... ArgTs>
+ Event<void(ArgTs...)> event(mbed::Callback<R(B0, ArgTs...)> cb, C0 c0);
- void operator()(A0 a0, A1 a1, A2 a2)
- {
- f(c0, c1, a0, a1, a2);
- }
- };
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ template <typename R, typename B0, typename B1, typename C0, typename C1, typename... ArgTs>
+ Event<void(ArgTs...)> event(R(*func)(B0, B1, ArgTs...), C0 c0, C1 c1);
- template <typename F, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
- struct context33 {
- F f;
- C0 c0;
- C1 c1;
- C2 c2;
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename... ArgTs>
+ Event<void(ArgTs...)> event(T *obj, R(T::*method)(B0, B1, ArgTs...), C0 c0, C1 c1);
- context33(F f, C0 c0, C1 c1, C2 c2)
- : f(f), c0(c0), c1(c1), c2(c2) {}
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename... ArgTs>
+ Event<void(ArgTs...)> event(const T *obj, R(T::*method)(B0, B1, ArgTs...) const, C0 c0, C1 c1);
- void operator()(A0 a0, A1 a1, A2 a2)
- {
- f(c0, c1, c2, a0, a1, a2);
- }
- };
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename... ArgTs>
+ Event<void(ArgTs...)> event(volatile T *obj, R(T::*method)(B0, B1, ArgTs...) volatile, C0 c0, C1 c1);
- template <typename F, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2>
- struct context43 {
- F f;
- C0 c0;
- C1 c1;
- C2 c2;
- C3 c3;
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename... ArgTs>
+ Event<void(ArgTs...)> event(const volatile T *obj, R(T::*method)(B0, B1, ArgTs...) const volatile, C0 c0, C1 c1);
- context43(F f, C0 c0, C1 c1, C2 c2, C3 c3)
- : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {}
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ template <typename R, typename B0, typename B1, typename C0, typename C1, typename... ArgTs>
+ Event<void(ArgTs...)> event(mbed::Callback<R(B0, B1, ArgTs...)> cb, C0 c0, C1 c1);
- void operator()(A0 a0, A1 a1, A2 a2)
- {
- f(c0, c1, c2, c3, a0, a1, a2);
- }
- };
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename... ArgTs>
+ Event<void(ArgTs...)> event(R(*func)(B0, B1, B2, ArgTs...), C0 c0, C1 c1, C2 c2);
- template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2>
- struct context53 {
- F f;
- C0 c0;
- C1 c1;
- C2 c2;
- C3 c3;
- C4 c4;
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename... ArgTs>
+ Event<void(ArgTs...)> event(T *obj, R(T::*method)(B0, B1, B2, ArgTs...), C0 c0, C1 c1, C2 c2);
- context53(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
- : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {}
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename... ArgTs>
+ Event<void(ArgTs...)> event(const T *obj, R(T::*method)(B0, B1, B2, ArgTs...) const, C0 c0, C1 c1, C2 c2);
- void operator()(A0 a0, A1 a1, A2 a2)
- {
- f(c0, c1, c2, c3, c4, a0, a1, a2);
- }
- };
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename... ArgTs>
+ Event<void(ArgTs...)> event(volatile T *obj, R(T::*method)(B0, B1, B2, ArgTs...) volatile, C0 c0, C1 c1, C2 c2);
- template <typename F, typename A0, typename A1, typename A2, typename A3>
- struct context04 {
- F f;
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename... ArgTs>
+ Event<void(ArgTs...)> event(const volatile T *obj, R(T::*method)(B0, B1, B2, ArgTs...) const volatile, C0 c0, C1 c1, C2 c2);
- context04(F f)
- : f(f) {}
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename... ArgTs>
+ Event<void(ArgTs...)> event(mbed::Callback<R(B0, B1, B2, ArgTs...)> cb, C0 c0, C1 c1, C2 c2);
- void operator()(A0 a0, A1 a1, A2 a2, A3 a3)
- {
- f(a0, a1, a2, a3);
- }
- };
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename... ArgTs>
+ Event<void(ArgTs...)> event(R(*func)(B0, B1, B2, B3, ArgTs...), C0 c0, C1 c1, C2 c2, C3 c3);
- template <typename F, typename C0, typename A0, typename A1, typename A2, typename A3>
- struct context14 {
- F f;
- C0 c0;
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename... ArgTs>
+ Event<void(ArgTs...)> event(T *obj, R(T::*method)(B0, B1, B2, B3, ArgTs...), C0 c0, C1 c1, C2 c2, C3 c3);
- context14(F f, C0 c0)
- : f(f), c0(c0) {}
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename... ArgTs>
+ Event<void(ArgTs...)> event(const T *obj, R(T::*method)(B0, B1, B2, B3, ArgTs...) const, C0 c0, C1 c1, C2 c2, C3 c3);
- void operator()(A0 a0, A1 a1, A2 a2, A3 a3)
- {
- f(c0, a0, a1, a2, a3);
- }
- };
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename... ArgTs>
+ Event<void(ArgTs...)> event(volatile T *obj, R(T::*method)(B0, B1, B2, B3, ArgTs...) volatile, C0 c0, C1 c1, C2 c2, C3 c3);
- template <typename F, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
- struct context24 {
- F f;
- C0 c0;
- C1 c1;
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename... ArgTs>
+ Event<void(ArgTs...)> event(const volatile T *obj, R(T::*method)(B0, B1, B2, B3, ArgTs...) const volatile, C0 c0, C1 c1, C2 c2, C3 c3);
- context24(F f, C0 c0, C1 c1)
- : f(f), c0(c0), c1(c1) {}
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename... ArgTs>
+ Event<void(ArgTs...)> event(mbed::Callback<R(B0, B1, B2, B3, ArgTs...)> cb, C0 c0, C1 c1, C2 c2, C3 c3);
- void operator()(A0 a0, A1 a1, A2 a2, A3 a3)
- {
- f(c0, c1, a0, a1, a2, a3);
- }
- };
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename... ArgTs>
+ Event<void(ArgTs...)> event(R(*func)(B0, B1, B2, B3, B4, ArgTs...), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
- template <typename F, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3>
- struct context34 {
- F f;
- C0 c0;
- C1 c1;
- C2 c2;
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ 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... ArgTs>
+ Event<void(ArgTs...)> event(T *obj, R(T::*method)(B0, B1, B2, B3, B4, ArgTs...), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
- context34(F f, C0 c0, C1 c1, C2 c2)
- : f(f), c0(c0), c1(c1), c2(c2) {}
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ 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... ArgTs>
+ Event<void(ArgTs...)> event(const T *obj, R(T::*method)(B0, B1, B2, B3, B4, ArgTs...) const, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
- void operator()(A0 a0, A1 a1, A2 a2, A3 a3)
- {
- f(c0, c1, c2, a0, a1, a2, a3);
- }
- };
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ 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... ArgTs>
+ Event<void(ArgTs...)> event(volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, ArgTs...) volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
- template <typename F, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3>
- struct context44 {
- F f;
- C0 c0;
- C1 c1;
- C2 c2;
- C3 c3;
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ 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... ArgTs>
+ Event<void(ArgTs...)> event(const volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, ArgTs...) const volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
- context44(F f, C0 c0, C1 c1, C2 c2, C3 c3)
- : f(f), c0(c0), c1(c1), c2(c2), c3(c3) {}
+ /** Creates an event bound to the event queue
+ * @see EventQueue::event
+ */
+ template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename... ArgTs>
+ Event<void(ArgTs...)> event(mbed::Callback<R(B0, B1, B2, B3, B4, ArgTs...)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
+#endif
- void operator()(A0 a0, A1 a1, A2 a2, A3 a3)
- {
- f(c0, c1, c2, c3, a0, a1, a2, a3);
- }
- };
+protected:
+#if !defined(DOXYGEN_ONLY)
+ template <typename F>
+ friend class Event;
+ struct equeue _equeue;
+ mbed::Callback<void(int)> _update;
- template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3>
- struct context54 {
- F f;
- C0 c0;
- C1 c1;
- C2 c2;
- C3 c3;
- C4 c4;
+ // Function attributes
+ template <typename F>
+ static void function_call(void *p)
+ {
+ (*(F *)p)();
+ }
- context54(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
- : f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {}
+ template <typename F>
+ static void function_dtor(void *p)
+ {
+ ((F *)p)->~F();
+ }
- void operator()(A0 a0, A1 a1, A2 a2, A3 a3)
- {
- f(c0, c1, c2, c3, c4, a0, a1, a2, a3);
- }
- };
+ // Context structures
+ template <typename F, typename... ContextArgTs>
+ struct context;
- template <typename F, typename A0, typename A1, typename A2, typename A3, typename A4>
- struct context05 {
+ template <typename F>
+ struct context<F> {
F f;
- context05(F f)
+ context(F f)
: f(f) {}
- void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4)
+ template <typename... ArgTs>
+ void operator()(ArgTs... args)
{
- f(a0, a1, a2, a3, a4);
+ f(args...);
}
};
- template <typename F, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
- struct context15 {
+ template <typename F, typename C0>
+ struct context<F, C0> {
F f;
C0 c0;
- context15(F f, C0 c0)
+ context(F f, C0 c0)
: f(f), c0(c0) {}
- void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4)
+ template <typename... ArgTs>
+ void operator()(ArgTs... args)
{
- f(c0, a0, a1, a2, a3, a4);
+ f(c0, args...);
}
};
- template <typename F, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
- struct context25 {
+ template <typename F, typename C0, typename C1>
+ struct context<F, C0, C1> {
F f;
C0 c0;
C1 c1;
- context25(F f, C0 c0, C1 c1)
+ context(F f, C0 c0, C1 c1)
: f(f), c0(c0), c1(c1) {}
- void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4)
+ template <typename... ArgTs>
+ void operator()(ArgTs... args)
{
- f(c0, c1, a0, a1, a2, a3, a4);
+ f(c0, c1, args...);
}
};
- template <typename F, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3, typename A4>
- struct context35 {
+ template <typename F, typename C0, typename C1, typename C2>
+ struct context<F, C0, C1, C2> {
F f;
C0 c0;
C1 c1;
C2 c2;
- context35(F f, C0 c0, C1 c1, C2 c2)
+ context(F f, C0 c0, C1 c1, C2 c2)
: f(f), c0(c0), c1(c1), c2(c2) {}
- void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4)
+ template <typename... ArgTs>
+ void operator()(ArgTs... args)
{
- f(c0, c1, c2, a0, a1, a2, a3, a4);
+ f(c0, c1, c2, args...);
}
};
- template <typename F, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3, typename A4>
- struct context45 {
+ template <typename F, typename C0, typename C1, typename C2, typename C3>
+ struct context<F, C0, C1, C2, C3> {
F f;
C0 c0;
C1 c1;
C2 c2;
C3 c3;
- context45(F f, C0 c0, C1 c1, C2 c2, C3 c3)
+ context(F f, C0 c0, C1 c1, C2 c2, C3 c3)
: f(f), c0(c0), c1(c1), c2(c2), c3(c3) {}
- void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4)
+ template <typename... ArgTs>
+ void operator()(ArgTs... args)
{
- f(c0, c1, c2, c3, a0, a1, a2, a3, a4);
+ f(c0, c1, c2, c3, args...);
}
};
- template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3, typename A4>
- struct context55 {
+ template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4>
+ struct context<F, C0, C1, C2, C3, C4> {
F f;
C0 c0;
C1 c1;
@@ -3391,12 +1174,13 @@ class EventQueue : private mbed::NonCopyable<EventQueue> {
C3 c3;
C4 c4;
- context55(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
+ context(F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
: f(f), c0(c0), c1(c1), c2(c2), c3(c3), c4(c4) {}
- void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4)
+ template <typename... ArgTs>
+ void operator()(ArgTs... args)
{
- f(c0, c1, c2, c3, c4, a0, a1, a2, a3, a4);
+ f(c0, c1, c2, c3, c4, args...);
}
};
#endif //!defined(DOXYGEN_ONLY)