ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Removed Doxygen errors from Event.h 

- Removed Makefile from branch
- Moved a0..a4/c0..c4 parameter documentation from top level overloaded functions to each function to appease Doxygen.
- Removed @see Event::Event from overloaded functions as the link did not work and the argument parameter documentation was moved down to each function
- TODO: Cleanup EventQueue.h
pull/4434/head
Kevin Gilbert 2017-06-02 14:28:08 -05:00
parent 744b95cc9f
commit 1d450f82fb
3 changed files with 215 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
doxyfile_options
View File

@ -840,7 +840,6 @@ EXCLUDE_PATTERNS = */tools/* \
*/TESTS/* \ */TESTS/* \
*/targets/* \ */targets/* \
*/BUILD/* \ */BUILD/* \
*/events/* \
*/rtos/* \ */rtos/* \
*/cmsis/* \ */cmsis/* \
*/hal/* \ */hal/* \

2
doxygen_options.json
View File

@ -8,5 +8,5 @@
"PREDEFINED": "DOXYGEN_ONLY \"MBED_DEPRECATED_SINCE(f, g)=\" \"MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, M)=\"", "PREDEFINED": "DOXYGEN_ONLY \"MBED_DEPRECATED_SINCE(f, g)=\" \"MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, M)=\"",
"EXPAND_AS_DEFINED": "", "EXPAND_AS_DEFINED": "",
"SKIP_FUNCTION_MACROS": "NO", "SKIP_FUNCTION_MACROS": "NO",
"EXCLUDE_PATTERNS": "*/tools/* */TESTS/* */targets/* */FEATURE_*/* */features/mbedtls/* */features/storage/* */features/unsupported/* */features/frameworks/* */features/filesystem/* */BUILD/* */rtos/* */events/* */cmsis/* */hal/* */features/FEATURES_*" "EXCLUDE_PATTERNS": "*/tools/* */TESTS/* */targets/* */FEATURE_*/* */features/mbedtls/* */features/storage/* */features/unsupported/* */features/frameworks/* */features/filesystem/* */BUILD/* */rtos/* */cmsis/* */hal/* */features/FEATURES_*"
} }

306
events/Event.h
View File

@ -44,12 +44,8 @@ public:
* callback acts as the target for the event and is executed in the * callback acts as the target for the event and is executed in the
* context of the event queue's dispatch loop once posted. * context of the event queue's dispatch loop once posted.
* *
* @param q Event queue to dispatch on * @param q Event queue to dispatch on
* @param f Function to execute when the event is dispatched * @param f Function to execute when the event is dispatched
* @param c0..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> template <typename F>
Event(EventQueue *q, F f) { Event(EventQueue *q, F f) {
@ -132,7 +128,6 @@ public:
* The post function is irq safe and can act as a mechanism for moving * The post function is irq safe and can act as a mechanism for moving
* events out of irq contexts. * events out of irq contexts.
* *
* @param a0..a4 Arguments to pass to the event
* @return A unique id that represents the posted event and can * @return A unique id that represents the posted event and can
* be passed to EventQueue::cancel, or an id of 0 if * be passed to EventQueue::cancel, or an id of 0 if
* there is not enough memory to allocate the event. * there is not enough memory to allocate the event.
@ -148,7 +143,6 @@ public:
/** Posts an event onto the underlying event queue, returning void /** Posts an event onto the underlying event queue, returning void
* *
* @param a0..a4 Arguments to pass to the event
*/ */
void call() const { void call() const {
MBED_UNUSED int id = post(); MBED_UNUSED int id = post();
@ -157,7 +151,6 @@ public:
/** Posts an event onto the underlying event queue, returning void /** Posts an event onto the underlying event queue, returning void
* *
* @param a0..a4 Arguments to pass to the event
*/ */
void operator()() const { void operator()() const {
return call(); return call();
@ -166,7 +159,6 @@ public:
/** Static thunk for passing as C-style function /** Static thunk for passing as C-style function
* *
* @param func Event to call passed as a void pointer * @param func Event to call passed as a void pointer
* @param a0..a4 Arguments to pass to the event
*/ */
static void thunk(void *func) { static void thunk(void *func) {
return static_cast<Event*>(func)->call(); return static_cast<Event*>(func)->call();
@ -227,7 +219,12 @@ private:
public: public:
/** Create an event /** Create an event
* @see Event::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> template <typename F, typename C0>
Event(EventQueue *q, F f, C0 c0) { Event(EventQueue *q, F f, C0 c0) {
@ -235,7 +232,12 @@ public:
} }
/** Create an event /** Create an event
* @see Event::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> template <typename F, typename C0, typename C1>
Event(EventQueue *q, F f, C0 c0, C1 c1) { Event(EventQueue *q, F f, C0 c0, C1 c1) {
@ -243,7 +245,12 @@ public:
} }
/** Create an event /** Create an event
* @see Event::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> template <typename F, typename C0, typename C1, typename C2>
Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2) { Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2) {
@ -251,7 +258,12 @@ public:
} }
/** Create an event /** Create an event
* @see Event::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> template <typename F, typename C0, typename C1, typename C2, typename C3>
Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3) { Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3) {
@ -259,7 +271,12 @@ public:
} }
/** Create an event /** Create an event
* @see Event::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> 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) { Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {
@ -443,10 +460,6 @@ public:
* *
* @param q Event queue to dispatch on * @param q Event queue to dispatch on
* @param f Function to execute when the event is dispatched * @param f Function to execute when the event is dispatched
* @param c0..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> template <typename F>
Event(EventQueue *q, F f) { Event(EventQueue *q, F f) {
@ -529,7 +542,7 @@ public:
* The post function is irq safe and can act as a mechanism for moving * The post function is irq safe and can act as a mechanism for moving
* events out of irq contexts. * events out of irq contexts.
* *
* @param a0..a4 Arguments to pass to the event * @param a0 Argument to pass to the event
* @return A unique id that represents the posted event and can * @return A unique id that represents the posted event and can
* be passed to EventQueue::cancel, or an id of 0 if * be passed to EventQueue::cancel, or an id of 0 if
* there is not enough memory to allocate the event. * there is not enough memory to allocate the event.
@ -545,7 +558,7 @@ public:
/** Posts an event onto the underlying event queue, returning void /** Posts an event onto the underlying event queue, returning void
* *
* @param a0..a4 Arguments to pass to the event * @param a0 Argument to pass to the event
*/ */
void call(A0 a0) const { void call(A0 a0) const {
MBED_UNUSED int id = post(a0); MBED_UNUSED int id = post(a0);
@ -554,7 +567,7 @@ public:
/** Posts an event onto the underlying event queue, returning void /** Posts an event onto the underlying event queue, returning void
* *
* @param a0..a4 Arguments to pass to the event * @param a0 Argument to pass to the event
*/ */
void operator()(A0 a0) const { void operator()(A0 a0) const {
return call(a0); return call(a0);
@ -563,7 +576,7 @@ public:
/** Static thunk for passing as C-style function /** Static thunk for passing as C-style function
* *
* @param func Event to call passed as a void pointer * @param func Event to call passed as a void pointer
* @param a0..a4 Arguments to pass to the event * @param a0 Argument to pass to the event
*/ */
static void thunk(void *func, A0 a0) { static void thunk(void *func, A0 a0) {
return static_cast<Event*>(func)->call(a0); return static_cast<Event*>(func)->call(a0);
@ -624,7 +637,12 @@ private:
public: public:
/** Create an event /** Create an event
* @see Event::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> template <typename F, typename C0>
Event(EventQueue *q, F f, C0 c0) { Event(EventQueue *q, F f, C0 c0) {
@ -632,7 +650,12 @@ public:
} }
/** Create an event /** Create an event
* @see Event::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> template <typename F, typename C0, typename C1>
Event(EventQueue *q, F f, C0 c0, C1 c1) { Event(EventQueue *q, F f, C0 c0, C1 c1) {
@ -640,7 +663,12 @@ public:
} }
/** Create an event /** Create an event
* @see Event::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> template <typename F, typename C0, typename C1, typename C2>
Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2) { Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2) {
@ -648,7 +676,12 @@ public:
} }
/** Create an event /** Create an event
* @see Event::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> template <typename F, typename C0, typename C1, typename C2, typename C3>
Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3) { Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3) {
@ -656,7 +689,12 @@ public:
} }
/** Create an event /** Create an event
* @see Event::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> 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) { Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {
@ -840,10 +878,6 @@ public:
* *
* @param q Event queue to dispatch on * @param q Event queue to dispatch on
* @param f Function to execute when the event is dispatched * @param f Function to execute when the event is dispatched
* @param c0..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> template <typename F>
Event(EventQueue *q, F f) { Event(EventQueue *q, F f) {
@ -926,7 +960,7 @@ public:
* The post function is irq safe and can act as a mechanism for moving * The post function is irq safe and can act as a mechanism for moving
* events out of irq contexts. * events out of irq contexts.
* *
* @param a0..a4 Arguments to pass to the event * @param a0,a1 Arguments to pass to the event
* @return A unique id that represents the posted event and can * @return A unique id that represents the posted event and can
* be passed to EventQueue::cancel, or an id of 0 if * be passed to EventQueue::cancel, or an id of 0 if
* there is not enough memory to allocate the event. * there is not enough memory to allocate the event.
@ -942,7 +976,7 @@ public:
/** Posts an event onto the underlying event queue, returning void /** Posts an event onto the underlying event queue, returning void
* *
* @param a0..a4 Arguments to pass to the event * @param a0,a1 Arguments to pass to the event
*/ */
void call(A0 a0, A1 a1) const { void call(A0 a0, A1 a1) const {
MBED_UNUSED int id = post(a0, a1); MBED_UNUSED int id = post(a0, a1);
@ -951,7 +985,7 @@ public:
/** Posts an event onto the underlying event queue, returning void /** Posts an event onto the underlying event queue, returning void
* *
* @param a0..a4 Arguments to pass to the event * @param a0,a1 Arguments to pass to the event
*/ */
void operator()(A0 a0, A1 a1) const { void operator()(A0 a0, A1 a1) const {
return call(a0, a1); return call(a0, a1);
@ -960,7 +994,7 @@ public:
/** Static thunk for passing as C-style function /** Static thunk for passing as C-style function
* *
* @param func Event to call passed as a void pointer * @param func Event to call passed as a void pointer
* @param a0..a4 Arguments to pass to the event * @param a0,a1 Arguments to pass to the event
*/ */
static void thunk(void *func, A0 a0, A1 a1) { static void thunk(void *func, A0 a0, A1 a1) {
return static_cast<Event*>(func)->call(a0, a1); return static_cast<Event*>(func)->call(a0, a1);
@ -1021,7 +1055,12 @@ private:
public: public:
/** Create an event /** Create an event
* @see Event::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> template <typename F, typename C0>
Event(EventQueue *q, F f, C0 c0) { Event(EventQueue *q, F f, C0 c0) {
@ -1029,7 +1068,12 @@ public:
} }
/** Create an event /** Create an event
* @see Event::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> template <typename F, typename C0, typename C1>
Event(EventQueue *q, F f, C0 c0, C1 c1) { Event(EventQueue *q, F f, C0 c0, C1 c1) {
@ -1037,7 +1081,12 @@ public:
} }
/** Create an event /** Create an event
* @see Event::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> template <typename F, typename C0, typename C1, typename C2>
Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2) { Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2) {
@ -1045,7 +1094,12 @@ public:
} }
/** Create an event /** Create an event
* @see Event::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> template <typename F, typename C0, typename C1, typename C2, typename C3>
Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3) { Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3) {
@ -1053,7 +1107,12 @@ public:
} }
/** Create an event /** Create an event
* @see Event::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> 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) { Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {
@ -1237,10 +1296,6 @@ public:
* *
* @param q Event queue to dispatch on * @param q Event queue to dispatch on
* @param f Function to execute when the event is dispatched * @param f Function to execute when the event is dispatched
* @param c0..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> template <typename F>
Event(EventQueue *q, F f) { Event(EventQueue *q, F f) {
@ -1323,10 +1378,10 @@ public:
* The post function is irq safe and can act as a mechanism for moving * The post function is irq safe and can act as a mechanism for moving
* events out of irq contexts. * events out of irq contexts.
* *
* @param a0..a4 Arguments to pass to the event * @param a0,a1,a2 Arguments to pass to the event
* @return A unique id that represents the posted event and can * @return A unique id that represents the posted event and can
* be passed to EventQueue::cancel, or an id of 0 if * be passed to EventQueue::cancel, or an id of 0 if
* there is not enough memory to allocate the event. * there is not enough memory to allocate the event.
*/ */
int post(A0 a0, A1 a1, A2 a2) const { int post(A0 a0, A1 a1, A2 a2) const {
if (!_event) { if (!_event) {
@ -1339,7 +1394,7 @@ public:
/** Posts an event onto the underlying event queue, returning void /** Posts an event onto the underlying event queue, returning void
* *
* @param a0..a4 Arguments to pass to the event * @param a0,a1,a2 Arguments to pass to the event
*/ */
void call(A0 a0, A1 a1, A2 a2) const { void call(A0 a0, A1 a1, A2 a2) const {
MBED_UNUSED int id = post(a0, a1, a2); MBED_UNUSED int id = post(a0, a1, a2);
@ -1348,7 +1403,7 @@ public:
/** Posts an event onto the underlying event queue, returning void /** Posts an event onto the underlying event queue, returning void
* *
* @param a0..a4 Arguments to pass to the event * @param a0,a1,a2 Arguments to pass to the event
*/ */
void operator()(A0 a0, A1 a1, A2 a2) const { void operator()(A0 a0, A1 a1, A2 a2) const {
return call(a0, a1, a2); return call(a0, a1, a2);
@ -1356,8 +1411,8 @@ public:
/** Static thunk for passing as C-style function /** Static thunk for passing as C-style function
* *
* @param func Event to call passed as a void pointer * @param func Event to call passed as a void pointer
* @param a0..a4 Arguments to pass to the event * @param a0,a1,a2 Arguments to pass to the event
*/ */
static void thunk(void *func, A0 a0, A1 a1, A2 a2) { static void thunk(void *func, A0 a0, A1 a1, A2 a2) {
return static_cast<Event*>(func)->call(a0, a1, a2); return static_cast<Event*>(func)->call(a0, a1, a2);
@ -1418,7 +1473,12 @@ private:
public: public:
/** Create an event /** Create an event
* @see Event::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> template <typename F, typename C0>
Event(EventQueue *q, F f, C0 c0) { Event(EventQueue *q, F f, C0 c0) {
@ -1426,7 +1486,12 @@ public:
} }
/** Create an event /** Create an event
* @see Event::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> template <typename F, typename C0, typename C1>
Event(EventQueue *q, F f, C0 c0, C1 c1) { Event(EventQueue *q, F f, C0 c0, C1 c1) {
@ -1434,7 +1499,12 @@ public:
} }
/** Create an event /** Create an event
* @see Event::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> template <typename F, typename C0, typename C1, typename C2>
Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2) { Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2) {
@ -1442,7 +1512,12 @@ public:
} }
/** Create an event /** Create an event
* @see Event::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> template <typename F, typename C0, typename C1, typename C2, typename C3>
Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3) { Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3) {
@ -1450,7 +1525,12 @@ public:
} }
/** Create an event /** Create an event
* @see Event::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> 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) { Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {
@ -1634,10 +1714,6 @@ public:
* *
* @param q Event queue to dispatch on * @param q Event queue to dispatch on
* @param f Function to execute when the event is dispatched * @param f Function to execute when the event is dispatched
* @param c0..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> template <typename F>
Event(EventQueue *q, F f) { Event(EventQueue *q, F f) {
@ -1720,10 +1796,10 @@ public:
* The post function is irq safe and can act as a mechanism for moving * The post function is irq safe and can act as a mechanism for moving
* events out of irq contexts. * events out of irq contexts.
* *
* @param a0..a4 Arguments to pass to the event * @param a0,a1,a2,a3 Arguments to pass to the event
* @return A unique id that represents the posted event and can * @return A unique id that represents the posted event and can
* be passed to EventQueue::cancel, or an id of 0 if * be passed to EventQueue::cancel, or an id of 0 if
* there is not enough memory to allocate the event. * there is not enough memory to allocate the event.
*/ */
int post(A0 a0, A1 a1, A2 a2, A3 a3) const { int post(A0 a0, A1 a1, A2 a2, A3 a3) const {
if (!_event) { if (!_event) {
@ -1736,7 +1812,7 @@ public:
/** Posts an event onto the underlying event queue, returning void /** Posts an event onto the underlying event queue, returning void
* *
* @param a0..a4 Arguments to pass to the event * @param a0,a1,a2,a3 Arguments to pass to the event
*/ */
void call(A0 a0, A1 a1, A2 a2, A3 a3) const { void call(A0 a0, A1 a1, A2 a2, A3 a3) const {
MBED_UNUSED int id = post(a0, a1, a2, a3); MBED_UNUSED int id = post(a0, a1, a2, a3);
@ -1745,7 +1821,7 @@ public:
/** Posts an event onto the underlying event queue, returning void /** Posts an event onto the underlying event queue, returning void
* *
* @param a0..a4 Arguments to pass to the event * @param a0,a1,a2,a3 Arguments to pass to the event
*/ */
void operator()(A0 a0, A1 a1, A2 a2, A3 a3) const { void operator()(A0 a0, A1 a1, A2 a2, A3 a3) const {
return call(a0, a1, a2, a3); return call(a0, a1, a2, a3);
@ -1753,8 +1829,8 @@ public:
/** Static thunk for passing as C-style function /** Static thunk for passing as C-style function
* *
* @param func Event to call passed as a void pointer * @param func Event to call passed as a void pointer
* @param a0..a4 Arguments to pass to the event * @param a0,a1,a2,a3 Arguments to pass to the event
*/ */
static void thunk(void *func, A0 a0, A1 a1, A2 a2, A3 a3) { static void thunk(void *func, A0 a0, A1 a1, A2 a2, A3 a3) {
return static_cast<Event*>(func)->call(a0, a1, a2, a3); return static_cast<Event*>(func)->call(a0, a1, a2, a3);
@ -1815,7 +1891,12 @@ private:
public: public:
/** Create an event /** Create an event
* @see Event::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> template <typename F, typename C0>
Event(EventQueue *q, F f, C0 c0) { Event(EventQueue *q, F f, C0 c0) {
@ -1823,7 +1904,12 @@ public:
} }
/** Create an event /** Create an event
* @see Event::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> template <typename F, typename C0, typename C1>
Event(EventQueue *q, F f, C0 c0, C1 c1) { Event(EventQueue *q, F f, C0 c0, C1 c1) {
@ -1831,7 +1917,12 @@ public:
} }
/** Create an event /** Create an event
* @see Event::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> template <typename F, typename C0, typename C1, typename C2>
Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2) { Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2) {
@ -1839,7 +1930,12 @@ public:
} }
/** Create an event /** Create an event
* @see Event::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> template <typename F, typename C0, typename C1, typename C2, typename C3>
Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3) { Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3) {
@ -1847,7 +1943,12 @@ public:
} }
/** Create an event /** Create an event
* @see Event::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> 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) { Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {
@ -2031,10 +2132,6 @@ public:
* *
* @param q Event queue to dispatch on * @param q Event queue to dispatch on
* @param f Function to execute when the event is dispatched * @param f Function to execute when the event is dispatched
* @param c0..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> template <typename F>
Event(EventQueue *q, F f) { Event(EventQueue *q, F f) {
@ -2117,10 +2214,10 @@ public:
* The post function is irq safe and can act as a mechanism for moving * The post function is irq safe and can act as a mechanism for moving
* events out of irq contexts. * events out of irq contexts.
* *
* @param a0..a4 Arguments to pass to the event * @param a0,a1,a2,a3,a4 Arguments to pass to the event
* @return A unique id that represents the posted event and can * @return A unique id that represents the posted event and can
* be passed to EventQueue::cancel, or an id of 0 if * be passed to EventQueue::cancel, or an id of 0 if
* there is not enough memory to allocate the event. * there is not enough memory to allocate the event.
*/ */
int post(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const { int post(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const {
if (!_event) { if (!_event) {
@ -2133,7 +2230,7 @@ public:
/** Posts an event onto the underlying event queue, returning void /** Posts an event onto the underlying event queue, returning void
* *
* @param a0..a4 Arguments to pass to the event * @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 { void call(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const {
MBED_UNUSED int id = post(a0, a1, a2, a3, a4); MBED_UNUSED int id = post(a0, a1, a2, a3, a4);
@ -2142,7 +2239,7 @@ public:
/** Posts an event onto the underlying event queue, returning void /** Posts an event onto the underlying event queue, returning void
* *
* @param a0..a4 Arguments to pass to the event * @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 { void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const {
return call(a0, a1, a2, a3, a4); return call(a0, a1, a2, a3, a4);
@ -2150,8 +2247,8 @@ public:
/** Static thunk for passing as C-style function /** Static thunk for passing as C-style function
* *
* @param func Event to call passed as a void pointer * @param func Event to call passed as a void pointer
* @param a0..a4 Arguments to pass to the event * @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) { 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); return static_cast<Event*>(func)->call(a0, a1, a2, a3, a4);
@ -2212,7 +2309,12 @@ private:
public: public:
/** Create an event /** Create an event
* @see Event::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> template <typename F, typename C0>
Event(EventQueue *q, F f, C0 c0) { Event(EventQueue *q, F f, C0 c0) {
@ -2220,7 +2322,12 @@ public:
} }
/** Create an event /** Create an event
* @see Event::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> template <typename F, typename C0, typename C1>
Event(EventQueue *q, F f, C0 c0, C1 c1) { Event(EventQueue *q, F f, C0 c0, C1 c1) {
@ -2228,7 +2335,12 @@ public:
} }
/** Create an event /** Create an event
* @see Event::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> template <typename F, typename C0, typename C1, typename C2>
Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2) { Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2) {
@ -2236,7 +2348,12 @@ public:
} }
/** Create an event /** Create an event
* @see Event::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> template <typename F, typename C0, typename C1, typename C2, typename C3>
Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3) { Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3) {
@ -2244,7 +2361,12 @@ public:
} }
/** Create an event /** Create an event
* @see Event::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> 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) { Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {