Denislam Valeev / Mbed OS Nucleo_rtos_basic

1

mbed-os/events/Event.h@0:e056ac8fecf8, 2018-03-13 (annotated)

Committer:
valeyev
Date:
Tue Mar 13 07:17:50 2018 +0000
Revision:
0:e056ac8fecf8
looking for...

Who changed what in which revision?

UserRevisionLine numberNew contents of line
valeyev 0:e056ac8fecf8 1 /* events
valeyev 0:e056ac8fecf8 2 * Copyright (c) 2016 ARM Limited
valeyev 0:e056ac8fecf8 3 *
valeyev 0:e056ac8fecf8 4 * Licensed under the Apache License, Version 2.0 (the "License");
valeyev 0:e056ac8fecf8 5 * you may not use this file except in compliance with the License.
valeyev 0:e056ac8fecf8 6 * You may obtain a copy of the License at
valeyev 0:e056ac8fecf8 7 *
valeyev 0:e056ac8fecf8 8 * http://www.apache.org/licenses/LICENSE-2.0
valeyev 0:e056ac8fecf8 9 *
valeyev 0:e056ac8fecf8 10 * Unless required by applicable law or agreed to in writing, software
valeyev 0:e056ac8fecf8 11 * distributed under the License is distributed on an "AS IS" BASIS,
valeyev 0:e056ac8fecf8 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
valeyev 0:e056ac8fecf8 13 * See the License for the specific language governing permissions and
valeyev 0:e056ac8fecf8 14 * limitations under the License.
valeyev 0:e056ac8fecf8 15 */
valeyev 0:e056ac8fecf8 16 #ifndef EVENT_H
valeyev 0:e056ac8fecf8 17 #define EVENT_H
valeyev 0:e056ac8fecf8 18
valeyev 0:e056ac8fecf8 19 #include "events/EventQueue.h"
valeyev 0:e056ac8fecf8 20 #include "platform/mbed_assert.h"
valeyev 0:e056ac8fecf8 21
valeyev 0:e056ac8fecf8 22 namespace events {
valeyev 0:e056ac8fecf8 23 /** \addtogroup events */
valeyev 0:e056ac8fecf8 24
valeyev 0:e056ac8fecf8 25 /** Event
valeyev 0:e056ac8fecf8 26 *
valeyev 0:e056ac8fecf8 27 * Representation of an event for fine-grain dispatch control
valeyev 0:e056ac8fecf8 28 * @ingroup events
valeyev 0:e056ac8fecf8 29 */
valeyev 0:e056ac8fecf8 30 template <typename F>
valeyev 0:e056ac8fecf8 31 class Event;
valeyev 0:e056ac8fecf8 32
valeyev 0:e056ac8fecf8 33 /** Event
valeyev 0:e056ac8fecf8 34 *
valeyev 0:e056ac8fecf8 35 * Representation of an event for fine-grain dispatch control
valeyev 0:e056ac8fecf8 36 * @ingroup events
valeyev 0:e056ac8fecf8 37 */
valeyev 0:e056ac8fecf8 38 template <>
valeyev 0:e056ac8fecf8 39 class Event<void()> {
valeyev 0:e056ac8fecf8 40 public:
valeyev 0:e056ac8fecf8 41 /** Create an event
valeyev 0:e056ac8fecf8 42 *
valeyev 0:e056ac8fecf8 43 * Constructs an event bound to the specified event queue. The specified
valeyev 0:e056ac8fecf8 44 * callback acts as the target for the event and is executed in the
valeyev 0:e056ac8fecf8 45 * context of the event queue's dispatch loop once posted.
valeyev 0:e056ac8fecf8 46 *
valeyev 0:e056ac8fecf8 47 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 48 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 49 */
valeyev 0:e056ac8fecf8 50 template <typename F>
valeyev 0:e056ac8fecf8 51 Event(EventQueue *q, F f) {
valeyev 0:e056ac8fecf8 52 _event = static_cast<struct event *>(
valeyev 0:e056ac8fecf8 53 equeue_alloc(&q->_equeue, sizeof(struct event) + sizeof(F)));
valeyev 0:e056ac8fecf8 54
valeyev 0:e056ac8fecf8 55 if (_event) {
valeyev 0:e056ac8fecf8 56 _event->equeue = &q->_equeue;
valeyev 0:e056ac8fecf8 57 _event->id = 0;
valeyev 0:e056ac8fecf8 58 _event->delay = 0;
valeyev 0:e056ac8fecf8 59 _event->period = -1;
valeyev 0:e056ac8fecf8 60
valeyev 0:e056ac8fecf8 61 _event->post = &Event::event_post<F>;
valeyev 0:e056ac8fecf8 62 _event->dtor = &Event::event_dtor<F>;
valeyev 0:e056ac8fecf8 63
valeyev 0:e056ac8fecf8 64 new (_event+1) F(f);
valeyev 0:e056ac8fecf8 65
valeyev 0:e056ac8fecf8 66 _event->ref = 1;
valeyev 0:e056ac8fecf8 67 }
valeyev 0:e056ac8fecf8 68 }
valeyev 0:e056ac8fecf8 69
valeyev 0:e056ac8fecf8 70 /** Copy constructor for events
valeyev 0:e056ac8fecf8 71 */
valeyev 0:e056ac8fecf8 72 Event(const Event &e) {
valeyev 0:e056ac8fecf8 73 _event = 0;
valeyev 0:e056ac8fecf8 74 if (e._event) {
valeyev 0:e056ac8fecf8 75 _event = e._event;
valeyev 0:e056ac8fecf8 76 _event->ref += 1;
valeyev 0:e056ac8fecf8 77 }
valeyev 0:e056ac8fecf8 78 }
valeyev 0:e056ac8fecf8 79
valeyev 0:e056ac8fecf8 80 /** Assignment operator for events
valeyev 0:e056ac8fecf8 81 */
valeyev 0:e056ac8fecf8 82 Event &operator=(const Event &that) {
valeyev 0:e056ac8fecf8 83 if (this != &that) {
valeyev 0:e056ac8fecf8 84 this->~Event();
valeyev 0:e056ac8fecf8 85 new (this) Event(that);
valeyev 0:e056ac8fecf8 86 }
valeyev 0:e056ac8fecf8 87
valeyev 0:e056ac8fecf8 88 return *this;
valeyev 0:e056ac8fecf8 89 }
valeyev 0:e056ac8fecf8 90
valeyev 0:e056ac8fecf8 91 /** Destructor for events
valeyev 0:e056ac8fecf8 92 */
valeyev 0:e056ac8fecf8 93 ~Event() {
valeyev 0:e056ac8fecf8 94 if (_event) {
valeyev 0:e056ac8fecf8 95 _event->ref -= 1;
valeyev 0:e056ac8fecf8 96 if (_event->ref == 0) {
valeyev 0:e056ac8fecf8 97 _event->dtor(_event);
valeyev 0:e056ac8fecf8 98 equeue_dealloc(_event->equeue, _event);
valeyev 0:e056ac8fecf8 99 }
valeyev 0:e056ac8fecf8 100 }
valeyev 0:e056ac8fecf8 101 }
valeyev 0:e056ac8fecf8 102
valeyev 0:e056ac8fecf8 103 /** Configure the delay of an event
valeyev 0:e056ac8fecf8 104 *
valeyev 0:e056ac8fecf8 105 * @param delay Millisecond delay before dispatching the event
valeyev 0:e056ac8fecf8 106 */
valeyev 0:e056ac8fecf8 107 void delay(int delay) {
valeyev 0:e056ac8fecf8 108 if (_event) {
valeyev 0:e056ac8fecf8 109 _event->delay = delay;
valeyev 0:e056ac8fecf8 110 }
valeyev 0:e056ac8fecf8 111 }
valeyev 0:e056ac8fecf8 112
valeyev 0:e056ac8fecf8 113 /** Configure the period of an event
valeyev 0:e056ac8fecf8 114 *
valeyev 0:e056ac8fecf8 115 * @param period Millisecond period for repeatedly dispatching an event
valeyev 0:e056ac8fecf8 116 */
valeyev 0:e056ac8fecf8 117 void period(int period) {
valeyev 0:e056ac8fecf8 118 if (_event) {
valeyev 0:e056ac8fecf8 119 _event->period = period;
valeyev 0:e056ac8fecf8 120 }
valeyev 0:e056ac8fecf8 121 }
valeyev 0:e056ac8fecf8 122
valeyev 0:e056ac8fecf8 123 /** Posts an event onto the underlying event queue
valeyev 0:e056ac8fecf8 124 *
valeyev 0:e056ac8fecf8 125 * The event is posted to the underlying queue and is executed in the
valeyev 0:e056ac8fecf8 126 * context of the event queue's dispatch loop.
valeyev 0:e056ac8fecf8 127 *
valeyev 0:e056ac8fecf8 128 * The post function is irq safe and can act as a mechanism for moving
valeyev 0:e056ac8fecf8 129 * events out of irq contexts.
valeyev 0:e056ac8fecf8 130 *
valeyev 0:e056ac8fecf8 131 * @return A unique id that represents the posted event and can
valeyev 0:e056ac8fecf8 132 * be passed to EventQueue::cancel, or an id of 0 if
valeyev 0:e056ac8fecf8 133 * there is not enough memory to allocate the event.
valeyev 0:e056ac8fecf8 134 */
valeyev 0:e056ac8fecf8 135 int post() const {
valeyev 0:e056ac8fecf8 136 if (!_event) {
valeyev 0:e056ac8fecf8 137 return 0;
valeyev 0:e056ac8fecf8 138 }
valeyev 0:e056ac8fecf8 139
valeyev 0:e056ac8fecf8 140 _event->id = _event->post(_event);
valeyev 0:e056ac8fecf8 141 return _event->id;
valeyev 0:e056ac8fecf8 142 }
valeyev 0:e056ac8fecf8 143
valeyev 0:e056ac8fecf8 144 /** Posts an event onto the underlying event queue, returning void
valeyev 0:e056ac8fecf8 145 *
valeyev 0:e056ac8fecf8 146 */
valeyev 0:e056ac8fecf8 147 void call() const {
valeyev 0:e056ac8fecf8 148 MBED_UNUSED int id = post();
valeyev 0:e056ac8fecf8 149 MBED_ASSERT(id);
valeyev 0:e056ac8fecf8 150 }
valeyev 0:e056ac8fecf8 151
valeyev 0:e056ac8fecf8 152 /** Posts an event onto the underlying event queue, returning void
valeyev 0:e056ac8fecf8 153 *
valeyev 0:e056ac8fecf8 154 */
valeyev 0:e056ac8fecf8 155 void operator()() const {
valeyev 0:e056ac8fecf8 156 return call();
valeyev 0:e056ac8fecf8 157 }
valeyev 0:e056ac8fecf8 158
valeyev 0:e056ac8fecf8 159 /** Static thunk for passing as C-style function
valeyev 0:e056ac8fecf8 160 *
valeyev 0:e056ac8fecf8 161 * @param func Event to call passed as a void pointer
valeyev 0:e056ac8fecf8 162 */
valeyev 0:e056ac8fecf8 163 static void thunk(void *func) {
valeyev 0:e056ac8fecf8 164 return static_cast<Event*>(func)->call();
valeyev 0:e056ac8fecf8 165 }
valeyev 0:e056ac8fecf8 166
valeyev 0:e056ac8fecf8 167 /** Cancels the most recently posted event
valeyev 0:e056ac8fecf8 168 *
valeyev 0:e056ac8fecf8 169 * Attempts to cancel the most recently posted event. It is safe to call
valeyev 0:e056ac8fecf8 170 * cancel after an event has already been dispatched.
valeyev 0:e056ac8fecf8 171 *
valeyev 0:e056ac8fecf8 172 * The cancel function is irq safe.
valeyev 0:e056ac8fecf8 173 *
valeyev 0:e056ac8fecf8 174 * If called while the event queue's dispatch loop is active, the cancel
valeyev 0:e056ac8fecf8 175 * function does not garuntee that the event will not execute after it
valeyev 0:e056ac8fecf8 176 * returns, as the event may have already begun executing.
valeyev 0:e056ac8fecf8 177 */
valeyev 0:e056ac8fecf8 178 void cancel() const {
valeyev 0:e056ac8fecf8 179 if (_event) {
valeyev 0:e056ac8fecf8 180 equeue_cancel(_event->equeue, _event->id);
valeyev 0:e056ac8fecf8 181 }
valeyev 0:e056ac8fecf8 182 }
valeyev 0:e056ac8fecf8 183
valeyev 0:e056ac8fecf8 184 private:
valeyev 0:e056ac8fecf8 185 struct event {
valeyev 0:e056ac8fecf8 186 unsigned ref;
valeyev 0:e056ac8fecf8 187 equeue_t *equeue;
valeyev 0:e056ac8fecf8 188 int id;
valeyev 0:e056ac8fecf8 189
valeyev 0:e056ac8fecf8 190 int delay;
valeyev 0:e056ac8fecf8 191 int period;
valeyev 0:e056ac8fecf8 192
valeyev 0:e056ac8fecf8 193 int (*post)(struct event *);
valeyev 0:e056ac8fecf8 194 void (*dtor)(struct event *);
valeyev 0:e056ac8fecf8 195
valeyev 0:e056ac8fecf8 196 // F follows
valeyev 0:e056ac8fecf8 197 } *_event;
valeyev 0:e056ac8fecf8 198
valeyev 0:e056ac8fecf8 199 // Event attributes
valeyev 0:e056ac8fecf8 200 template <typename F>
valeyev 0:e056ac8fecf8 201 static int event_post(struct event *e) {
valeyev 0:e056ac8fecf8 202 typedef EventQueue::context00<F> C;
valeyev 0:e056ac8fecf8 203 void *p = equeue_alloc(e->equeue, sizeof(C));
valeyev 0:e056ac8fecf8 204 if (!p) {
valeyev 0:e056ac8fecf8 205 return 0;
valeyev 0:e056ac8fecf8 206 }
valeyev 0:e056ac8fecf8 207
valeyev 0:e056ac8fecf8 208 new (p) C(*(F*)(e + 1));
valeyev 0:e056ac8fecf8 209 equeue_event_delay(p, e->delay);
valeyev 0:e056ac8fecf8 210 equeue_event_period(p, e->period);
valeyev 0:e056ac8fecf8 211 equeue_event_dtor(p, &EventQueue::function_dtor<C>);
valeyev 0:e056ac8fecf8 212 return equeue_post(e->equeue, &EventQueue::function_call<C>, p);
valeyev 0:e056ac8fecf8 213 }
valeyev 0:e056ac8fecf8 214
valeyev 0:e056ac8fecf8 215 template <typename F>
valeyev 0:e056ac8fecf8 216 static void event_dtor(struct event *e) {
valeyev 0:e056ac8fecf8 217 ((F*)(e + 1))->~F();
valeyev 0:e056ac8fecf8 218 }
valeyev 0:e056ac8fecf8 219
valeyev 0:e056ac8fecf8 220 public:
valeyev 0:e056ac8fecf8 221 /** Create an event
valeyev 0:e056ac8fecf8 222 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 223 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 224 * @param c0 Argument to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 225 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 226 * memory pool. Must be type-compatible with b0, the
valeyev 0:e056ac8fecf8 227 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 228 */
valeyev 0:e056ac8fecf8 229 template <typename F, typename C0>
valeyev 0:e056ac8fecf8 230 Event(EventQueue *q, F f, C0 c0) {
valeyev 0:e056ac8fecf8 231 new (this) Event(q, EventQueue::context10<F, C0>(f, c0));
valeyev 0:e056ac8fecf8 232 }
valeyev 0:e056ac8fecf8 233
valeyev 0:e056ac8fecf8 234 /** Create an event
valeyev 0:e056ac8fecf8 235 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 236 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 237 * @param c0,c1 Arguments to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 238 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 239 * memory pool. Must be type-compatible with b0..b1, the
valeyev 0:e056ac8fecf8 240 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 241 */
valeyev 0:e056ac8fecf8 242 template <typename F, typename C0, typename C1>
valeyev 0:e056ac8fecf8 243 Event(EventQueue *q, F f, C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 244 new (this) Event(q, EventQueue::context20<F, C0, C1>(f, c0, c1));
valeyev 0:e056ac8fecf8 245 }
valeyev 0:e056ac8fecf8 246
valeyev 0:e056ac8fecf8 247 /** Create an event
valeyev 0:e056ac8fecf8 248 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 249 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 250 * @param c0,c1,c2 Arguments to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 251 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 252 * memory pool. Must be type-compatible with b0..b2, the
valeyev 0:e056ac8fecf8 253 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 254 */
valeyev 0:e056ac8fecf8 255 template <typename F, typename C0, typename C1, typename C2>
valeyev 0:e056ac8fecf8 256 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2) {
valeyev 0:e056ac8fecf8 257 new (this) Event(q, EventQueue::context30<F, C0, C1, C2>(f, c0, c1, c2));
valeyev 0:e056ac8fecf8 258 }
valeyev 0:e056ac8fecf8 259
valeyev 0:e056ac8fecf8 260 /** Create an event
valeyev 0:e056ac8fecf8 261 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 262 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 263 * @param c0,c1,c2,c3 Arguments to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 264 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 265 * memory pool. Must be type-compatible with b0..b3, the
valeyev 0:e056ac8fecf8 266 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 267 */
valeyev 0:e056ac8fecf8 268 template <typename F, typename C0, typename C1, typename C2, typename C3>
valeyev 0:e056ac8fecf8 269 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3) {
valeyev 0:e056ac8fecf8 270 new (this) Event(q, EventQueue::context40<F, C0, C1, C2, C3>(f, c0, c1, c2, c3));
valeyev 0:e056ac8fecf8 271 }
valeyev 0:e056ac8fecf8 272
valeyev 0:e056ac8fecf8 273 /** Create an event
valeyev 0:e056ac8fecf8 274 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 275 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 276 * @param c0,c1,c2,c3,c4 Arguments to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 277 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 278 * memory pool. Must be type-compatible with b0..b4, the
valeyev 0:e056ac8fecf8 279 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 280 */
valeyev 0:e056ac8fecf8 281 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4>
valeyev 0:e056ac8fecf8 282 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {
valeyev 0:e056ac8fecf8 283 new (this) Event(q, EventQueue::context50<F, C0, C1, C2, C3, C4>(f, c0, c1, c2, c3, c4));
valeyev 0:e056ac8fecf8 284 }
valeyev 0:e056ac8fecf8 285
valeyev 0:e056ac8fecf8 286 /** Create an event
valeyev 0:e056ac8fecf8 287 * @see Event::Event
valeyev 0:e056ac8fecf8 288 */
valeyev 0:e056ac8fecf8 289 template <typename T, typename R, typename B0>
valeyev 0:e056ac8fecf8 290 Event(EventQueue *q, T *obj, R (T::*method)(B0), B0 b0) {
valeyev 0:e056ac8fecf8 291 new (this) Event(q, mbed::callback(obj, method), b0);
valeyev 0:e056ac8fecf8 292 }
valeyev 0:e056ac8fecf8 293
valeyev 0:e056ac8fecf8 294 /** Create an event
valeyev 0:e056ac8fecf8 295 * @see Event::Event
valeyev 0:e056ac8fecf8 296 */
valeyev 0:e056ac8fecf8 297 template <typename T, typename R, typename B0>
valeyev 0:e056ac8fecf8 298 Event(EventQueue *q, const T *obj, R (T::*method)(B0) const, B0 b0) {
valeyev 0:e056ac8fecf8 299 new (this) Event(q, mbed::callback(obj, method), b0);
valeyev 0:e056ac8fecf8 300 }
valeyev 0:e056ac8fecf8 301
valeyev 0:e056ac8fecf8 302 /** Create an event
valeyev 0:e056ac8fecf8 303 * @see Event::Event
valeyev 0:e056ac8fecf8 304 */
valeyev 0:e056ac8fecf8 305 template <typename T, typename R, typename B0>
valeyev 0:e056ac8fecf8 306 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0) volatile, B0 b0) {
valeyev 0:e056ac8fecf8 307 new (this) Event(q, mbed::callback(obj, method), b0);
valeyev 0:e056ac8fecf8 308 }
valeyev 0:e056ac8fecf8 309
valeyev 0:e056ac8fecf8 310 /** Create an event
valeyev 0:e056ac8fecf8 311 * @see Event::Event
valeyev 0:e056ac8fecf8 312 */
valeyev 0:e056ac8fecf8 313 template <typename T, typename R, typename B0>
valeyev 0:e056ac8fecf8 314 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0) const volatile, B0 b0) {
valeyev 0:e056ac8fecf8 315 new (this) Event(q, mbed::callback(obj, method), b0);
valeyev 0:e056ac8fecf8 316 }
valeyev 0:e056ac8fecf8 317
valeyev 0:e056ac8fecf8 318 /** Create an event
valeyev 0:e056ac8fecf8 319 * @see Event::Event
valeyev 0:e056ac8fecf8 320 */
valeyev 0:e056ac8fecf8 321 template <typename T, typename R, typename B0, typename B1>
valeyev 0:e056ac8fecf8 322 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1), B0 b0, B1 b1) {
valeyev 0:e056ac8fecf8 323 new (this) Event(q, mbed::callback(obj, method), b0, b1);
valeyev 0:e056ac8fecf8 324 }
valeyev 0:e056ac8fecf8 325
valeyev 0:e056ac8fecf8 326 /** Create an event
valeyev 0:e056ac8fecf8 327 * @see Event::Event
valeyev 0:e056ac8fecf8 328 */
valeyev 0:e056ac8fecf8 329 template <typename T, typename R, typename B0, typename B1>
valeyev 0:e056ac8fecf8 330 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1) const, B0 b0, B1 b1) {
valeyev 0:e056ac8fecf8 331 new (this) Event(q, mbed::callback(obj, method), b0, b1);
valeyev 0:e056ac8fecf8 332 }
valeyev 0:e056ac8fecf8 333
valeyev 0:e056ac8fecf8 334 /** Create an event
valeyev 0:e056ac8fecf8 335 * @see Event::Event
valeyev 0:e056ac8fecf8 336 */
valeyev 0:e056ac8fecf8 337 template <typename T, typename R, typename B0, typename B1>
valeyev 0:e056ac8fecf8 338 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1) volatile, B0 b0, B1 b1) {
valeyev 0:e056ac8fecf8 339 new (this) Event(q, mbed::callback(obj, method), b0, b1);
valeyev 0:e056ac8fecf8 340 }
valeyev 0:e056ac8fecf8 341
valeyev 0:e056ac8fecf8 342 /** Create an event
valeyev 0:e056ac8fecf8 343 * @see Event::Event
valeyev 0:e056ac8fecf8 344 */
valeyev 0:e056ac8fecf8 345 template <typename T, typename R, typename B0, typename B1>
valeyev 0:e056ac8fecf8 346 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1) const volatile, B0 b0, B1 b1) {
valeyev 0:e056ac8fecf8 347 new (this) Event(q, mbed::callback(obj, method), b0, b1);
valeyev 0:e056ac8fecf8 348 }
valeyev 0:e056ac8fecf8 349
valeyev 0:e056ac8fecf8 350 /** Create an event
valeyev 0:e056ac8fecf8 351 * @see Event::Event
valeyev 0:e056ac8fecf8 352 */
valeyev 0:e056ac8fecf8 353 template <typename T, typename R, typename B0, typename B1, typename B2>
valeyev 0:e056ac8fecf8 354 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2), B0 b0, B1 b1, B2 b2) {
valeyev 0:e056ac8fecf8 355 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
valeyev 0:e056ac8fecf8 356 }
valeyev 0:e056ac8fecf8 357
valeyev 0:e056ac8fecf8 358 /** Create an event
valeyev 0:e056ac8fecf8 359 * @see Event::Event
valeyev 0:e056ac8fecf8 360 */
valeyev 0:e056ac8fecf8 361 template <typename T, typename R, typename B0, typename B1, typename B2>
valeyev 0:e056ac8fecf8 362 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, B2) const, B0 b0, B1 b1, B2 b2) {
valeyev 0:e056ac8fecf8 363 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
valeyev 0:e056ac8fecf8 364 }
valeyev 0:e056ac8fecf8 365
valeyev 0:e056ac8fecf8 366 /** Create an event
valeyev 0:e056ac8fecf8 367 * @see Event::Event
valeyev 0:e056ac8fecf8 368 */
valeyev 0:e056ac8fecf8 369 template <typename T, typename R, typename B0, typename B1, typename B2>
valeyev 0:e056ac8fecf8 370 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, B2) volatile, B0 b0, B1 b1, B2 b2) {
valeyev 0:e056ac8fecf8 371 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
valeyev 0:e056ac8fecf8 372 }
valeyev 0:e056ac8fecf8 373
valeyev 0:e056ac8fecf8 374 /** Create an event
valeyev 0:e056ac8fecf8 375 * @see Event::Event
valeyev 0:e056ac8fecf8 376 */
valeyev 0:e056ac8fecf8 377 template <typename T, typename R, typename B0, typename B1, typename B2>
valeyev 0:e056ac8fecf8 378 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, B2) const volatile, B0 b0, B1 b1, B2 b2) {
valeyev 0:e056ac8fecf8 379 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
valeyev 0:e056ac8fecf8 380 }
valeyev 0:e056ac8fecf8 381
valeyev 0:e056ac8fecf8 382 /** Create an event
valeyev 0:e056ac8fecf8 383 * @see Event::Event
valeyev 0:e056ac8fecf8 384 */
valeyev 0:e056ac8fecf8 385 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
valeyev 0:e056ac8fecf8 386 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, B3), B0 b0, B1 b1, B2 b2, B3 b3) {
valeyev 0:e056ac8fecf8 387 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
valeyev 0:e056ac8fecf8 388 }
valeyev 0:e056ac8fecf8 389
valeyev 0:e056ac8fecf8 390 /** Create an event
valeyev 0:e056ac8fecf8 391 * @see Event::Event
valeyev 0:e056ac8fecf8 392 */
valeyev 0:e056ac8fecf8 393 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
valeyev 0:e056ac8fecf8 394 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, B2, B3) const, B0 b0, B1 b1, B2 b2, B3 b3) {
valeyev 0:e056ac8fecf8 395 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
valeyev 0:e056ac8fecf8 396 }
valeyev 0:e056ac8fecf8 397
valeyev 0:e056ac8fecf8 398 /** Create an event
valeyev 0:e056ac8fecf8 399 * @see Event::Event
valeyev 0:e056ac8fecf8 400 */
valeyev 0:e056ac8fecf8 401 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
valeyev 0:e056ac8fecf8 402 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, B2, B3) volatile, B0 b0, B1 b1, B2 b2, B3 b3) {
valeyev 0:e056ac8fecf8 403 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
valeyev 0:e056ac8fecf8 404 }
valeyev 0:e056ac8fecf8 405
valeyev 0:e056ac8fecf8 406 /** Create an event
valeyev 0:e056ac8fecf8 407 * @see Event::Event
valeyev 0:e056ac8fecf8 408 */
valeyev 0:e056ac8fecf8 409 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
valeyev 0:e056ac8fecf8 410 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, B2, B3) const volatile, B0 b0, B1 b1, B2 b2, B3 b3) {
valeyev 0:e056ac8fecf8 411 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
valeyev 0:e056ac8fecf8 412 }
valeyev 0:e056ac8fecf8 413
valeyev 0:e056ac8fecf8 414 /** Create an event
valeyev 0:e056ac8fecf8 415 * @see Event::Event
valeyev 0:e056ac8fecf8 416 */
valeyev 0:e056ac8fecf8 417 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
valeyev 0:e056ac8fecf8 418 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, B3, B4), B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) {
valeyev 0:e056ac8fecf8 419 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
valeyev 0:e056ac8fecf8 420 }
valeyev 0:e056ac8fecf8 421
valeyev 0:e056ac8fecf8 422 /** Create an event
valeyev 0:e056ac8fecf8 423 * @see Event::Event
valeyev 0:e056ac8fecf8 424 */
valeyev 0:e056ac8fecf8 425 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
valeyev 0:e056ac8fecf8 426 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) {
valeyev 0:e056ac8fecf8 427 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
valeyev 0:e056ac8fecf8 428 }
valeyev 0:e056ac8fecf8 429
valeyev 0:e056ac8fecf8 430 /** Create an event
valeyev 0:e056ac8fecf8 431 * @see Event::Event
valeyev 0:e056ac8fecf8 432 */
valeyev 0:e056ac8fecf8 433 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
valeyev 0:e056ac8fecf8 434 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) {
valeyev 0:e056ac8fecf8 435 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
valeyev 0:e056ac8fecf8 436 }
valeyev 0:e056ac8fecf8 437
valeyev 0:e056ac8fecf8 438 /** Create an event
valeyev 0:e056ac8fecf8 439 * @see Event::Event
valeyev 0:e056ac8fecf8 440 */
valeyev 0:e056ac8fecf8 441 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
valeyev 0:e056ac8fecf8 442 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) {
valeyev 0:e056ac8fecf8 443 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
valeyev 0:e056ac8fecf8 444 }
valeyev 0:e056ac8fecf8 445 };
valeyev 0:e056ac8fecf8 446
valeyev 0:e056ac8fecf8 447 /** Event
valeyev 0:e056ac8fecf8 448 *
valeyev 0:e056ac8fecf8 449 * Representation of an event for fine-grain dispatch control
valeyev 0:e056ac8fecf8 450 * @ingroup events
valeyev 0:e056ac8fecf8 451 */
valeyev 0:e056ac8fecf8 452 template <typename A0>
valeyev 0:e056ac8fecf8 453 class Event<void(A0)> {
valeyev 0:e056ac8fecf8 454 public:
valeyev 0:e056ac8fecf8 455 /** Create an event
valeyev 0:e056ac8fecf8 456 *
valeyev 0:e056ac8fecf8 457 * Constructs an event bound to the specified event queue. The specified
valeyev 0:e056ac8fecf8 458 * callback acts as the target for the event and is executed in the
valeyev 0:e056ac8fecf8 459 * context of the event queue's dispatch loop once posted.
valeyev 0:e056ac8fecf8 460 *
valeyev 0:e056ac8fecf8 461 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 462 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 463 */
valeyev 0:e056ac8fecf8 464 template <typename F>
valeyev 0:e056ac8fecf8 465 Event(EventQueue *q, F f) {
valeyev 0:e056ac8fecf8 466 _event = static_cast<struct event *>(
valeyev 0:e056ac8fecf8 467 equeue_alloc(&q->_equeue, sizeof(struct event) + sizeof(F)));
valeyev 0:e056ac8fecf8 468
valeyev 0:e056ac8fecf8 469 if (_event) {
valeyev 0:e056ac8fecf8 470 _event->equeue = &q->_equeue;
valeyev 0:e056ac8fecf8 471 _event->id = 0;
valeyev 0:e056ac8fecf8 472 _event->delay = 0;
valeyev 0:e056ac8fecf8 473 _event->period = -1;
valeyev 0:e056ac8fecf8 474
valeyev 0:e056ac8fecf8 475 _event->post = &Event::event_post<F>;
valeyev 0:e056ac8fecf8 476 _event->dtor = &Event::event_dtor<F>;
valeyev 0:e056ac8fecf8 477
valeyev 0:e056ac8fecf8 478 new (_event+1) F(f);
valeyev 0:e056ac8fecf8 479
valeyev 0:e056ac8fecf8 480 _event->ref = 1;
valeyev 0:e056ac8fecf8 481 }
valeyev 0:e056ac8fecf8 482 }
valeyev 0:e056ac8fecf8 483
valeyev 0:e056ac8fecf8 484 /** Copy constructor for events
valeyev 0:e056ac8fecf8 485 */
valeyev 0:e056ac8fecf8 486 Event(const Event &e) {
valeyev 0:e056ac8fecf8 487 _event = 0;
valeyev 0:e056ac8fecf8 488 if (e._event) {
valeyev 0:e056ac8fecf8 489 _event = e._event;
valeyev 0:e056ac8fecf8 490 _event->ref += 1;
valeyev 0:e056ac8fecf8 491 }
valeyev 0:e056ac8fecf8 492 }
valeyev 0:e056ac8fecf8 493
valeyev 0:e056ac8fecf8 494 /** Assignment operator for events
valeyev 0:e056ac8fecf8 495 */
valeyev 0:e056ac8fecf8 496 Event &operator=(const Event &that) {
valeyev 0:e056ac8fecf8 497 if (this != &that) {
valeyev 0:e056ac8fecf8 498 this->~Event();
valeyev 0:e056ac8fecf8 499 new (this) Event(that);
valeyev 0:e056ac8fecf8 500 }
valeyev 0:e056ac8fecf8 501
valeyev 0:e056ac8fecf8 502 return *this;
valeyev 0:e056ac8fecf8 503 }
valeyev 0:e056ac8fecf8 504
valeyev 0:e056ac8fecf8 505 /** Destructor for events
valeyev 0:e056ac8fecf8 506 */
valeyev 0:e056ac8fecf8 507 ~Event() {
valeyev 0:e056ac8fecf8 508 if (_event) {
valeyev 0:e056ac8fecf8 509 _event->ref -= 1;
valeyev 0:e056ac8fecf8 510 if (_event->ref == 0) {
valeyev 0:e056ac8fecf8 511 _event->dtor(_event);
valeyev 0:e056ac8fecf8 512 equeue_dealloc(_event->equeue, _event);
valeyev 0:e056ac8fecf8 513 }
valeyev 0:e056ac8fecf8 514 }
valeyev 0:e056ac8fecf8 515 }
valeyev 0:e056ac8fecf8 516
valeyev 0:e056ac8fecf8 517 /** Configure the delay of an event
valeyev 0:e056ac8fecf8 518 *
valeyev 0:e056ac8fecf8 519 * @param delay Millisecond delay before dispatching the event
valeyev 0:e056ac8fecf8 520 */
valeyev 0:e056ac8fecf8 521 void delay(int delay) {
valeyev 0:e056ac8fecf8 522 if (_event) {
valeyev 0:e056ac8fecf8 523 _event->delay = delay;
valeyev 0:e056ac8fecf8 524 }
valeyev 0:e056ac8fecf8 525 }
valeyev 0:e056ac8fecf8 526
valeyev 0:e056ac8fecf8 527 /** Configure the period of an event
valeyev 0:e056ac8fecf8 528 *
valeyev 0:e056ac8fecf8 529 * @param period Millisecond period for repeatedly dispatching an event
valeyev 0:e056ac8fecf8 530 */
valeyev 0:e056ac8fecf8 531 void period(int period) {
valeyev 0:e056ac8fecf8 532 if (_event) {
valeyev 0:e056ac8fecf8 533 _event->period = period;
valeyev 0:e056ac8fecf8 534 }
valeyev 0:e056ac8fecf8 535 }
valeyev 0:e056ac8fecf8 536
valeyev 0:e056ac8fecf8 537 /** Posts an event onto the underlying event queue
valeyev 0:e056ac8fecf8 538 *
valeyev 0:e056ac8fecf8 539 * The event is posted to the underlying queue and is executed in the
valeyev 0:e056ac8fecf8 540 * context of the event queue's dispatch loop.
valeyev 0:e056ac8fecf8 541 *
valeyev 0:e056ac8fecf8 542 * The post function is irq safe and can act as a mechanism for moving
valeyev 0:e056ac8fecf8 543 * events out of irq contexts.
valeyev 0:e056ac8fecf8 544 *
valeyev 0:e056ac8fecf8 545 * @param a0 Argument to pass to the event
valeyev 0:e056ac8fecf8 546 * @return A unique id that represents the posted event and can
valeyev 0:e056ac8fecf8 547 * be passed to EventQueue::cancel, or an id of 0 if
valeyev 0:e056ac8fecf8 548 * there is not enough memory to allocate the event.
valeyev 0:e056ac8fecf8 549 */
valeyev 0:e056ac8fecf8 550 int post(A0 a0) const {
valeyev 0:e056ac8fecf8 551 if (!_event) {
valeyev 0:e056ac8fecf8 552 return 0;
valeyev 0:e056ac8fecf8 553 }
valeyev 0:e056ac8fecf8 554
valeyev 0:e056ac8fecf8 555 _event->id = _event->post(_event, a0);
valeyev 0:e056ac8fecf8 556 return _event->id;
valeyev 0:e056ac8fecf8 557 }
valeyev 0:e056ac8fecf8 558
valeyev 0:e056ac8fecf8 559 /** Posts an event onto the underlying event queue, returning void
valeyev 0:e056ac8fecf8 560 *
valeyev 0:e056ac8fecf8 561 * @param a0 Argument to pass to the event
valeyev 0:e056ac8fecf8 562 */
valeyev 0:e056ac8fecf8 563 void call(A0 a0) const {
valeyev 0:e056ac8fecf8 564 MBED_UNUSED int id = post(a0);
valeyev 0:e056ac8fecf8 565 MBED_ASSERT(id);
valeyev 0:e056ac8fecf8 566 }
valeyev 0:e056ac8fecf8 567
valeyev 0:e056ac8fecf8 568 /** Posts an event onto the underlying event queue, returning void
valeyev 0:e056ac8fecf8 569 *
valeyev 0:e056ac8fecf8 570 * @param a0 Argument to pass to the event
valeyev 0:e056ac8fecf8 571 */
valeyev 0:e056ac8fecf8 572 void operator()(A0 a0) const {
valeyev 0:e056ac8fecf8 573 return call(a0);
valeyev 0:e056ac8fecf8 574 }
valeyev 0:e056ac8fecf8 575
valeyev 0:e056ac8fecf8 576 /** Static thunk for passing as C-style function
valeyev 0:e056ac8fecf8 577 *
valeyev 0:e056ac8fecf8 578 * @param func Event to call passed as a void pointer
valeyev 0:e056ac8fecf8 579 * @param a0 Argument to pass to the event
valeyev 0:e056ac8fecf8 580 */
valeyev 0:e056ac8fecf8 581 static void thunk(void *func, A0 a0) {
valeyev 0:e056ac8fecf8 582 return static_cast<Event*>(func)->call(a0);
valeyev 0:e056ac8fecf8 583 }
valeyev 0:e056ac8fecf8 584
valeyev 0:e056ac8fecf8 585 /** Cancels the most recently posted event
valeyev 0:e056ac8fecf8 586 *
valeyev 0:e056ac8fecf8 587 * Attempts to cancel the most recently posted event. It is safe to call
valeyev 0:e056ac8fecf8 588 * cancel after an event has already been dispatched.
valeyev 0:e056ac8fecf8 589 *
valeyev 0:e056ac8fecf8 590 * The cancel function is irq safe.
valeyev 0:e056ac8fecf8 591 *
valeyev 0:e056ac8fecf8 592 * If called while the event queue's dispatch loop is active, the cancel
valeyev 0:e056ac8fecf8 593 * function does not garuntee that the event will not execute after it
valeyev 0:e056ac8fecf8 594 * returns, as the event may have already begun executing.
valeyev 0:e056ac8fecf8 595 */
valeyev 0:e056ac8fecf8 596 void cancel() const {
valeyev 0:e056ac8fecf8 597 if (_event) {
valeyev 0:e056ac8fecf8 598 equeue_cancel(_event->equeue, _event->id);
valeyev 0:e056ac8fecf8 599 }
valeyev 0:e056ac8fecf8 600 }
valeyev 0:e056ac8fecf8 601
valeyev 0:e056ac8fecf8 602 private:
valeyev 0:e056ac8fecf8 603 struct event {
valeyev 0:e056ac8fecf8 604 unsigned ref;
valeyev 0:e056ac8fecf8 605 equeue_t *equeue;
valeyev 0:e056ac8fecf8 606 int id;
valeyev 0:e056ac8fecf8 607
valeyev 0:e056ac8fecf8 608 int delay;
valeyev 0:e056ac8fecf8 609 int period;
valeyev 0:e056ac8fecf8 610
valeyev 0:e056ac8fecf8 611 int (*post)(struct event *, A0 a0);
valeyev 0:e056ac8fecf8 612 void (*dtor)(struct event *);
valeyev 0:e056ac8fecf8 613
valeyev 0:e056ac8fecf8 614 // F follows
valeyev 0:e056ac8fecf8 615 } *_event;
valeyev 0:e056ac8fecf8 616
valeyev 0:e056ac8fecf8 617 // Event attributes
valeyev 0:e056ac8fecf8 618 template <typename F>
valeyev 0:e056ac8fecf8 619 static int event_post(struct event *e, A0 a0) {
valeyev 0:e056ac8fecf8 620 typedef EventQueue::context10<F, A0> C;
valeyev 0:e056ac8fecf8 621 void *p = equeue_alloc(e->equeue, sizeof(C));
valeyev 0:e056ac8fecf8 622 if (!p) {
valeyev 0:e056ac8fecf8 623 return 0;
valeyev 0:e056ac8fecf8 624 }
valeyev 0:e056ac8fecf8 625
valeyev 0:e056ac8fecf8 626 new (p) C(*(F*)(e + 1), a0);
valeyev 0:e056ac8fecf8 627 equeue_event_delay(p, e->delay);
valeyev 0:e056ac8fecf8 628 equeue_event_period(p, e->period);
valeyev 0:e056ac8fecf8 629 equeue_event_dtor(p, &EventQueue::function_dtor<C>);
valeyev 0:e056ac8fecf8 630 return equeue_post(e->equeue, &EventQueue::function_call<C>, p);
valeyev 0:e056ac8fecf8 631 }
valeyev 0:e056ac8fecf8 632
valeyev 0:e056ac8fecf8 633 template <typename F>
valeyev 0:e056ac8fecf8 634 static void event_dtor(struct event *e) {
valeyev 0:e056ac8fecf8 635 ((F*)(e + 1))->~F();
valeyev 0:e056ac8fecf8 636 }
valeyev 0:e056ac8fecf8 637
valeyev 0:e056ac8fecf8 638 public:
valeyev 0:e056ac8fecf8 639 /** Create an event
valeyev 0:e056ac8fecf8 640 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 641 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 642 * @param c0 Argument to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 643 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 644 * memory pool. Must be type-compatible with b0, the
valeyev 0:e056ac8fecf8 645 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 646 */
valeyev 0:e056ac8fecf8 647 template <typename F, typename C0>
valeyev 0:e056ac8fecf8 648 Event(EventQueue *q, F f, C0 c0) {
valeyev 0:e056ac8fecf8 649 new (this) Event(q, EventQueue::context11<F, C0, A0>(f, c0));
valeyev 0:e056ac8fecf8 650 }
valeyev 0:e056ac8fecf8 651
valeyev 0:e056ac8fecf8 652 /** Create an event
valeyev 0:e056ac8fecf8 653 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 654 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 655 * @param c0,c1 Arguments to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 656 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 657 * memory pool. Must be type-compatible with b0..b1, the
valeyev 0:e056ac8fecf8 658 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 659 */
valeyev 0:e056ac8fecf8 660 template <typename F, typename C0, typename C1>
valeyev 0:e056ac8fecf8 661 Event(EventQueue *q, F f, C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 662 new (this) Event(q, EventQueue::context21<F, C0, C1, A0>(f, c0, c1));
valeyev 0:e056ac8fecf8 663 }
valeyev 0:e056ac8fecf8 664
valeyev 0:e056ac8fecf8 665 /** Create an event
valeyev 0:e056ac8fecf8 666 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 667 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 668 * @param c0,c1,c2 Arguments to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 669 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 670 * memory pool. Must be type-compatible with b0..b2, the
valeyev 0:e056ac8fecf8 671 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 672 */
valeyev 0:e056ac8fecf8 673 template <typename F, typename C0, typename C1, typename C2>
valeyev 0:e056ac8fecf8 674 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2) {
valeyev 0:e056ac8fecf8 675 new (this) Event(q, EventQueue::context31<F, C0, C1, C2, A0>(f, c0, c1, c2));
valeyev 0:e056ac8fecf8 676 }
valeyev 0:e056ac8fecf8 677
valeyev 0:e056ac8fecf8 678 /** Create an event
valeyev 0:e056ac8fecf8 679 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 680 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 681 * @param c0,c1,c2,c3 Arguments to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 682 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 683 * memory pool. Must be type-compatible with b0..b3, the
valeyev 0:e056ac8fecf8 684 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 685 */
valeyev 0:e056ac8fecf8 686 template <typename F, typename C0, typename C1, typename C2, typename C3>
valeyev 0:e056ac8fecf8 687 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3) {
valeyev 0:e056ac8fecf8 688 new (this) Event(q, EventQueue::context41<F, C0, C1, C2, C3, A0>(f, c0, c1, c2, c3));
valeyev 0:e056ac8fecf8 689 }
valeyev 0:e056ac8fecf8 690
valeyev 0:e056ac8fecf8 691 /** Create an event
valeyev 0:e056ac8fecf8 692 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 693 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 694 * @param c0,c1,c2,c3,c4 Arguments to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 695 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 696 * memory pool. Must be type-compatible with b0..b4, the
valeyev 0:e056ac8fecf8 697 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 698 */
valeyev 0:e056ac8fecf8 699 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4>
valeyev 0:e056ac8fecf8 700 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {
valeyev 0:e056ac8fecf8 701 new (this) Event(q, EventQueue::context51<F, C0, C1, C2, C3, C4, A0>(f, c0, c1, c2, c3, c4));
valeyev 0:e056ac8fecf8 702 }
valeyev 0:e056ac8fecf8 703
valeyev 0:e056ac8fecf8 704 /** Create an event
valeyev 0:e056ac8fecf8 705 * @see Event::Event
valeyev 0:e056ac8fecf8 706 */
valeyev 0:e056ac8fecf8 707 template <typename T, typename R, typename B0>
valeyev 0:e056ac8fecf8 708 Event(EventQueue *q, T *obj, R (T::*method)(B0, A0), B0 b0) {
valeyev 0:e056ac8fecf8 709 new (this) Event(q, mbed::callback(obj, method), b0);
valeyev 0:e056ac8fecf8 710 }
valeyev 0:e056ac8fecf8 711
valeyev 0:e056ac8fecf8 712 /** Create an event
valeyev 0:e056ac8fecf8 713 * @see Event::Event
valeyev 0:e056ac8fecf8 714 */
valeyev 0:e056ac8fecf8 715 template <typename T, typename R, typename B0>
valeyev 0:e056ac8fecf8 716 Event(EventQueue *q, const T *obj, R (T::*method)(B0, A0) const, B0 b0) {
valeyev 0:e056ac8fecf8 717 new (this) Event(q, mbed::callback(obj, method), b0);
valeyev 0:e056ac8fecf8 718 }
valeyev 0:e056ac8fecf8 719
valeyev 0:e056ac8fecf8 720 /** Create an event
valeyev 0:e056ac8fecf8 721 * @see Event::Event
valeyev 0:e056ac8fecf8 722 */
valeyev 0:e056ac8fecf8 723 template <typename T, typename R, typename B0>
valeyev 0:e056ac8fecf8 724 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, A0) volatile, B0 b0) {
valeyev 0:e056ac8fecf8 725 new (this) Event(q, mbed::callback(obj, method), b0);
valeyev 0:e056ac8fecf8 726 }
valeyev 0:e056ac8fecf8 727
valeyev 0:e056ac8fecf8 728 /** Create an event
valeyev 0:e056ac8fecf8 729 * @see Event::Event
valeyev 0:e056ac8fecf8 730 */
valeyev 0:e056ac8fecf8 731 template <typename T, typename R, typename B0>
valeyev 0:e056ac8fecf8 732 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, A0) const volatile, B0 b0) {
valeyev 0:e056ac8fecf8 733 new (this) Event(q, mbed::callback(obj, method), b0);
valeyev 0:e056ac8fecf8 734 }
valeyev 0:e056ac8fecf8 735
valeyev 0:e056ac8fecf8 736 /** Create an event
valeyev 0:e056ac8fecf8 737 * @see Event::Event
valeyev 0:e056ac8fecf8 738 */
valeyev 0:e056ac8fecf8 739 template <typename T, typename R, typename B0, typename B1>
valeyev 0:e056ac8fecf8 740 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, A0), B0 b0, B1 b1) {
valeyev 0:e056ac8fecf8 741 new (this) Event(q, mbed::callback(obj, method), b0, b1);
valeyev 0:e056ac8fecf8 742 }
valeyev 0:e056ac8fecf8 743
valeyev 0:e056ac8fecf8 744 /** Create an event
valeyev 0:e056ac8fecf8 745 * @see Event::Event
valeyev 0:e056ac8fecf8 746 */
valeyev 0:e056ac8fecf8 747 template <typename T, typename R, typename B0, typename B1>
valeyev 0:e056ac8fecf8 748 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, A0) const, B0 b0, B1 b1) {
valeyev 0:e056ac8fecf8 749 new (this) Event(q, mbed::callback(obj, method), b0, b1);
valeyev 0:e056ac8fecf8 750 }
valeyev 0:e056ac8fecf8 751
valeyev 0:e056ac8fecf8 752 /** Create an event
valeyev 0:e056ac8fecf8 753 * @see Event::Event
valeyev 0:e056ac8fecf8 754 */
valeyev 0:e056ac8fecf8 755 template <typename T, typename R, typename B0, typename B1>
valeyev 0:e056ac8fecf8 756 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, A0) volatile, B0 b0, B1 b1) {
valeyev 0:e056ac8fecf8 757 new (this) Event(q, mbed::callback(obj, method), b0, b1);
valeyev 0:e056ac8fecf8 758 }
valeyev 0:e056ac8fecf8 759
valeyev 0:e056ac8fecf8 760 /** Create an event
valeyev 0:e056ac8fecf8 761 * @see Event::Event
valeyev 0:e056ac8fecf8 762 */
valeyev 0:e056ac8fecf8 763 template <typename T, typename R, typename B0, typename B1>
valeyev 0:e056ac8fecf8 764 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, A0) const volatile, B0 b0, B1 b1) {
valeyev 0:e056ac8fecf8 765 new (this) Event(q, mbed::callback(obj, method), b0, b1);
valeyev 0:e056ac8fecf8 766 }
valeyev 0:e056ac8fecf8 767
valeyev 0:e056ac8fecf8 768 /** Create an event
valeyev 0:e056ac8fecf8 769 * @see Event::Event
valeyev 0:e056ac8fecf8 770 */
valeyev 0:e056ac8fecf8 771 template <typename T, typename R, typename B0, typename B1, typename B2>
valeyev 0:e056ac8fecf8 772 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, A0), B0 b0, B1 b1, B2 b2) {
valeyev 0:e056ac8fecf8 773 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
valeyev 0:e056ac8fecf8 774 }
valeyev 0:e056ac8fecf8 775
valeyev 0:e056ac8fecf8 776 /** Create an event
valeyev 0:e056ac8fecf8 777 * @see Event::Event
valeyev 0:e056ac8fecf8 778 */
valeyev 0:e056ac8fecf8 779 template <typename T, typename R, typename B0, typename B1, typename B2>
valeyev 0:e056ac8fecf8 780 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, B2, A0) const, B0 b0, B1 b1, B2 b2) {
valeyev 0:e056ac8fecf8 781 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
valeyev 0:e056ac8fecf8 782 }
valeyev 0:e056ac8fecf8 783
valeyev 0:e056ac8fecf8 784 /** Create an event
valeyev 0:e056ac8fecf8 785 * @see Event::Event
valeyev 0:e056ac8fecf8 786 */
valeyev 0:e056ac8fecf8 787 template <typename T, typename R, typename B0, typename B1, typename B2>
valeyev 0:e056ac8fecf8 788 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, B2, A0) volatile, B0 b0, B1 b1, B2 b2) {
valeyev 0:e056ac8fecf8 789 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
valeyev 0:e056ac8fecf8 790 }
valeyev 0:e056ac8fecf8 791
valeyev 0:e056ac8fecf8 792 /** Create an event
valeyev 0:e056ac8fecf8 793 * @see Event::Event
valeyev 0:e056ac8fecf8 794 */
valeyev 0:e056ac8fecf8 795 template <typename T, typename R, typename B0, typename B1, typename B2>
valeyev 0:e056ac8fecf8 796 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, B2, A0) const volatile, B0 b0, B1 b1, B2 b2) {
valeyev 0:e056ac8fecf8 797 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
valeyev 0:e056ac8fecf8 798 }
valeyev 0:e056ac8fecf8 799
valeyev 0:e056ac8fecf8 800 /** Create an event
valeyev 0:e056ac8fecf8 801 * @see Event::Event
valeyev 0:e056ac8fecf8 802 */
valeyev 0:e056ac8fecf8 803 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
valeyev 0:e056ac8fecf8 804 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, B3, A0), B0 b0, B1 b1, B2 b2, B3 b3) {
valeyev 0:e056ac8fecf8 805 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
valeyev 0:e056ac8fecf8 806 }
valeyev 0:e056ac8fecf8 807
valeyev 0:e056ac8fecf8 808 /** Create an event
valeyev 0:e056ac8fecf8 809 * @see Event::Event
valeyev 0:e056ac8fecf8 810 */
valeyev 0:e056ac8fecf8 811 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
valeyev 0:e056ac8fecf8 812 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, B2, B3, A0) const, B0 b0, B1 b1, B2 b2, B3 b3) {
valeyev 0:e056ac8fecf8 813 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
valeyev 0:e056ac8fecf8 814 }
valeyev 0:e056ac8fecf8 815
valeyev 0:e056ac8fecf8 816 /** Create an event
valeyev 0:e056ac8fecf8 817 * @see Event::Event
valeyev 0:e056ac8fecf8 818 */
valeyev 0:e056ac8fecf8 819 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
valeyev 0:e056ac8fecf8 820 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0) volatile, B0 b0, B1 b1, B2 b2, B3 b3) {
valeyev 0:e056ac8fecf8 821 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
valeyev 0:e056ac8fecf8 822 }
valeyev 0:e056ac8fecf8 823
valeyev 0:e056ac8fecf8 824 /** Create an event
valeyev 0:e056ac8fecf8 825 * @see Event::Event
valeyev 0:e056ac8fecf8 826 */
valeyev 0:e056ac8fecf8 827 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
valeyev 0:e056ac8fecf8 828 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) {
valeyev 0:e056ac8fecf8 829 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
valeyev 0:e056ac8fecf8 830 }
valeyev 0:e056ac8fecf8 831
valeyev 0:e056ac8fecf8 832 /** Create an event
valeyev 0:e056ac8fecf8 833 * @see Event::Event
valeyev 0:e056ac8fecf8 834 */
valeyev 0:e056ac8fecf8 835 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
valeyev 0:e056ac8fecf8 836 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0), B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) {
valeyev 0:e056ac8fecf8 837 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
valeyev 0:e056ac8fecf8 838 }
valeyev 0:e056ac8fecf8 839
valeyev 0:e056ac8fecf8 840 /** Create an event
valeyev 0:e056ac8fecf8 841 * @see Event::Event
valeyev 0:e056ac8fecf8 842 */
valeyev 0:e056ac8fecf8 843 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
valeyev 0:e056ac8fecf8 844 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) {
valeyev 0:e056ac8fecf8 845 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
valeyev 0:e056ac8fecf8 846 }
valeyev 0:e056ac8fecf8 847
valeyev 0:e056ac8fecf8 848 /** Create an event
valeyev 0:e056ac8fecf8 849 * @see Event::Event
valeyev 0:e056ac8fecf8 850 */
valeyev 0:e056ac8fecf8 851 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
valeyev 0:e056ac8fecf8 852 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) {
valeyev 0:e056ac8fecf8 853 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
valeyev 0:e056ac8fecf8 854 }
valeyev 0:e056ac8fecf8 855
valeyev 0:e056ac8fecf8 856 /** Create an event
valeyev 0:e056ac8fecf8 857 * @see Event::Event
valeyev 0:e056ac8fecf8 858 */
valeyev 0:e056ac8fecf8 859 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
valeyev 0:e056ac8fecf8 860 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) {
valeyev 0:e056ac8fecf8 861 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
valeyev 0:e056ac8fecf8 862 }
valeyev 0:e056ac8fecf8 863 };
valeyev 0:e056ac8fecf8 864
valeyev 0:e056ac8fecf8 865 /** Event
valeyev 0:e056ac8fecf8 866 *
valeyev 0:e056ac8fecf8 867 * Representation of an event for fine-grain dispatch control
valeyev 0:e056ac8fecf8 868 * @ingroup events
valeyev 0:e056ac8fecf8 869 */
valeyev 0:e056ac8fecf8 870 template <typename A0, typename A1>
valeyev 0:e056ac8fecf8 871 class Event<void(A0, A1)> {
valeyev 0:e056ac8fecf8 872 public:
valeyev 0:e056ac8fecf8 873 /** Create an event
valeyev 0:e056ac8fecf8 874 *
valeyev 0:e056ac8fecf8 875 * Constructs an event bound to the specified event queue. The specified
valeyev 0:e056ac8fecf8 876 * callback acts as the target for the event and is executed in the
valeyev 0:e056ac8fecf8 877 * context of the event queue's dispatch loop once posted.
valeyev 0:e056ac8fecf8 878 *
valeyev 0:e056ac8fecf8 879 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 880 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 881 */
valeyev 0:e056ac8fecf8 882 template <typename F>
valeyev 0:e056ac8fecf8 883 Event(EventQueue *q, F f) {
valeyev 0:e056ac8fecf8 884 _event = static_cast<struct event *>(
valeyev 0:e056ac8fecf8 885 equeue_alloc(&q->_equeue, sizeof(struct event) + sizeof(F)));
valeyev 0:e056ac8fecf8 886
valeyev 0:e056ac8fecf8 887 if (_event) {
valeyev 0:e056ac8fecf8 888 _event->equeue = &q->_equeue;
valeyev 0:e056ac8fecf8 889 _event->id = 0;
valeyev 0:e056ac8fecf8 890 _event->delay = 0;
valeyev 0:e056ac8fecf8 891 _event->period = -1;
valeyev 0:e056ac8fecf8 892
valeyev 0:e056ac8fecf8 893 _event->post = &Event::event_post<F>;
valeyev 0:e056ac8fecf8 894 _event->dtor = &Event::event_dtor<F>;
valeyev 0:e056ac8fecf8 895
valeyev 0:e056ac8fecf8 896 new (_event+1) F(f);
valeyev 0:e056ac8fecf8 897
valeyev 0:e056ac8fecf8 898 _event->ref = 1;
valeyev 0:e056ac8fecf8 899 }
valeyev 0:e056ac8fecf8 900 }
valeyev 0:e056ac8fecf8 901
valeyev 0:e056ac8fecf8 902 /** Copy constructor for events
valeyev 0:e056ac8fecf8 903 */
valeyev 0:e056ac8fecf8 904 Event(const Event &e) {
valeyev 0:e056ac8fecf8 905 _event = 0;
valeyev 0:e056ac8fecf8 906 if (e._event) {
valeyev 0:e056ac8fecf8 907 _event = e._event;
valeyev 0:e056ac8fecf8 908 _event->ref += 1;
valeyev 0:e056ac8fecf8 909 }
valeyev 0:e056ac8fecf8 910 }
valeyev 0:e056ac8fecf8 911
valeyev 0:e056ac8fecf8 912 /** Assignment operator for events
valeyev 0:e056ac8fecf8 913 */
valeyev 0:e056ac8fecf8 914 Event &operator=(const Event &that) {
valeyev 0:e056ac8fecf8 915 if (this != &that) {
valeyev 0:e056ac8fecf8 916 this->~Event();
valeyev 0:e056ac8fecf8 917 new (this) Event(that);
valeyev 0:e056ac8fecf8 918 }
valeyev 0:e056ac8fecf8 919
valeyev 0:e056ac8fecf8 920 return *this;
valeyev 0:e056ac8fecf8 921 }
valeyev 0:e056ac8fecf8 922
valeyev 0:e056ac8fecf8 923 /** Destructor for events
valeyev 0:e056ac8fecf8 924 */
valeyev 0:e056ac8fecf8 925 ~Event() {
valeyev 0:e056ac8fecf8 926 if (_event) {
valeyev 0:e056ac8fecf8 927 _event->ref -= 1;
valeyev 0:e056ac8fecf8 928 if (_event->ref == 0) {
valeyev 0:e056ac8fecf8 929 _event->dtor(_event);
valeyev 0:e056ac8fecf8 930 equeue_dealloc(_event->equeue, _event);
valeyev 0:e056ac8fecf8 931 }
valeyev 0:e056ac8fecf8 932 }
valeyev 0:e056ac8fecf8 933 }
valeyev 0:e056ac8fecf8 934
valeyev 0:e056ac8fecf8 935 /** Configure the delay of an event
valeyev 0:e056ac8fecf8 936 *
valeyev 0:e056ac8fecf8 937 * @param delay Millisecond delay before dispatching the event
valeyev 0:e056ac8fecf8 938 */
valeyev 0:e056ac8fecf8 939 void delay(int delay) {
valeyev 0:e056ac8fecf8 940 if (_event) {
valeyev 0:e056ac8fecf8 941 _event->delay = delay;
valeyev 0:e056ac8fecf8 942 }
valeyev 0:e056ac8fecf8 943 }
valeyev 0:e056ac8fecf8 944
valeyev 0:e056ac8fecf8 945 /** Configure the period of an event
valeyev 0:e056ac8fecf8 946 *
valeyev 0:e056ac8fecf8 947 * @param period Millisecond period for repeatedly dispatching an event
valeyev 0:e056ac8fecf8 948 */
valeyev 0:e056ac8fecf8 949 void period(int period) {
valeyev 0:e056ac8fecf8 950 if (_event) {
valeyev 0:e056ac8fecf8 951 _event->period = period;
valeyev 0:e056ac8fecf8 952 }
valeyev 0:e056ac8fecf8 953 }
valeyev 0:e056ac8fecf8 954
valeyev 0:e056ac8fecf8 955 /** Posts an event onto the underlying event queue
valeyev 0:e056ac8fecf8 956 *
valeyev 0:e056ac8fecf8 957 * The event is posted to the underlying queue and is executed in the
valeyev 0:e056ac8fecf8 958 * context of the event queue's dispatch loop.
valeyev 0:e056ac8fecf8 959 *
valeyev 0:e056ac8fecf8 960 * The post function is irq safe and can act as a mechanism for moving
valeyev 0:e056ac8fecf8 961 * events out of irq contexts.
valeyev 0:e056ac8fecf8 962 *
valeyev 0:e056ac8fecf8 963 * @param a0,a1 Arguments to pass to the event
valeyev 0:e056ac8fecf8 964 * @return A unique id that represents the posted event and can
valeyev 0:e056ac8fecf8 965 * be passed to EventQueue::cancel, or an id of 0 if
valeyev 0:e056ac8fecf8 966 * there is not enough memory to allocate the event.
valeyev 0:e056ac8fecf8 967 */
valeyev 0:e056ac8fecf8 968 int post(A0 a0, A1 a1) const {
valeyev 0:e056ac8fecf8 969 if (!_event) {
valeyev 0:e056ac8fecf8 970 return 0;
valeyev 0:e056ac8fecf8 971 }
valeyev 0:e056ac8fecf8 972
valeyev 0:e056ac8fecf8 973 _event->id = _event->post(_event, a0, a1);
valeyev 0:e056ac8fecf8 974 return _event->id;
valeyev 0:e056ac8fecf8 975 }
valeyev 0:e056ac8fecf8 976
valeyev 0:e056ac8fecf8 977 /** Posts an event onto the underlying event queue, returning void
valeyev 0:e056ac8fecf8 978 *
valeyev 0:e056ac8fecf8 979 * @param a0,a1 Arguments to pass to the event
valeyev 0:e056ac8fecf8 980 */
valeyev 0:e056ac8fecf8 981 void call(A0 a0, A1 a1) const {
valeyev 0:e056ac8fecf8 982 MBED_UNUSED int id = post(a0, a1);
valeyev 0:e056ac8fecf8 983 MBED_ASSERT(id);
valeyev 0:e056ac8fecf8 984 }
valeyev 0:e056ac8fecf8 985
valeyev 0:e056ac8fecf8 986 /** Posts an event onto the underlying event queue, returning void
valeyev 0:e056ac8fecf8 987 *
valeyev 0:e056ac8fecf8 988 * @param a0,a1 Arguments to pass to the event
valeyev 0:e056ac8fecf8 989 */
valeyev 0:e056ac8fecf8 990 void operator()(A0 a0, A1 a1) const {
valeyev 0:e056ac8fecf8 991 return call(a0, a1);
valeyev 0:e056ac8fecf8 992 }
valeyev 0:e056ac8fecf8 993
valeyev 0:e056ac8fecf8 994 /** Static thunk for passing as C-style function
valeyev 0:e056ac8fecf8 995 *
valeyev 0:e056ac8fecf8 996 * @param func Event to call passed as a void pointer
valeyev 0:e056ac8fecf8 997 * @param a0,a1 Arguments to pass to the event
valeyev 0:e056ac8fecf8 998 */
valeyev 0:e056ac8fecf8 999 static void thunk(void *func, A0 a0, A1 a1) {
valeyev 0:e056ac8fecf8 1000 return static_cast<Event*>(func)->call(a0, a1);
valeyev 0:e056ac8fecf8 1001 }
valeyev 0:e056ac8fecf8 1002
valeyev 0:e056ac8fecf8 1003 /** Cancels the most recently posted event
valeyev 0:e056ac8fecf8 1004 *
valeyev 0:e056ac8fecf8 1005 * Attempts to cancel the most recently posted event. It is safe to call
valeyev 0:e056ac8fecf8 1006 * cancel after an event has already been dispatched.
valeyev 0:e056ac8fecf8 1007 *
valeyev 0:e056ac8fecf8 1008 * The cancel function is irq safe.
valeyev 0:e056ac8fecf8 1009 *
valeyev 0:e056ac8fecf8 1010 * If called while the event queue's dispatch loop is active, the cancel
valeyev 0:e056ac8fecf8 1011 * function does not garuntee that the event will not execute after it
valeyev 0:e056ac8fecf8 1012 * returns, as the event may have already begun executing.
valeyev 0:e056ac8fecf8 1013 */
valeyev 0:e056ac8fecf8 1014 void cancel() const {
valeyev 0:e056ac8fecf8 1015 if (_event) {
valeyev 0:e056ac8fecf8 1016 equeue_cancel(_event->equeue, _event->id);
valeyev 0:e056ac8fecf8 1017 }
valeyev 0:e056ac8fecf8 1018 }
valeyev 0:e056ac8fecf8 1019
valeyev 0:e056ac8fecf8 1020 private:
valeyev 0:e056ac8fecf8 1021 struct event {
valeyev 0:e056ac8fecf8 1022 unsigned ref;
valeyev 0:e056ac8fecf8 1023 equeue_t *equeue;
valeyev 0:e056ac8fecf8 1024 int id;
valeyev 0:e056ac8fecf8 1025
valeyev 0:e056ac8fecf8 1026 int delay;
valeyev 0:e056ac8fecf8 1027 int period;
valeyev 0:e056ac8fecf8 1028
valeyev 0:e056ac8fecf8 1029 int (*post)(struct event *, A0 a0, A1 a1);
valeyev 0:e056ac8fecf8 1030 void (*dtor)(struct event *);
valeyev 0:e056ac8fecf8 1031
valeyev 0:e056ac8fecf8 1032 // F follows
valeyev 0:e056ac8fecf8 1033 } *_event;
valeyev 0:e056ac8fecf8 1034
valeyev 0:e056ac8fecf8 1035 // Event attributes
valeyev 0:e056ac8fecf8 1036 template <typename F>
valeyev 0:e056ac8fecf8 1037 static int event_post(struct event *e, A0 a0, A1 a1) {
valeyev 0:e056ac8fecf8 1038 typedef EventQueue::context20<F, A0, A1> C;
valeyev 0:e056ac8fecf8 1039 void *p = equeue_alloc(e->equeue, sizeof(C));
valeyev 0:e056ac8fecf8 1040 if (!p) {
valeyev 0:e056ac8fecf8 1041 return 0;
valeyev 0:e056ac8fecf8 1042 }
valeyev 0:e056ac8fecf8 1043
valeyev 0:e056ac8fecf8 1044 new (p) C(*(F*)(e + 1), a0, a1);
valeyev 0:e056ac8fecf8 1045 equeue_event_delay(p, e->delay);
valeyev 0:e056ac8fecf8 1046 equeue_event_period(p, e->period);
valeyev 0:e056ac8fecf8 1047 equeue_event_dtor(p, &EventQueue::function_dtor<C>);
valeyev 0:e056ac8fecf8 1048 return equeue_post(e->equeue, &EventQueue::function_call<C>, p);
valeyev 0:e056ac8fecf8 1049 }
valeyev 0:e056ac8fecf8 1050
valeyev 0:e056ac8fecf8 1051 template <typename F>
valeyev 0:e056ac8fecf8 1052 static void event_dtor(struct event *e) {
valeyev 0:e056ac8fecf8 1053 ((F*)(e + 1))->~F();
valeyev 0:e056ac8fecf8 1054 }
valeyev 0:e056ac8fecf8 1055
valeyev 0:e056ac8fecf8 1056 public:
valeyev 0:e056ac8fecf8 1057 /** Create an event
valeyev 0:e056ac8fecf8 1058 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 1059 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 1060 * @param c0 Argument to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 1061 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 1062 * memory pool. Must be type-compatible with b0, the
valeyev 0:e056ac8fecf8 1063 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 1064 */
valeyev 0:e056ac8fecf8 1065 template <typename F, typename C0>
valeyev 0:e056ac8fecf8 1066 Event(EventQueue *q, F f, C0 c0) {
valeyev 0:e056ac8fecf8 1067 new (this) Event(q, EventQueue::context12<F, C0, A0, A1>(f, c0));
valeyev 0:e056ac8fecf8 1068 }
valeyev 0:e056ac8fecf8 1069
valeyev 0:e056ac8fecf8 1070 /** Create an event
valeyev 0:e056ac8fecf8 1071 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 1072 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 1073 * @param c0,c1 Arguments to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 1074 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 1075 * memory pool. Must be type-compatible with b0..b1, the
valeyev 0:e056ac8fecf8 1076 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 1077 */
valeyev 0:e056ac8fecf8 1078 template <typename F, typename C0, typename C1>
valeyev 0:e056ac8fecf8 1079 Event(EventQueue *q, F f, C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 1080 new (this) Event(q, EventQueue::context22<F, C0, C1, A0, A1>(f, c0, c1));
valeyev 0:e056ac8fecf8 1081 }
valeyev 0:e056ac8fecf8 1082
valeyev 0:e056ac8fecf8 1083 /** Create an event
valeyev 0:e056ac8fecf8 1084 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 1085 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 1086 * @param c0,c1,c2 Arguments to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 1087 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 1088 * memory pool. Must be type-compatible with b0..b2, the
valeyev 0:e056ac8fecf8 1089 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 1090 */
valeyev 0:e056ac8fecf8 1091 template <typename F, typename C0, typename C1, typename C2>
valeyev 0:e056ac8fecf8 1092 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2) {
valeyev 0:e056ac8fecf8 1093 new (this) Event(q, EventQueue::context32<F, C0, C1, C2, A0, A1>(f, c0, c1, c2));
valeyev 0:e056ac8fecf8 1094 }
valeyev 0:e056ac8fecf8 1095
valeyev 0:e056ac8fecf8 1096 /** Create an event
valeyev 0:e056ac8fecf8 1097 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 1098 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 1099 * @param c0,c1,c2,c3 Arguments to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 1100 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 1101 * memory pool. Must be type-compatible with b0..b3, the
valeyev 0:e056ac8fecf8 1102 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 1103 */
valeyev 0:e056ac8fecf8 1104 template <typename F, typename C0, typename C1, typename C2, typename C3>
valeyev 0:e056ac8fecf8 1105 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3) {
valeyev 0:e056ac8fecf8 1106 new (this) Event(q, EventQueue::context42<F, C0, C1, C2, C3, A0, A1>(f, c0, c1, c2, c3));
valeyev 0:e056ac8fecf8 1107 }
valeyev 0:e056ac8fecf8 1108
valeyev 0:e056ac8fecf8 1109 /** Create an event
valeyev 0:e056ac8fecf8 1110 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 1111 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 1112 * @param c0,c1,c2,c3,c4 Arguments to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 1113 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 1114 * memory pool. Must be type-compatible with b0..b4, the
valeyev 0:e056ac8fecf8 1115 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 1116 */
valeyev 0:e056ac8fecf8 1117 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4>
valeyev 0:e056ac8fecf8 1118 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {
valeyev 0:e056ac8fecf8 1119 new (this) Event(q, EventQueue::context52<F, C0, C1, C2, C3, C4, A0, A1>(f, c0, c1, c2, c3, c4));
valeyev 0:e056ac8fecf8 1120 }
valeyev 0:e056ac8fecf8 1121
valeyev 0:e056ac8fecf8 1122 /** Create an event
valeyev 0:e056ac8fecf8 1123 * @see Event::Event
valeyev 0:e056ac8fecf8 1124 */
valeyev 0:e056ac8fecf8 1125 template <typename T, typename R, typename B0>
valeyev 0:e056ac8fecf8 1126 Event(EventQueue *q, T *obj, R (T::*method)(B0, A0, A1), B0 b0) {
valeyev 0:e056ac8fecf8 1127 new (this) Event(q, mbed::callback(obj, method), b0);
valeyev 0:e056ac8fecf8 1128 }
valeyev 0:e056ac8fecf8 1129
valeyev 0:e056ac8fecf8 1130 /** Create an event
valeyev 0:e056ac8fecf8 1131 * @see Event::Event
valeyev 0:e056ac8fecf8 1132 */
valeyev 0:e056ac8fecf8 1133 template <typename T, typename R, typename B0>
valeyev 0:e056ac8fecf8 1134 Event(EventQueue *q, const T *obj, R (T::*method)(B0, A0, A1) const, B0 b0) {
valeyev 0:e056ac8fecf8 1135 new (this) Event(q, mbed::callback(obj, method), b0);
valeyev 0:e056ac8fecf8 1136 }
valeyev 0:e056ac8fecf8 1137
valeyev 0:e056ac8fecf8 1138 /** Create an event
valeyev 0:e056ac8fecf8 1139 * @see Event::Event
valeyev 0:e056ac8fecf8 1140 */
valeyev 0:e056ac8fecf8 1141 template <typename T, typename R, typename B0>
valeyev 0:e056ac8fecf8 1142 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, A0, A1) volatile, B0 b0) {
valeyev 0:e056ac8fecf8 1143 new (this) Event(q, mbed::callback(obj, method), b0);
valeyev 0:e056ac8fecf8 1144 }
valeyev 0:e056ac8fecf8 1145
valeyev 0:e056ac8fecf8 1146 /** Create an event
valeyev 0:e056ac8fecf8 1147 * @see Event::Event
valeyev 0:e056ac8fecf8 1148 */
valeyev 0:e056ac8fecf8 1149 template <typename T, typename R, typename B0>
valeyev 0:e056ac8fecf8 1150 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, A0, A1) const volatile, B0 b0) {
valeyev 0:e056ac8fecf8 1151 new (this) Event(q, mbed::callback(obj, method), b0);
valeyev 0:e056ac8fecf8 1152 }
valeyev 0:e056ac8fecf8 1153
valeyev 0:e056ac8fecf8 1154 /** Create an event
valeyev 0:e056ac8fecf8 1155 * @see Event::Event
valeyev 0:e056ac8fecf8 1156 */
valeyev 0:e056ac8fecf8 1157 template <typename T, typename R, typename B0, typename B1>
valeyev 0:e056ac8fecf8 1158 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, A0, A1), B0 b0, B1 b1) {
valeyev 0:e056ac8fecf8 1159 new (this) Event(q, mbed::callback(obj, method), b0, b1);
valeyev 0:e056ac8fecf8 1160 }
valeyev 0:e056ac8fecf8 1161
valeyev 0:e056ac8fecf8 1162 /** Create an event
valeyev 0:e056ac8fecf8 1163 * @see Event::Event
valeyev 0:e056ac8fecf8 1164 */
valeyev 0:e056ac8fecf8 1165 template <typename T, typename R, typename B0, typename B1>
valeyev 0:e056ac8fecf8 1166 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, A0, A1) const, B0 b0, B1 b1) {
valeyev 0:e056ac8fecf8 1167 new (this) Event(q, mbed::callback(obj, method), b0, b1);
valeyev 0:e056ac8fecf8 1168 }
valeyev 0:e056ac8fecf8 1169
valeyev 0:e056ac8fecf8 1170 /** Create an event
valeyev 0:e056ac8fecf8 1171 * @see Event::Event
valeyev 0:e056ac8fecf8 1172 */
valeyev 0:e056ac8fecf8 1173 template <typename T, typename R, typename B0, typename B1>
valeyev 0:e056ac8fecf8 1174 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, A0, A1) volatile, B0 b0, B1 b1) {
valeyev 0:e056ac8fecf8 1175 new (this) Event(q, mbed::callback(obj, method), b0, b1);
valeyev 0:e056ac8fecf8 1176 }
valeyev 0:e056ac8fecf8 1177
valeyev 0:e056ac8fecf8 1178 /** Create an event
valeyev 0:e056ac8fecf8 1179 * @see Event::Event
valeyev 0:e056ac8fecf8 1180 */
valeyev 0:e056ac8fecf8 1181 template <typename T, typename R, typename B0, typename B1>
valeyev 0:e056ac8fecf8 1182 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, A0, A1) const volatile, B0 b0, B1 b1) {
valeyev 0:e056ac8fecf8 1183 new (this) Event(q, mbed::callback(obj, method), b0, b1);
valeyev 0:e056ac8fecf8 1184 }
valeyev 0:e056ac8fecf8 1185
valeyev 0:e056ac8fecf8 1186 /** Create an event
valeyev 0:e056ac8fecf8 1187 * @see Event::Event
valeyev 0:e056ac8fecf8 1188 */
valeyev 0:e056ac8fecf8 1189 template <typename T, typename R, typename B0, typename B1, typename B2>
valeyev 0:e056ac8fecf8 1190 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, A0, A1), B0 b0, B1 b1, B2 b2) {
valeyev 0:e056ac8fecf8 1191 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
valeyev 0:e056ac8fecf8 1192 }
valeyev 0:e056ac8fecf8 1193
valeyev 0:e056ac8fecf8 1194 /** Create an event
valeyev 0:e056ac8fecf8 1195 * @see Event::Event
valeyev 0:e056ac8fecf8 1196 */
valeyev 0:e056ac8fecf8 1197 template <typename T, typename R, typename B0, typename B1, typename B2>
valeyev 0:e056ac8fecf8 1198 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, B2, A0, A1) const, B0 b0, B1 b1, B2 b2) {
valeyev 0:e056ac8fecf8 1199 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
valeyev 0:e056ac8fecf8 1200 }
valeyev 0:e056ac8fecf8 1201
valeyev 0:e056ac8fecf8 1202 /** Create an event
valeyev 0:e056ac8fecf8 1203 * @see Event::Event
valeyev 0:e056ac8fecf8 1204 */
valeyev 0:e056ac8fecf8 1205 template <typename T, typename R, typename B0, typename B1, typename B2>
valeyev 0:e056ac8fecf8 1206 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1) volatile, B0 b0, B1 b1, B2 b2) {
valeyev 0:e056ac8fecf8 1207 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
valeyev 0:e056ac8fecf8 1208 }
valeyev 0:e056ac8fecf8 1209
valeyev 0:e056ac8fecf8 1210 /** Create an event
valeyev 0:e056ac8fecf8 1211 * @see Event::Event
valeyev 0:e056ac8fecf8 1212 */
valeyev 0:e056ac8fecf8 1213 template <typename T, typename R, typename B0, typename B1, typename B2>
valeyev 0:e056ac8fecf8 1214 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1) const volatile, B0 b0, B1 b1, B2 b2) {
valeyev 0:e056ac8fecf8 1215 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
valeyev 0:e056ac8fecf8 1216 }
valeyev 0:e056ac8fecf8 1217
valeyev 0:e056ac8fecf8 1218 /** Create an event
valeyev 0:e056ac8fecf8 1219 * @see Event::Event
valeyev 0:e056ac8fecf8 1220 */
valeyev 0:e056ac8fecf8 1221 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
valeyev 0:e056ac8fecf8 1222 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1), B0 b0, B1 b1, B2 b2, B3 b3) {
valeyev 0:e056ac8fecf8 1223 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
valeyev 0:e056ac8fecf8 1224 }
valeyev 0:e056ac8fecf8 1225
valeyev 0:e056ac8fecf8 1226 /** Create an event
valeyev 0:e056ac8fecf8 1227 * @see Event::Event
valeyev 0:e056ac8fecf8 1228 */
valeyev 0:e056ac8fecf8 1229 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
valeyev 0:e056ac8fecf8 1230 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1) const, B0 b0, B1 b1, B2 b2, B3 b3) {
valeyev 0:e056ac8fecf8 1231 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
valeyev 0:e056ac8fecf8 1232 }
valeyev 0:e056ac8fecf8 1233
valeyev 0:e056ac8fecf8 1234 /** Create an event
valeyev 0:e056ac8fecf8 1235 * @see Event::Event
valeyev 0:e056ac8fecf8 1236 */
valeyev 0:e056ac8fecf8 1237 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
valeyev 0:e056ac8fecf8 1238 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1) volatile, B0 b0, B1 b1, B2 b2, B3 b3) {
valeyev 0:e056ac8fecf8 1239 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
valeyev 0:e056ac8fecf8 1240 }
valeyev 0:e056ac8fecf8 1241
valeyev 0:e056ac8fecf8 1242 /** Create an event
valeyev 0:e056ac8fecf8 1243 * @see Event::Event
valeyev 0:e056ac8fecf8 1244 */
valeyev 0:e056ac8fecf8 1245 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
valeyev 0:e056ac8fecf8 1246 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) {
valeyev 0:e056ac8fecf8 1247 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
valeyev 0:e056ac8fecf8 1248 }
valeyev 0:e056ac8fecf8 1249
valeyev 0:e056ac8fecf8 1250 /** Create an event
valeyev 0:e056ac8fecf8 1251 * @see Event::Event
valeyev 0:e056ac8fecf8 1252 */
valeyev 0:e056ac8fecf8 1253 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
valeyev 0:e056ac8fecf8 1254 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) {
valeyev 0:e056ac8fecf8 1255 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
valeyev 0:e056ac8fecf8 1256 }
valeyev 0:e056ac8fecf8 1257
valeyev 0:e056ac8fecf8 1258 /** Create an event
valeyev 0:e056ac8fecf8 1259 * @see Event::Event
valeyev 0:e056ac8fecf8 1260 */
valeyev 0:e056ac8fecf8 1261 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
valeyev 0:e056ac8fecf8 1262 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) {
valeyev 0:e056ac8fecf8 1263 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
valeyev 0:e056ac8fecf8 1264 }
valeyev 0:e056ac8fecf8 1265
valeyev 0:e056ac8fecf8 1266 /** Create an event
valeyev 0:e056ac8fecf8 1267 * @see Event::Event
valeyev 0:e056ac8fecf8 1268 */
valeyev 0:e056ac8fecf8 1269 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
valeyev 0:e056ac8fecf8 1270 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) {
valeyev 0:e056ac8fecf8 1271 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
valeyev 0:e056ac8fecf8 1272 }
valeyev 0:e056ac8fecf8 1273
valeyev 0:e056ac8fecf8 1274 /** Create an event
valeyev 0:e056ac8fecf8 1275 * @see Event::Event
valeyev 0:e056ac8fecf8 1276 */
valeyev 0:e056ac8fecf8 1277 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
valeyev 0:e056ac8fecf8 1278 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) {
valeyev 0:e056ac8fecf8 1279 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
valeyev 0:e056ac8fecf8 1280 }
valeyev 0:e056ac8fecf8 1281 };
valeyev 0:e056ac8fecf8 1282
valeyev 0:e056ac8fecf8 1283 /** Event
valeyev 0:e056ac8fecf8 1284 *
valeyev 0:e056ac8fecf8 1285 * Representation of an event for fine-grain dispatch control
valeyev 0:e056ac8fecf8 1286 * @ingroup events
valeyev 0:e056ac8fecf8 1287 */
valeyev 0:e056ac8fecf8 1288 template <typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 1289 class Event<void(A0, A1, A2)> {
valeyev 0:e056ac8fecf8 1290 public:
valeyev 0:e056ac8fecf8 1291 /** Create an event
valeyev 0:e056ac8fecf8 1292 *
valeyev 0:e056ac8fecf8 1293 * Constructs an event bound to the specified event queue. The specified
valeyev 0:e056ac8fecf8 1294 * callback acts as the target for the event and is executed in the
valeyev 0:e056ac8fecf8 1295 * context of the event queue's dispatch loop once posted.
valeyev 0:e056ac8fecf8 1296 *
valeyev 0:e056ac8fecf8 1297 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 1298 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 1299 */
valeyev 0:e056ac8fecf8 1300 template <typename F>
valeyev 0:e056ac8fecf8 1301 Event(EventQueue *q, F f) {
valeyev 0:e056ac8fecf8 1302 _event = static_cast<struct event *>(
valeyev 0:e056ac8fecf8 1303 equeue_alloc(&q->_equeue, sizeof(struct event) + sizeof(F)));
valeyev 0:e056ac8fecf8 1304
valeyev 0:e056ac8fecf8 1305 if (_event) {
valeyev 0:e056ac8fecf8 1306 _event->equeue = &q->_equeue;
valeyev 0:e056ac8fecf8 1307 _event->id = 0;
valeyev 0:e056ac8fecf8 1308 _event->delay = 0;
valeyev 0:e056ac8fecf8 1309 _event->period = -1;
valeyev 0:e056ac8fecf8 1310
valeyev 0:e056ac8fecf8 1311 _event->post = &Event::event_post<F>;
valeyev 0:e056ac8fecf8 1312 _event->dtor = &Event::event_dtor<F>;
valeyev 0:e056ac8fecf8 1313
valeyev 0:e056ac8fecf8 1314 new (_event+1) F(f);
valeyev 0:e056ac8fecf8 1315
valeyev 0:e056ac8fecf8 1316 _event->ref = 1;
valeyev 0:e056ac8fecf8 1317 }
valeyev 0:e056ac8fecf8 1318 }
valeyev 0:e056ac8fecf8 1319
valeyev 0:e056ac8fecf8 1320 /** Copy constructor for events
valeyev 0:e056ac8fecf8 1321 */
valeyev 0:e056ac8fecf8 1322 Event(const Event &e) {
valeyev 0:e056ac8fecf8 1323 _event = 0;
valeyev 0:e056ac8fecf8 1324 if (e._event) {
valeyev 0:e056ac8fecf8 1325 _event = e._event;
valeyev 0:e056ac8fecf8 1326 _event->ref += 1;
valeyev 0:e056ac8fecf8 1327 }
valeyev 0:e056ac8fecf8 1328 }
valeyev 0:e056ac8fecf8 1329
valeyev 0:e056ac8fecf8 1330 /** Assignment operator for events
valeyev 0:e056ac8fecf8 1331 */
valeyev 0:e056ac8fecf8 1332 Event &operator=(const Event &that) {
valeyev 0:e056ac8fecf8 1333 if (this != &that) {
valeyev 0:e056ac8fecf8 1334 this->~Event();
valeyev 0:e056ac8fecf8 1335 new (this) Event(that);
valeyev 0:e056ac8fecf8 1336 }
valeyev 0:e056ac8fecf8 1337
valeyev 0:e056ac8fecf8 1338 return *this;
valeyev 0:e056ac8fecf8 1339 }
valeyev 0:e056ac8fecf8 1340
valeyev 0:e056ac8fecf8 1341 /** Destructor for events
valeyev 0:e056ac8fecf8 1342 */
valeyev 0:e056ac8fecf8 1343 ~Event() {
valeyev 0:e056ac8fecf8 1344 if (_event) {
valeyev 0:e056ac8fecf8 1345 _event->ref -= 1;
valeyev 0:e056ac8fecf8 1346 if (_event->ref == 0) {
valeyev 0:e056ac8fecf8 1347 _event->dtor(_event);
valeyev 0:e056ac8fecf8 1348 equeue_dealloc(_event->equeue, _event);
valeyev 0:e056ac8fecf8 1349 }
valeyev 0:e056ac8fecf8 1350 }
valeyev 0:e056ac8fecf8 1351 }
valeyev 0:e056ac8fecf8 1352
valeyev 0:e056ac8fecf8 1353 /** Configure the delay of an event
valeyev 0:e056ac8fecf8 1354 *
valeyev 0:e056ac8fecf8 1355 * @param delay Millisecond delay before dispatching the event
valeyev 0:e056ac8fecf8 1356 */
valeyev 0:e056ac8fecf8 1357 void delay(int delay) {
valeyev 0:e056ac8fecf8 1358 if (_event) {
valeyev 0:e056ac8fecf8 1359 _event->delay = delay;
valeyev 0:e056ac8fecf8 1360 }
valeyev 0:e056ac8fecf8 1361 }
valeyev 0:e056ac8fecf8 1362
valeyev 0:e056ac8fecf8 1363 /** Configure the period of an event
valeyev 0:e056ac8fecf8 1364 *
valeyev 0:e056ac8fecf8 1365 * @param period Millisecond period for repeatedly dispatching an event
valeyev 0:e056ac8fecf8 1366 */
valeyev 0:e056ac8fecf8 1367 void period(int period) {
valeyev 0:e056ac8fecf8 1368 if (_event) {
valeyev 0:e056ac8fecf8 1369 _event->period = period;
valeyev 0:e056ac8fecf8 1370 }
valeyev 0:e056ac8fecf8 1371 }
valeyev 0:e056ac8fecf8 1372
valeyev 0:e056ac8fecf8 1373 /** Posts an event onto the underlying event queue
valeyev 0:e056ac8fecf8 1374 *
valeyev 0:e056ac8fecf8 1375 * The event is posted to the underlying queue and is executed in the
valeyev 0:e056ac8fecf8 1376 * context of the event queue's dispatch loop.
valeyev 0:e056ac8fecf8 1377 *
valeyev 0:e056ac8fecf8 1378 * The post function is irq safe and can act as a mechanism for moving
valeyev 0:e056ac8fecf8 1379 * events out of irq contexts.
valeyev 0:e056ac8fecf8 1380 *
valeyev 0:e056ac8fecf8 1381 * @param a0,a1,a2 Arguments to pass to the event
valeyev 0:e056ac8fecf8 1382 * @return A unique id that represents the posted event and can
valeyev 0:e056ac8fecf8 1383 * be passed to EventQueue::cancel, or an id of 0 if
valeyev 0:e056ac8fecf8 1384 * there is not enough memory to allocate the event.
valeyev 0:e056ac8fecf8 1385 */
valeyev 0:e056ac8fecf8 1386 int post(A0 a0, A1 a1, A2 a2) const {
valeyev 0:e056ac8fecf8 1387 if (!_event) {
valeyev 0:e056ac8fecf8 1388 return 0;
valeyev 0:e056ac8fecf8 1389 }
valeyev 0:e056ac8fecf8 1390
valeyev 0:e056ac8fecf8 1391 _event->id = _event->post(_event, a0, a1, a2);
valeyev 0:e056ac8fecf8 1392 return _event->id;
valeyev 0:e056ac8fecf8 1393 }
valeyev 0:e056ac8fecf8 1394
valeyev 0:e056ac8fecf8 1395 /** Posts an event onto the underlying event queue, returning void
valeyev 0:e056ac8fecf8 1396 *
valeyev 0:e056ac8fecf8 1397 * @param a0,a1,a2 Arguments to pass to the event
valeyev 0:e056ac8fecf8 1398 */
valeyev 0:e056ac8fecf8 1399 void call(A0 a0, A1 a1, A2 a2) const {
valeyev 0:e056ac8fecf8 1400 MBED_UNUSED int id = post(a0, a1, a2);
valeyev 0:e056ac8fecf8 1401 MBED_ASSERT(id);
valeyev 0:e056ac8fecf8 1402 }
valeyev 0:e056ac8fecf8 1403
valeyev 0:e056ac8fecf8 1404 /** Posts an event onto the underlying event queue, returning void
valeyev 0:e056ac8fecf8 1405 *
valeyev 0:e056ac8fecf8 1406 * @param a0,a1,a2 Arguments to pass to the event
valeyev 0:e056ac8fecf8 1407 */
valeyev 0:e056ac8fecf8 1408 void operator()(A0 a0, A1 a1, A2 a2) const {
valeyev 0:e056ac8fecf8 1409 return call(a0, a1, a2);
valeyev 0:e056ac8fecf8 1410 }
valeyev 0:e056ac8fecf8 1411
valeyev 0:e056ac8fecf8 1412 /** Static thunk for passing as C-style function
valeyev 0:e056ac8fecf8 1413 *
valeyev 0:e056ac8fecf8 1414 * @param func Event to call passed as a void pointer
valeyev 0:e056ac8fecf8 1415 * @param a0,a1,a2 Arguments to pass to the event
valeyev 0:e056ac8fecf8 1416 */
valeyev 0:e056ac8fecf8 1417 static void thunk(void *func, A0 a0, A1 a1, A2 a2) {
valeyev 0:e056ac8fecf8 1418 return static_cast<Event*>(func)->call(a0, a1, a2);
valeyev 0:e056ac8fecf8 1419 }
valeyev 0:e056ac8fecf8 1420
valeyev 0:e056ac8fecf8 1421 /** Cancels the most recently posted event
valeyev 0:e056ac8fecf8 1422 *
valeyev 0:e056ac8fecf8 1423 * Attempts to cancel the most recently posted event. It is safe to call
valeyev 0:e056ac8fecf8 1424 * cancel after an event has already been dispatched.
valeyev 0:e056ac8fecf8 1425 *
valeyev 0:e056ac8fecf8 1426 * The cancel function is irq safe.
valeyev 0:e056ac8fecf8 1427 *
valeyev 0:e056ac8fecf8 1428 * If called while the event queue's dispatch loop is active, the cancel
valeyev 0:e056ac8fecf8 1429 * function does not garuntee that the event will not execute after it
valeyev 0:e056ac8fecf8 1430 * returns, as the event may have already begun executing.
valeyev 0:e056ac8fecf8 1431 */
valeyev 0:e056ac8fecf8 1432 void cancel() const {
valeyev 0:e056ac8fecf8 1433 if (_event) {
valeyev 0:e056ac8fecf8 1434 equeue_cancel(_event->equeue, _event->id);
valeyev 0:e056ac8fecf8 1435 }
valeyev 0:e056ac8fecf8 1436 }
valeyev 0:e056ac8fecf8 1437
valeyev 0:e056ac8fecf8 1438 private:
valeyev 0:e056ac8fecf8 1439 struct event {
valeyev 0:e056ac8fecf8 1440 unsigned ref;
valeyev 0:e056ac8fecf8 1441 equeue_t *equeue;
valeyev 0:e056ac8fecf8 1442 int id;
valeyev 0:e056ac8fecf8 1443
valeyev 0:e056ac8fecf8 1444 int delay;
valeyev 0:e056ac8fecf8 1445 int period;
valeyev 0:e056ac8fecf8 1446
valeyev 0:e056ac8fecf8 1447 int (*post)(struct event *, A0 a0, A1 a1, A2 a2);
valeyev 0:e056ac8fecf8 1448 void (*dtor)(struct event *);
valeyev 0:e056ac8fecf8 1449
valeyev 0:e056ac8fecf8 1450 // F follows
valeyev 0:e056ac8fecf8 1451 } *_event;
valeyev 0:e056ac8fecf8 1452
valeyev 0:e056ac8fecf8 1453 // Event attributes
valeyev 0:e056ac8fecf8 1454 template <typename F>
valeyev 0:e056ac8fecf8 1455 static int event_post(struct event *e, A0 a0, A1 a1, A2 a2) {
valeyev 0:e056ac8fecf8 1456 typedef EventQueue::context30<F, A0, A1, A2> C;
valeyev 0:e056ac8fecf8 1457 void *p = equeue_alloc(e->equeue, sizeof(C));
valeyev 0:e056ac8fecf8 1458 if (!p) {
valeyev 0:e056ac8fecf8 1459 return 0;
valeyev 0:e056ac8fecf8 1460 }
valeyev 0:e056ac8fecf8 1461
valeyev 0:e056ac8fecf8 1462 new (p) C(*(F*)(e + 1), a0, a1, a2);
valeyev 0:e056ac8fecf8 1463 equeue_event_delay(p, e->delay);
valeyev 0:e056ac8fecf8 1464 equeue_event_period(p, e->period);
valeyev 0:e056ac8fecf8 1465 equeue_event_dtor(p, &EventQueue::function_dtor<C>);
valeyev 0:e056ac8fecf8 1466 return equeue_post(e->equeue, &EventQueue::function_call<C>, p);
valeyev 0:e056ac8fecf8 1467 }
valeyev 0:e056ac8fecf8 1468
valeyev 0:e056ac8fecf8 1469 template <typename F>
valeyev 0:e056ac8fecf8 1470 static void event_dtor(struct event *e) {
valeyev 0:e056ac8fecf8 1471 ((F*)(e + 1))->~F();
valeyev 0:e056ac8fecf8 1472 }
valeyev 0:e056ac8fecf8 1473
valeyev 0:e056ac8fecf8 1474 public:
valeyev 0:e056ac8fecf8 1475 /** Create an event
valeyev 0:e056ac8fecf8 1476 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 1477 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 1478 * @param c0 Argument to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 1479 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 1480 * memory pool. Must be type-compatible with b0, the
valeyev 0:e056ac8fecf8 1481 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 1482 */
valeyev 0:e056ac8fecf8 1483 template <typename F, typename C0>
valeyev 0:e056ac8fecf8 1484 Event(EventQueue *q, F f, C0 c0) {
valeyev 0:e056ac8fecf8 1485 new (this) Event(q, EventQueue::context13<F, C0, A0, A1, A2>(f, c0));
valeyev 0:e056ac8fecf8 1486 }
valeyev 0:e056ac8fecf8 1487
valeyev 0:e056ac8fecf8 1488 /** Create an event
valeyev 0:e056ac8fecf8 1489 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 1490 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 1491 * @param c0,c1 Arguments to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 1492 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 1493 * memory pool. Must be type-compatible with b0..b1, the
valeyev 0:e056ac8fecf8 1494 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 1495 */
valeyev 0:e056ac8fecf8 1496 template <typename F, typename C0, typename C1>
valeyev 0:e056ac8fecf8 1497 Event(EventQueue *q, F f, C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 1498 new (this) Event(q, EventQueue::context23<F, C0, C1, A0, A1, A2>(f, c0, c1));
valeyev 0:e056ac8fecf8 1499 }
valeyev 0:e056ac8fecf8 1500
valeyev 0:e056ac8fecf8 1501 /** Create an event
valeyev 0:e056ac8fecf8 1502 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 1503 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 1504 * @param c0,c1,c2 Arguments to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 1505 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 1506 * memory pool. Must be type-compatible with b0..b2, the
valeyev 0:e056ac8fecf8 1507 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 1508 */
valeyev 0:e056ac8fecf8 1509 template <typename F, typename C0, typename C1, typename C2>
valeyev 0:e056ac8fecf8 1510 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2) {
valeyev 0:e056ac8fecf8 1511 new (this) Event(q, EventQueue::context33<F, C0, C1, C2, A0, A1, A2>(f, c0, c1, c2));
valeyev 0:e056ac8fecf8 1512 }
valeyev 0:e056ac8fecf8 1513
valeyev 0:e056ac8fecf8 1514 /** Create an event
valeyev 0:e056ac8fecf8 1515 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 1516 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 1517 * @param c0,c1,c2,c3 Arguments to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 1518 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 1519 * memory pool. Must be type-compatible with b0..b3, the
valeyev 0:e056ac8fecf8 1520 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 1521 */
valeyev 0:e056ac8fecf8 1522 template <typename F, typename C0, typename C1, typename C2, typename C3>
valeyev 0:e056ac8fecf8 1523 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3) {
valeyev 0:e056ac8fecf8 1524 new (this) Event(q, EventQueue::context43<F, C0, C1, C2, C3, A0, A1, A2>(f, c0, c1, c2, c3));
valeyev 0:e056ac8fecf8 1525 }
valeyev 0:e056ac8fecf8 1526
valeyev 0:e056ac8fecf8 1527 /** Create an event
valeyev 0:e056ac8fecf8 1528 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 1529 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 1530 * @param c0,c1,c2,c3,c4 Arguments to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 1531 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 1532 * memory pool. Must be type-compatible with b0..b4, the
valeyev 0:e056ac8fecf8 1533 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 1534 */
valeyev 0:e056ac8fecf8 1535 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4>
valeyev 0:e056ac8fecf8 1536 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {
valeyev 0:e056ac8fecf8 1537 new (this) Event(q, EventQueue::context53<F, C0, C1, C2, C3, C4, A0, A1, A2>(f, c0, c1, c2, c3, c4));
valeyev 0:e056ac8fecf8 1538 }
valeyev 0:e056ac8fecf8 1539
valeyev 0:e056ac8fecf8 1540 /** Create an event
valeyev 0:e056ac8fecf8 1541 * @see Event::Event
valeyev 0:e056ac8fecf8 1542 */
valeyev 0:e056ac8fecf8 1543 template <typename T, typename R, typename B0>
valeyev 0:e056ac8fecf8 1544 Event(EventQueue *q, T *obj, R (T::*method)(B0, A0, A1, A2), B0 b0) {
valeyev 0:e056ac8fecf8 1545 new (this) Event(q, mbed::callback(obj, method), b0);
valeyev 0:e056ac8fecf8 1546 }
valeyev 0:e056ac8fecf8 1547
valeyev 0:e056ac8fecf8 1548 /** Create an event
valeyev 0:e056ac8fecf8 1549 * @see Event::Event
valeyev 0:e056ac8fecf8 1550 */
valeyev 0:e056ac8fecf8 1551 template <typename T, typename R, typename B0>
valeyev 0:e056ac8fecf8 1552 Event(EventQueue *q, const T *obj, R (T::*method)(B0, A0, A1, A2) const, B0 b0) {
valeyev 0:e056ac8fecf8 1553 new (this) Event(q, mbed::callback(obj, method), b0);
valeyev 0:e056ac8fecf8 1554 }
valeyev 0:e056ac8fecf8 1555
valeyev 0:e056ac8fecf8 1556 /** Create an event
valeyev 0:e056ac8fecf8 1557 * @see Event::Event
valeyev 0:e056ac8fecf8 1558 */
valeyev 0:e056ac8fecf8 1559 template <typename T, typename R, typename B0>
valeyev 0:e056ac8fecf8 1560 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, A0, A1, A2) volatile, B0 b0) {
valeyev 0:e056ac8fecf8 1561 new (this) Event(q, mbed::callback(obj, method), b0);
valeyev 0:e056ac8fecf8 1562 }
valeyev 0:e056ac8fecf8 1563
valeyev 0:e056ac8fecf8 1564 /** Create an event
valeyev 0:e056ac8fecf8 1565 * @see Event::Event
valeyev 0:e056ac8fecf8 1566 */
valeyev 0:e056ac8fecf8 1567 template <typename T, typename R, typename B0>
valeyev 0:e056ac8fecf8 1568 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, A0, A1, A2) const volatile, B0 b0) {
valeyev 0:e056ac8fecf8 1569 new (this) Event(q, mbed::callback(obj, method), b0);
valeyev 0:e056ac8fecf8 1570 }
valeyev 0:e056ac8fecf8 1571
valeyev 0:e056ac8fecf8 1572 /** Create an event
valeyev 0:e056ac8fecf8 1573 * @see Event::Event
valeyev 0:e056ac8fecf8 1574 */
valeyev 0:e056ac8fecf8 1575 template <typename T, typename R, typename B0, typename B1>
valeyev 0:e056ac8fecf8 1576 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, A0, A1, A2), B0 b0, B1 b1) {
valeyev 0:e056ac8fecf8 1577 new (this) Event(q, mbed::callback(obj, method), b0, b1);
valeyev 0:e056ac8fecf8 1578 }
valeyev 0:e056ac8fecf8 1579
valeyev 0:e056ac8fecf8 1580 /** Create an event
valeyev 0:e056ac8fecf8 1581 * @see Event::Event
valeyev 0:e056ac8fecf8 1582 */
valeyev 0:e056ac8fecf8 1583 template <typename T, typename R, typename B0, typename B1>
valeyev 0:e056ac8fecf8 1584 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, A0, A1, A2) const, B0 b0, B1 b1) {
valeyev 0:e056ac8fecf8 1585 new (this) Event(q, mbed::callback(obj, method), b0, b1);
valeyev 0:e056ac8fecf8 1586 }
valeyev 0:e056ac8fecf8 1587
valeyev 0:e056ac8fecf8 1588 /** Create an event
valeyev 0:e056ac8fecf8 1589 * @see Event::Event
valeyev 0:e056ac8fecf8 1590 */
valeyev 0:e056ac8fecf8 1591 template <typename T, typename R, typename B0, typename B1>
valeyev 0:e056ac8fecf8 1592 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2) volatile, B0 b0, B1 b1) {
valeyev 0:e056ac8fecf8 1593 new (this) Event(q, mbed::callback(obj, method), b0, b1);
valeyev 0:e056ac8fecf8 1594 }
valeyev 0:e056ac8fecf8 1595
valeyev 0:e056ac8fecf8 1596 /** Create an event
valeyev 0:e056ac8fecf8 1597 * @see Event::Event
valeyev 0:e056ac8fecf8 1598 */
valeyev 0:e056ac8fecf8 1599 template <typename T, typename R, typename B0, typename B1>
valeyev 0:e056ac8fecf8 1600 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2) const volatile, B0 b0, B1 b1) {
valeyev 0:e056ac8fecf8 1601 new (this) Event(q, mbed::callback(obj, method), b0, b1);
valeyev 0:e056ac8fecf8 1602 }
valeyev 0:e056ac8fecf8 1603
valeyev 0:e056ac8fecf8 1604 /** Create an event
valeyev 0:e056ac8fecf8 1605 * @see Event::Event
valeyev 0:e056ac8fecf8 1606 */
valeyev 0:e056ac8fecf8 1607 template <typename T, typename R, typename B0, typename B1, typename B2>
valeyev 0:e056ac8fecf8 1608 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2), B0 b0, B1 b1, B2 b2) {
valeyev 0:e056ac8fecf8 1609 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
valeyev 0:e056ac8fecf8 1610 }
valeyev 0:e056ac8fecf8 1611
valeyev 0:e056ac8fecf8 1612 /** Create an event
valeyev 0:e056ac8fecf8 1613 * @see Event::Event
valeyev 0:e056ac8fecf8 1614 */
valeyev 0:e056ac8fecf8 1615 template <typename T, typename R, typename B0, typename B1, typename B2>
valeyev 0:e056ac8fecf8 1616 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2) const, B0 b0, B1 b1, B2 b2) {
valeyev 0:e056ac8fecf8 1617 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
valeyev 0:e056ac8fecf8 1618 }
valeyev 0:e056ac8fecf8 1619
valeyev 0:e056ac8fecf8 1620 /** Create an event
valeyev 0:e056ac8fecf8 1621 * @see Event::Event
valeyev 0:e056ac8fecf8 1622 */
valeyev 0:e056ac8fecf8 1623 template <typename T, typename R, typename B0, typename B1, typename B2>
valeyev 0:e056ac8fecf8 1624 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2) volatile, B0 b0, B1 b1, B2 b2) {
valeyev 0:e056ac8fecf8 1625 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
valeyev 0:e056ac8fecf8 1626 }
valeyev 0:e056ac8fecf8 1627
valeyev 0:e056ac8fecf8 1628 /** Create an event
valeyev 0:e056ac8fecf8 1629 * @see Event::Event
valeyev 0:e056ac8fecf8 1630 */
valeyev 0:e056ac8fecf8 1631 template <typename T, typename R, typename B0, typename B1, typename B2>
valeyev 0:e056ac8fecf8 1632 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2) const volatile, B0 b0, B1 b1, B2 b2) {
valeyev 0:e056ac8fecf8 1633 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
valeyev 0:e056ac8fecf8 1634 }
valeyev 0:e056ac8fecf8 1635
valeyev 0:e056ac8fecf8 1636 /** Create an event
valeyev 0:e056ac8fecf8 1637 * @see Event::Event
valeyev 0:e056ac8fecf8 1638 */
valeyev 0:e056ac8fecf8 1639 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
valeyev 0:e056ac8fecf8 1640 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2), B0 b0, B1 b1, B2 b2, B3 b3) {
valeyev 0:e056ac8fecf8 1641 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
valeyev 0:e056ac8fecf8 1642 }
valeyev 0:e056ac8fecf8 1643
valeyev 0:e056ac8fecf8 1644 /** Create an event
valeyev 0:e056ac8fecf8 1645 * @see Event::Event
valeyev 0:e056ac8fecf8 1646 */
valeyev 0:e056ac8fecf8 1647 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
valeyev 0:e056ac8fecf8 1648 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) {
valeyev 0:e056ac8fecf8 1649 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
valeyev 0:e056ac8fecf8 1650 }
valeyev 0:e056ac8fecf8 1651
valeyev 0:e056ac8fecf8 1652 /** Create an event
valeyev 0:e056ac8fecf8 1653 * @see Event::Event
valeyev 0:e056ac8fecf8 1654 */
valeyev 0:e056ac8fecf8 1655 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
valeyev 0:e056ac8fecf8 1656 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) {
valeyev 0:e056ac8fecf8 1657 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
valeyev 0:e056ac8fecf8 1658 }
valeyev 0:e056ac8fecf8 1659
valeyev 0:e056ac8fecf8 1660 /** Create an event
valeyev 0:e056ac8fecf8 1661 * @see Event::Event
valeyev 0:e056ac8fecf8 1662 */
valeyev 0:e056ac8fecf8 1663 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
valeyev 0:e056ac8fecf8 1664 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) {
valeyev 0:e056ac8fecf8 1665 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
valeyev 0:e056ac8fecf8 1666 }
valeyev 0:e056ac8fecf8 1667
valeyev 0:e056ac8fecf8 1668 /** Create an event
valeyev 0:e056ac8fecf8 1669 * @see Event::Event
valeyev 0:e056ac8fecf8 1670 */
valeyev 0:e056ac8fecf8 1671 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
valeyev 0:e056ac8fecf8 1672 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) {
valeyev 0:e056ac8fecf8 1673 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
valeyev 0:e056ac8fecf8 1674 }
valeyev 0:e056ac8fecf8 1675
valeyev 0:e056ac8fecf8 1676 /** Create an event
valeyev 0:e056ac8fecf8 1677 * @see Event::Event
valeyev 0:e056ac8fecf8 1678 */
valeyev 0:e056ac8fecf8 1679 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
valeyev 0:e056ac8fecf8 1680 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) {
valeyev 0:e056ac8fecf8 1681 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
valeyev 0:e056ac8fecf8 1682 }
valeyev 0:e056ac8fecf8 1683
valeyev 0:e056ac8fecf8 1684 /** Create an event
valeyev 0:e056ac8fecf8 1685 * @see Event::Event
valeyev 0:e056ac8fecf8 1686 */
valeyev 0:e056ac8fecf8 1687 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
valeyev 0:e056ac8fecf8 1688 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) {
valeyev 0:e056ac8fecf8 1689 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
valeyev 0:e056ac8fecf8 1690 }
valeyev 0:e056ac8fecf8 1691
valeyev 0:e056ac8fecf8 1692 /** Create an event
valeyev 0:e056ac8fecf8 1693 * @see Event::Event
valeyev 0:e056ac8fecf8 1694 */
valeyev 0:e056ac8fecf8 1695 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
valeyev 0:e056ac8fecf8 1696 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) {
valeyev 0:e056ac8fecf8 1697 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
valeyev 0:e056ac8fecf8 1698 }
valeyev 0:e056ac8fecf8 1699 };
valeyev 0:e056ac8fecf8 1700
valeyev 0:e056ac8fecf8 1701 /** Event
valeyev 0:e056ac8fecf8 1702 *
valeyev 0:e056ac8fecf8 1703 * Representation of an event for fine-grain dispatch control
valeyev 0:e056ac8fecf8 1704 * @ingroup events
valeyev 0:e056ac8fecf8 1705 */
valeyev 0:e056ac8fecf8 1706 template <typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 1707 class Event<void(A0, A1, A2, A3)> {
valeyev 0:e056ac8fecf8 1708 public:
valeyev 0:e056ac8fecf8 1709 /** Create an event
valeyev 0:e056ac8fecf8 1710 *
valeyev 0:e056ac8fecf8 1711 * Constructs an event bound to the specified event queue. The specified
valeyev 0:e056ac8fecf8 1712 * callback acts as the target for the event and is executed in the
valeyev 0:e056ac8fecf8 1713 * context of the event queue's dispatch loop once posted.
valeyev 0:e056ac8fecf8 1714 *
valeyev 0:e056ac8fecf8 1715 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 1716 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 1717 */
valeyev 0:e056ac8fecf8 1718 template <typename F>
valeyev 0:e056ac8fecf8 1719 Event(EventQueue *q, F f) {
valeyev 0:e056ac8fecf8 1720 _event = static_cast<struct event *>(
valeyev 0:e056ac8fecf8 1721 equeue_alloc(&q->_equeue, sizeof(struct event) + sizeof(F)));
valeyev 0:e056ac8fecf8 1722
valeyev 0:e056ac8fecf8 1723 if (_event) {
valeyev 0:e056ac8fecf8 1724 _event->equeue = &q->_equeue;
valeyev 0:e056ac8fecf8 1725 _event->id = 0;
valeyev 0:e056ac8fecf8 1726 _event->delay = 0;
valeyev 0:e056ac8fecf8 1727 _event->period = -1;
valeyev 0:e056ac8fecf8 1728
valeyev 0:e056ac8fecf8 1729 _event->post = &Event::event_post<F>;
valeyev 0:e056ac8fecf8 1730 _event->dtor = &Event::event_dtor<F>;
valeyev 0:e056ac8fecf8 1731
valeyev 0:e056ac8fecf8 1732 new (_event+1) F(f);
valeyev 0:e056ac8fecf8 1733
valeyev 0:e056ac8fecf8 1734 _event->ref = 1;
valeyev 0:e056ac8fecf8 1735 }
valeyev 0:e056ac8fecf8 1736 }
valeyev 0:e056ac8fecf8 1737
valeyev 0:e056ac8fecf8 1738 /** Copy constructor for events
valeyev 0:e056ac8fecf8 1739 */
valeyev 0:e056ac8fecf8 1740 Event(const Event &e) {
valeyev 0:e056ac8fecf8 1741 _event = 0;
valeyev 0:e056ac8fecf8 1742 if (e._event) {
valeyev 0:e056ac8fecf8 1743 _event = e._event;
valeyev 0:e056ac8fecf8 1744 _event->ref += 1;
valeyev 0:e056ac8fecf8 1745 }
valeyev 0:e056ac8fecf8 1746 }
valeyev 0:e056ac8fecf8 1747
valeyev 0:e056ac8fecf8 1748 /** Assignment operator for events
valeyev 0:e056ac8fecf8 1749 */
valeyev 0:e056ac8fecf8 1750 Event &operator=(const Event &that) {
valeyev 0:e056ac8fecf8 1751 if (this != &that) {
valeyev 0:e056ac8fecf8 1752 this->~Event();
valeyev 0:e056ac8fecf8 1753 new (this) Event(that);
valeyev 0:e056ac8fecf8 1754 }
valeyev 0:e056ac8fecf8 1755
valeyev 0:e056ac8fecf8 1756 return *this;
valeyev 0:e056ac8fecf8 1757 }
valeyev 0:e056ac8fecf8 1758
valeyev 0:e056ac8fecf8 1759 /** Destructor for events
valeyev 0:e056ac8fecf8 1760 */
valeyev 0:e056ac8fecf8 1761 ~Event() {
valeyev 0:e056ac8fecf8 1762 if (_event) {
valeyev 0:e056ac8fecf8 1763 _event->ref -= 1;
valeyev 0:e056ac8fecf8 1764 if (_event->ref == 0) {
valeyev 0:e056ac8fecf8 1765 _event->dtor(_event);
valeyev 0:e056ac8fecf8 1766 equeue_dealloc(_event->equeue, _event);
valeyev 0:e056ac8fecf8 1767 }
valeyev 0:e056ac8fecf8 1768 }
valeyev 0:e056ac8fecf8 1769 }
valeyev 0:e056ac8fecf8 1770
valeyev 0:e056ac8fecf8 1771 /** Configure the delay of an event
valeyev 0:e056ac8fecf8 1772 *
valeyev 0:e056ac8fecf8 1773 * @param delay Millisecond delay before dispatching the event
valeyev 0:e056ac8fecf8 1774 */
valeyev 0:e056ac8fecf8 1775 void delay(int delay) {
valeyev 0:e056ac8fecf8 1776 if (_event) {
valeyev 0:e056ac8fecf8 1777 _event->delay = delay;
valeyev 0:e056ac8fecf8 1778 }
valeyev 0:e056ac8fecf8 1779 }
valeyev 0:e056ac8fecf8 1780
valeyev 0:e056ac8fecf8 1781 /** Configure the period of an event
valeyev 0:e056ac8fecf8 1782 *
valeyev 0:e056ac8fecf8 1783 * @param period Millisecond period for repeatedly dispatching an event
valeyev 0:e056ac8fecf8 1784 */
valeyev 0:e056ac8fecf8 1785 void period(int period) {
valeyev 0:e056ac8fecf8 1786 if (_event) {
valeyev 0:e056ac8fecf8 1787 _event->period = period;
valeyev 0:e056ac8fecf8 1788 }
valeyev 0:e056ac8fecf8 1789 }
valeyev 0:e056ac8fecf8 1790
valeyev 0:e056ac8fecf8 1791 /** Posts an event onto the underlying event queue
valeyev 0:e056ac8fecf8 1792 *
valeyev 0:e056ac8fecf8 1793 * The event is posted to the underlying queue and is executed in the
valeyev 0:e056ac8fecf8 1794 * context of the event queue's dispatch loop.
valeyev 0:e056ac8fecf8 1795 *
valeyev 0:e056ac8fecf8 1796 * The post function is irq safe and can act as a mechanism for moving
valeyev 0:e056ac8fecf8 1797 * events out of irq contexts.
valeyev 0:e056ac8fecf8 1798 *
valeyev 0:e056ac8fecf8 1799 * @param a0,a1,a2,a3 Arguments to pass to the event
valeyev 0:e056ac8fecf8 1800 * @return A unique id that represents the posted event and can
valeyev 0:e056ac8fecf8 1801 * be passed to EventQueue::cancel, or an id of 0 if
valeyev 0:e056ac8fecf8 1802 * there is not enough memory to allocate the event.
valeyev 0:e056ac8fecf8 1803 */
valeyev 0:e056ac8fecf8 1804 int post(A0 a0, A1 a1, A2 a2, A3 a3) const {
valeyev 0:e056ac8fecf8 1805 if (!_event) {
valeyev 0:e056ac8fecf8 1806 return 0;
valeyev 0:e056ac8fecf8 1807 }
valeyev 0:e056ac8fecf8 1808
valeyev 0:e056ac8fecf8 1809 _event->id = _event->post(_event, a0, a1, a2, a3);
valeyev 0:e056ac8fecf8 1810 return _event->id;
valeyev 0:e056ac8fecf8 1811 }
valeyev 0:e056ac8fecf8 1812
valeyev 0:e056ac8fecf8 1813 /** Posts an event onto the underlying event queue, returning void
valeyev 0:e056ac8fecf8 1814 *
valeyev 0:e056ac8fecf8 1815 * @param a0,a1,a2,a3 Arguments to pass to the event
valeyev 0:e056ac8fecf8 1816 */
valeyev 0:e056ac8fecf8 1817 void call(A0 a0, A1 a1, A2 a2, A3 a3) const {
valeyev 0:e056ac8fecf8 1818 MBED_UNUSED int id = post(a0, a1, a2, a3);
valeyev 0:e056ac8fecf8 1819 MBED_ASSERT(id);
valeyev 0:e056ac8fecf8 1820 }
valeyev 0:e056ac8fecf8 1821
valeyev 0:e056ac8fecf8 1822 /** Posts an event onto the underlying event queue, returning void
valeyev 0:e056ac8fecf8 1823 *
valeyev 0:e056ac8fecf8 1824 * @param a0,a1,a2,a3 Arguments to pass to the event
valeyev 0:e056ac8fecf8 1825 */
valeyev 0:e056ac8fecf8 1826 void operator()(A0 a0, A1 a1, A2 a2, A3 a3) const {
valeyev 0:e056ac8fecf8 1827 return call(a0, a1, a2, a3);
valeyev 0:e056ac8fecf8 1828 }
valeyev 0:e056ac8fecf8 1829
valeyev 0:e056ac8fecf8 1830 /** Static thunk for passing as C-style function
valeyev 0:e056ac8fecf8 1831 *
valeyev 0:e056ac8fecf8 1832 * @param func Event to call passed as a void pointer
valeyev 0:e056ac8fecf8 1833 * @param a0,a1,a2,a3 Arguments to pass to the event
valeyev 0:e056ac8fecf8 1834 */
valeyev 0:e056ac8fecf8 1835 static void thunk(void *func, A0 a0, A1 a1, A2 a2, A3 a3) {
valeyev 0:e056ac8fecf8 1836 return static_cast<Event*>(func)->call(a0, a1, a2, a3);
valeyev 0:e056ac8fecf8 1837 }
valeyev 0:e056ac8fecf8 1838
valeyev 0:e056ac8fecf8 1839 /** Cancels the most recently posted event
valeyev 0:e056ac8fecf8 1840 *
valeyev 0:e056ac8fecf8 1841 * Attempts to cancel the most recently posted event. It is safe to call
valeyev 0:e056ac8fecf8 1842 * cancel after an event has already been dispatched.
valeyev 0:e056ac8fecf8 1843 *
valeyev 0:e056ac8fecf8 1844 * The cancel function is irq safe.
valeyev 0:e056ac8fecf8 1845 *
valeyev 0:e056ac8fecf8 1846 * If called while the event queue's dispatch loop is active, the cancel
valeyev 0:e056ac8fecf8 1847 * function does not garuntee that the event will not execute after it
valeyev 0:e056ac8fecf8 1848 * returns, as the event may have already begun executing.
valeyev 0:e056ac8fecf8 1849 */
valeyev 0:e056ac8fecf8 1850 void cancel() const {
valeyev 0:e056ac8fecf8 1851 if (_event) {
valeyev 0:e056ac8fecf8 1852 equeue_cancel(_event->equeue, _event->id);
valeyev 0:e056ac8fecf8 1853 }
valeyev 0:e056ac8fecf8 1854 }
valeyev 0:e056ac8fecf8 1855
valeyev 0:e056ac8fecf8 1856 private:
valeyev 0:e056ac8fecf8 1857 struct event {
valeyev 0:e056ac8fecf8 1858 unsigned ref;
valeyev 0:e056ac8fecf8 1859 equeue_t *equeue;
valeyev 0:e056ac8fecf8 1860 int id;
valeyev 0:e056ac8fecf8 1861
valeyev 0:e056ac8fecf8 1862 int delay;
valeyev 0:e056ac8fecf8 1863 int period;
valeyev 0:e056ac8fecf8 1864
valeyev 0:e056ac8fecf8 1865 int (*post)(struct event *, A0 a0, A1 a1, A2 a2, A3 a3);
valeyev 0:e056ac8fecf8 1866 void (*dtor)(struct event *);
valeyev 0:e056ac8fecf8 1867
valeyev 0:e056ac8fecf8 1868 // F follows
valeyev 0:e056ac8fecf8 1869 } *_event;
valeyev 0:e056ac8fecf8 1870
valeyev 0:e056ac8fecf8 1871 // Event attributes
valeyev 0:e056ac8fecf8 1872 template <typename F>
valeyev 0:e056ac8fecf8 1873 static int event_post(struct event *e, A0 a0, A1 a1, A2 a2, A3 a3) {
valeyev 0:e056ac8fecf8 1874 typedef EventQueue::context40<F, A0, A1, A2, A3> C;
valeyev 0:e056ac8fecf8 1875 void *p = equeue_alloc(e->equeue, sizeof(C));
valeyev 0:e056ac8fecf8 1876 if (!p) {
valeyev 0:e056ac8fecf8 1877 return 0;
valeyev 0:e056ac8fecf8 1878 }
valeyev 0:e056ac8fecf8 1879
valeyev 0:e056ac8fecf8 1880 new (p) C(*(F*)(e + 1), a0, a1, a2, a3);
valeyev 0:e056ac8fecf8 1881 equeue_event_delay(p, e->delay);
valeyev 0:e056ac8fecf8 1882 equeue_event_period(p, e->period);
valeyev 0:e056ac8fecf8 1883 equeue_event_dtor(p, &EventQueue::function_dtor<C>);
valeyev 0:e056ac8fecf8 1884 return equeue_post(e->equeue, &EventQueue::function_call<C>, p);
valeyev 0:e056ac8fecf8 1885 }
valeyev 0:e056ac8fecf8 1886
valeyev 0:e056ac8fecf8 1887 template <typename F>
valeyev 0:e056ac8fecf8 1888 static void event_dtor(struct event *e) {
valeyev 0:e056ac8fecf8 1889 ((F*)(e + 1))->~F();
valeyev 0:e056ac8fecf8 1890 }
valeyev 0:e056ac8fecf8 1891
valeyev 0:e056ac8fecf8 1892 public:
valeyev 0:e056ac8fecf8 1893 /** Create an event
valeyev 0:e056ac8fecf8 1894 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 1895 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 1896 * @param c0 Argument to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 1897 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 1898 * memory pool. Must be type-compatible with b0, the
valeyev 0:e056ac8fecf8 1899 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 1900 */
valeyev 0:e056ac8fecf8 1901 template <typename F, typename C0>
valeyev 0:e056ac8fecf8 1902 Event(EventQueue *q, F f, C0 c0) {
valeyev 0:e056ac8fecf8 1903 new (this) Event(q, EventQueue::context14<F, C0, A0, A1, A2, A3>(f, c0));
valeyev 0:e056ac8fecf8 1904 }
valeyev 0:e056ac8fecf8 1905
valeyev 0:e056ac8fecf8 1906 /** Create an event
valeyev 0:e056ac8fecf8 1907 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 1908 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 1909 * @param c0,c1 Arguments to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 1910 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 1911 * memory pool. Must be type-compatible with b0..b1, the
valeyev 0:e056ac8fecf8 1912 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 1913 */
valeyev 0:e056ac8fecf8 1914 template <typename F, typename C0, typename C1>
valeyev 0:e056ac8fecf8 1915 Event(EventQueue *q, F f, C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 1916 new (this) Event(q, EventQueue::context24<F, C0, C1, A0, A1, A2, A3>(f, c0, c1));
valeyev 0:e056ac8fecf8 1917 }
valeyev 0:e056ac8fecf8 1918
valeyev 0:e056ac8fecf8 1919 /** Create an event
valeyev 0:e056ac8fecf8 1920 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 1921 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 1922 * @param c0,c1,c2 Arguments to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 1923 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 1924 * memory pool. Must be type-compatible with b0..b2, the
valeyev 0:e056ac8fecf8 1925 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 1926 */
valeyev 0:e056ac8fecf8 1927 template <typename F, typename C0, typename C1, typename C2>
valeyev 0:e056ac8fecf8 1928 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2) {
valeyev 0:e056ac8fecf8 1929 new (this) Event(q, EventQueue::context34<F, C0, C1, C2, A0, A1, A2, A3>(f, c0, c1, c2));
valeyev 0:e056ac8fecf8 1930 }
valeyev 0:e056ac8fecf8 1931
valeyev 0:e056ac8fecf8 1932 /** Create an event
valeyev 0:e056ac8fecf8 1933 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 1934 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 1935 * @param c0,c1,c2,c3 Arguments to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 1936 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 1937 * memory pool. Must be type-compatible with b0..b3, the
valeyev 0:e056ac8fecf8 1938 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 1939 */
valeyev 0:e056ac8fecf8 1940 template <typename F, typename C0, typename C1, typename C2, typename C3>
valeyev 0:e056ac8fecf8 1941 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3) {
valeyev 0:e056ac8fecf8 1942 new (this) Event(q, EventQueue::context44<F, C0, C1, C2, C3, A0, A1, A2, A3>(f, c0, c1, c2, c3));
valeyev 0:e056ac8fecf8 1943 }
valeyev 0:e056ac8fecf8 1944
valeyev 0:e056ac8fecf8 1945 /** Create an event
valeyev 0:e056ac8fecf8 1946 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 1947 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 1948 * @param c0,c1,c2,c3,c4 Arguments to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 1949 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 1950 * memory pool. Must be type-compatible with b0..b4, the
valeyev 0:e056ac8fecf8 1951 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 1952 */
valeyev 0:e056ac8fecf8 1953 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4>
valeyev 0:e056ac8fecf8 1954 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {
valeyev 0:e056ac8fecf8 1955 new (this) Event(q, EventQueue::context54<F, C0, C1, C2, C3, C4, A0, A1, A2, A3>(f, c0, c1, c2, c3, c4));
valeyev 0:e056ac8fecf8 1956 }
valeyev 0:e056ac8fecf8 1957
valeyev 0:e056ac8fecf8 1958 /** Create an event
valeyev 0:e056ac8fecf8 1959 * @see Event::Event
valeyev 0:e056ac8fecf8 1960 */
valeyev 0:e056ac8fecf8 1961 template <typename T, typename R, typename B0>
valeyev 0:e056ac8fecf8 1962 Event(EventQueue *q, T *obj, R (T::*method)(B0, A0, A1, A2, A3), B0 b0) {
valeyev 0:e056ac8fecf8 1963 new (this) Event(q, mbed::callback(obj, method), b0);
valeyev 0:e056ac8fecf8 1964 }
valeyev 0:e056ac8fecf8 1965
valeyev 0:e056ac8fecf8 1966 /** Create an event
valeyev 0:e056ac8fecf8 1967 * @see Event::Event
valeyev 0:e056ac8fecf8 1968 */
valeyev 0:e056ac8fecf8 1969 template <typename T, typename R, typename B0>
valeyev 0:e056ac8fecf8 1970 Event(EventQueue *q, const T *obj, R (T::*method)(B0, A0, A1, A2, A3) const, B0 b0) {
valeyev 0:e056ac8fecf8 1971 new (this) Event(q, mbed::callback(obj, method), b0);
valeyev 0:e056ac8fecf8 1972 }
valeyev 0:e056ac8fecf8 1973
valeyev 0:e056ac8fecf8 1974 /** Create an event
valeyev 0:e056ac8fecf8 1975 * @see Event::Event
valeyev 0:e056ac8fecf8 1976 */
valeyev 0:e056ac8fecf8 1977 template <typename T, typename R, typename B0>
valeyev 0:e056ac8fecf8 1978 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3) volatile, B0 b0) {
valeyev 0:e056ac8fecf8 1979 new (this) Event(q, mbed::callback(obj, method), b0);
valeyev 0:e056ac8fecf8 1980 }
valeyev 0:e056ac8fecf8 1981
valeyev 0:e056ac8fecf8 1982 /** Create an event
valeyev 0:e056ac8fecf8 1983 * @see Event::Event
valeyev 0:e056ac8fecf8 1984 */
valeyev 0:e056ac8fecf8 1985 template <typename T, typename R, typename B0>
valeyev 0:e056ac8fecf8 1986 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3) const volatile, B0 b0) {
valeyev 0:e056ac8fecf8 1987 new (this) Event(q, mbed::callback(obj, method), b0);
valeyev 0:e056ac8fecf8 1988 }
valeyev 0:e056ac8fecf8 1989
valeyev 0:e056ac8fecf8 1990 /** Create an event
valeyev 0:e056ac8fecf8 1991 * @see Event::Event
valeyev 0:e056ac8fecf8 1992 */
valeyev 0:e056ac8fecf8 1993 template <typename T, typename R, typename B0, typename B1>
valeyev 0:e056ac8fecf8 1994 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3), B0 b0, B1 b1) {
valeyev 0:e056ac8fecf8 1995 new (this) Event(q, mbed::callback(obj, method), b0, b1);
valeyev 0:e056ac8fecf8 1996 }
valeyev 0:e056ac8fecf8 1997
valeyev 0:e056ac8fecf8 1998 /** Create an event
valeyev 0:e056ac8fecf8 1999 * @see Event::Event
valeyev 0:e056ac8fecf8 2000 */
valeyev 0:e056ac8fecf8 2001 template <typename T, typename R, typename B0, typename B1>
valeyev 0:e056ac8fecf8 2002 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3) const, B0 b0, B1 b1) {
valeyev 0:e056ac8fecf8 2003 new (this) Event(q, mbed::callback(obj, method), b0, b1);
valeyev 0:e056ac8fecf8 2004 }
valeyev 0:e056ac8fecf8 2005
valeyev 0:e056ac8fecf8 2006 /** Create an event
valeyev 0:e056ac8fecf8 2007 * @see Event::Event
valeyev 0:e056ac8fecf8 2008 */
valeyev 0:e056ac8fecf8 2009 template <typename T, typename R, typename B0, typename B1>
valeyev 0:e056ac8fecf8 2010 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3) volatile, B0 b0, B1 b1) {
valeyev 0:e056ac8fecf8 2011 new (this) Event(q, mbed::callback(obj, method), b0, b1);
valeyev 0:e056ac8fecf8 2012 }
valeyev 0:e056ac8fecf8 2013
valeyev 0:e056ac8fecf8 2014 /** Create an event
valeyev 0:e056ac8fecf8 2015 * @see Event::Event
valeyev 0:e056ac8fecf8 2016 */
valeyev 0:e056ac8fecf8 2017 template <typename T, typename R, typename B0, typename B1>
valeyev 0:e056ac8fecf8 2018 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3) const volatile, B0 b0, B1 b1) {
valeyev 0:e056ac8fecf8 2019 new (this) Event(q, mbed::callback(obj, method), b0, b1);
valeyev 0:e056ac8fecf8 2020 }
valeyev 0:e056ac8fecf8 2021
valeyev 0:e056ac8fecf8 2022 /** Create an event
valeyev 0:e056ac8fecf8 2023 * @see Event::Event
valeyev 0:e056ac8fecf8 2024 */
valeyev 0:e056ac8fecf8 2025 template <typename T, typename R, typename B0, typename B1, typename B2>
valeyev 0:e056ac8fecf8 2026 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3), B0 b0, B1 b1, B2 b2) {
valeyev 0:e056ac8fecf8 2027 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
valeyev 0:e056ac8fecf8 2028 }
valeyev 0:e056ac8fecf8 2029
valeyev 0:e056ac8fecf8 2030 /** Create an event
valeyev 0:e056ac8fecf8 2031 * @see Event::Event
valeyev 0:e056ac8fecf8 2032 */
valeyev 0:e056ac8fecf8 2033 template <typename T, typename R, typename B0, typename B1, typename B2>
valeyev 0:e056ac8fecf8 2034 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3) const, B0 b0, B1 b1, B2 b2) {
valeyev 0:e056ac8fecf8 2035 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
valeyev 0:e056ac8fecf8 2036 }
valeyev 0:e056ac8fecf8 2037
valeyev 0:e056ac8fecf8 2038 /** Create an event
valeyev 0:e056ac8fecf8 2039 * @see Event::Event
valeyev 0:e056ac8fecf8 2040 */
valeyev 0:e056ac8fecf8 2041 template <typename T, typename R, typename B0, typename B1, typename B2>
valeyev 0:e056ac8fecf8 2042 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3) volatile, B0 b0, B1 b1, B2 b2) {
valeyev 0:e056ac8fecf8 2043 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
valeyev 0:e056ac8fecf8 2044 }
valeyev 0:e056ac8fecf8 2045
valeyev 0:e056ac8fecf8 2046 /** Create an event
valeyev 0:e056ac8fecf8 2047 * @see Event::Event
valeyev 0:e056ac8fecf8 2048 */
valeyev 0:e056ac8fecf8 2049 template <typename T, typename R, typename B0, typename B1, typename B2>
valeyev 0:e056ac8fecf8 2050 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) {
valeyev 0:e056ac8fecf8 2051 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
valeyev 0:e056ac8fecf8 2052 }
valeyev 0:e056ac8fecf8 2053
valeyev 0:e056ac8fecf8 2054 /** Create an event
valeyev 0:e056ac8fecf8 2055 * @see Event::Event
valeyev 0:e056ac8fecf8 2056 */
valeyev 0:e056ac8fecf8 2057 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
valeyev 0:e056ac8fecf8 2058 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3), B0 b0, B1 b1, B2 b2, B3 b3) {
valeyev 0:e056ac8fecf8 2059 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
valeyev 0:e056ac8fecf8 2060 }
valeyev 0:e056ac8fecf8 2061
valeyev 0:e056ac8fecf8 2062 /** Create an event
valeyev 0:e056ac8fecf8 2063 * @see Event::Event
valeyev 0:e056ac8fecf8 2064 */
valeyev 0:e056ac8fecf8 2065 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
valeyev 0:e056ac8fecf8 2066 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) {
valeyev 0:e056ac8fecf8 2067 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
valeyev 0:e056ac8fecf8 2068 }
valeyev 0:e056ac8fecf8 2069
valeyev 0:e056ac8fecf8 2070 /** Create an event
valeyev 0:e056ac8fecf8 2071 * @see Event::Event
valeyev 0:e056ac8fecf8 2072 */
valeyev 0:e056ac8fecf8 2073 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
valeyev 0:e056ac8fecf8 2074 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) {
valeyev 0:e056ac8fecf8 2075 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
valeyev 0:e056ac8fecf8 2076 }
valeyev 0:e056ac8fecf8 2077
valeyev 0:e056ac8fecf8 2078 /** Create an event
valeyev 0:e056ac8fecf8 2079 * @see Event::Event
valeyev 0:e056ac8fecf8 2080 */
valeyev 0:e056ac8fecf8 2081 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
valeyev 0:e056ac8fecf8 2082 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) {
valeyev 0:e056ac8fecf8 2083 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
valeyev 0:e056ac8fecf8 2084 }
valeyev 0:e056ac8fecf8 2085
valeyev 0:e056ac8fecf8 2086 /** Create an event
valeyev 0:e056ac8fecf8 2087 * @see Event::Event
valeyev 0:e056ac8fecf8 2088 */
valeyev 0:e056ac8fecf8 2089 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
valeyev 0:e056ac8fecf8 2090 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) {
valeyev 0:e056ac8fecf8 2091 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
valeyev 0:e056ac8fecf8 2092 }
valeyev 0:e056ac8fecf8 2093
valeyev 0:e056ac8fecf8 2094 /** Create an event
valeyev 0:e056ac8fecf8 2095 * @see Event::Event
valeyev 0:e056ac8fecf8 2096 */
valeyev 0:e056ac8fecf8 2097 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
valeyev 0:e056ac8fecf8 2098 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) {
valeyev 0:e056ac8fecf8 2099 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
valeyev 0:e056ac8fecf8 2100 }
valeyev 0:e056ac8fecf8 2101
valeyev 0:e056ac8fecf8 2102 /** Create an event
valeyev 0:e056ac8fecf8 2103 * @see Event::Event
valeyev 0:e056ac8fecf8 2104 */
valeyev 0:e056ac8fecf8 2105 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
valeyev 0:e056ac8fecf8 2106 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) {
valeyev 0:e056ac8fecf8 2107 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
valeyev 0:e056ac8fecf8 2108 }
valeyev 0:e056ac8fecf8 2109
valeyev 0:e056ac8fecf8 2110 /** Create an event
valeyev 0:e056ac8fecf8 2111 * @see Event::Event
valeyev 0:e056ac8fecf8 2112 */
valeyev 0:e056ac8fecf8 2113 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
valeyev 0:e056ac8fecf8 2114 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) {
valeyev 0:e056ac8fecf8 2115 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
valeyev 0:e056ac8fecf8 2116 }
valeyev 0:e056ac8fecf8 2117 };
valeyev 0:e056ac8fecf8 2118
valeyev 0:e056ac8fecf8 2119 /** Event
valeyev 0:e056ac8fecf8 2120 *
valeyev 0:e056ac8fecf8 2121 * Representation of an event for fine-grain dispatch control
valeyev 0:e056ac8fecf8 2122 * @ingroup events
valeyev 0:e056ac8fecf8 2123 */
valeyev 0:e056ac8fecf8 2124 template <typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 2125 class Event<void(A0, A1, A2, A3, A4)> {
valeyev 0:e056ac8fecf8 2126 public:
valeyev 0:e056ac8fecf8 2127 /** Create an event
valeyev 0:e056ac8fecf8 2128 *
valeyev 0:e056ac8fecf8 2129 * Constructs an event bound to the specified event queue. The specified
valeyev 0:e056ac8fecf8 2130 * callback acts as the target for the event and is executed in the
valeyev 0:e056ac8fecf8 2131 * context of the event queue's dispatch loop once posted.
valeyev 0:e056ac8fecf8 2132 *
valeyev 0:e056ac8fecf8 2133 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 2134 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 2135 */
valeyev 0:e056ac8fecf8 2136 template <typename F>
valeyev 0:e056ac8fecf8 2137 Event(EventQueue *q, F f) {
valeyev 0:e056ac8fecf8 2138 _event = static_cast<struct event *>(
valeyev 0:e056ac8fecf8 2139 equeue_alloc(&q->_equeue, sizeof(struct event) + sizeof(F)));
valeyev 0:e056ac8fecf8 2140
valeyev 0:e056ac8fecf8 2141 if (_event) {
valeyev 0:e056ac8fecf8 2142 _event->equeue = &q->_equeue;
valeyev 0:e056ac8fecf8 2143 _event->id = 0;
valeyev 0:e056ac8fecf8 2144 _event->delay = 0;
valeyev 0:e056ac8fecf8 2145 _event->period = -1;
valeyev 0:e056ac8fecf8 2146
valeyev 0:e056ac8fecf8 2147 _event->post = &Event::event_post<F>;
valeyev 0:e056ac8fecf8 2148 _event->dtor = &Event::event_dtor<F>;
valeyev 0:e056ac8fecf8 2149
valeyev 0:e056ac8fecf8 2150 new (_event+1) F(f);
valeyev 0:e056ac8fecf8 2151
valeyev 0:e056ac8fecf8 2152 _event->ref = 1;
valeyev 0:e056ac8fecf8 2153 }
valeyev 0:e056ac8fecf8 2154 }
valeyev 0:e056ac8fecf8 2155
valeyev 0:e056ac8fecf8 2156 /** Copy constructor for events
valeyev 0:e056ac8fecf8 2157 */
valeyev 0:e056ac8fecf8 2158 Event(const Event &e) {
valeyev 0:e056ac8fecf8 2159 _event = 0;
valeyev 0:e056ac8fecf8 2160 if (e._event) {
valeyev 0:e056ac8fecf8 2161 _event = e._event;
valeyev 0:e056ac8fecf8 2162 _event->ref += 1;
valeyev 0:e056ac8fecf8 2163 }
valeyev 0:e056ac8fecf8 2164 }
valeyev 0:e056ac8fecf8 2165
valeyev 0:e056ac8fecf8 2166 /** Assignment operator for events
valeyev 0:e056ac8fecf8 2167 */
valeyev 0:e056ac8fecf8 2168 Event &operator=(const Event &that) {
valeyev 0:e056ac8fecf8 2169 if (this != &that) {
valeyev 0:e056ac8fecf8 2170 this->~Event();
valeyev 0:e056ac8fecf8 2171 new (this) Event(that);
valeyev 0:e056ac8fecf8 2172 }
valeyev 0:e056ac8fecf8 2173
valeyev 0:e056ac8fecf8 2174 return *this;
valeyev 0:e056ac8fecf8 2175 }
valeyev 0:e056ac8fecf8 2176
valeyev 0:e056ac8fecf8 2177 /** Destructor for events
valeyev 0:e056ac8fecf8 2178 */
valeyev 0:e056ac8fecf8 2179 ~Event() {
valeyev 0:e056ac8fecf8 2180 if (_event) {
valeyev 0:e056ac8fecf8 2181 _event->ref -= 1;
valeyev 0:e056ac8fecf8 2182 if (_event->ref == 0) {
valeyev 0:e056ac8fecf8 2183 _event->dtor(_event);
valeyev 0:e056ac8fecf8 2184 equeue_dealloc(_event->equeue, _event);
valeyev 0:e056ac8fecf8 2185 }
valeyev 0:e056ac8fecf8 2186 }
valeyev 0:e056ac8fecf8 2187 }
valeyev 0:e056ac8fecf8 2188
valeyev 0:e056ac8fecf8 2189 /** Configure the delay of an event
valeyev 0:e056ac8fecf8 2190 *
valeyev 0:e056ac8fecf8 2191 * @param delay Millisecond delay before dispatching the event
valeyev 0:e056ac8fecf8 2192 */
valeyev 0:e056ac8fecf8 2193 void delay(int delay) {
valeyev 0:e056ac8fecf8 2194 if (_event) {
valeyev 0:e056ac8fecf8 2195 _event->delay = delay;
valeyev 0:e056ac8fecf8 2196 }
valeyev 0:e056ac8fecf8 2197 }
valeyev 0:e056ac8fecf8 2198
valeyev 0:e056ac8fecf8 2199 /** Configure the period of an event
valeyev 0:e056ac8fecf8 2200 *
valeyev 0:e056ac8fecf8 2201 * @param period Millisecond period for repeatedly dispatching an event
valeyev 0:e056ac8fecf8 2202 */
valeyev 0:e056ac8fecf8 2203 void period(int period) {
valeyev 0:e056ac8fecf8 2204 if (_event) {
valeyev 0:e056ac8fecf8 2205 _event->period = period;
valeyev 0:e056ac8fecf8 2206 }
valeyev 0:e056ac8fecf8 2207 }
valeyev 0:e056ac8fecf8 2208
valeyev 0:e056ac8fecf8 2209 /** Posts an event onto the underlying event queue
valeyev 0:e056ac8fecf8 2210 *
valeyev 0:e056ac8fecf8 2211 * The event is posted to the underlying queue and is executed in the
valeyev 0:e056ac8fecf8 2212 * context of the event queue's dispatch loop.
valeyev 0:e056ac8fecf8 2213 *
valeyev 0:e056ac8fecf8 2214 * The post function is irq safe and can act as a mechanism for moving
valeyev 0:e056ac8fecf8 2215 * events out of irq contexts.
valeyev 0:e056ac8fecf8 2216 *
valeyev 0:e056ac8fecf8 2217 * @param a0,a1,a2,a3,a4 Arguments to pass to the event
valeyev 0:e056ac8fecf8 2218 * @return A unique id that represents the posted event and can
valeyev 0:e056ac8fecf8 2219 * be passed to EventQueue::cancel, or an id of 0 if
valeyev 0:e056ac8fecf8 2220 * there is not enough memory to allocate the event.
valeyev 0:e056ac8fecf8 2221 */
valeyev 0:e056ac8fecf8 2222 int post(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const {
valeyev 0:e056ac8fecf8 2223 if (!_event) {
valeyev 0:e056ac8fecf8 2224 return 0;
valeyev 0:e056ac8fecf8 2225 }
valeyev 0:e056ac8fecf8 2226
valeyev 0:e056ac8fecf8 2227 _event->id = _event->post(_event, a0, a1, a2, a3, a4);
valeyev 0:e056ac8fecf8 2228 return _event->id;
valeyev 0:e056ac8fecf8 2229 }
valeyev 0:e056ac8fecf8 2230
valeyev 0:e056ac8fecf8 2231 /** Posts an event onto the underlying event queue, returning void
valeyev 0:e056ac8fecf8 2232 *
valeyev 0:e056ac8fecf8 2233 * @param a0,a1,a2,a3,a4 Arguments to pass to the event
valeyev 0:e056ac8fecf8 2234 */
valeyev 0:e056ac8fecf8 2235 void call(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const {
valeyev 0:e056ac8fecf8 2236 MBED_UNUSED int id = post(a0, a1, a2, a3, a4);
valeyev 0:e056ac8fecf8 2237 MBED_ASSERT(id);
valeyev 0:e056ac8fecf8 2238 }
valeyev 0:e056ac8fecf8 2239
valeyev 0:e056ac8fecf8 2240 /** Posts an event onto the underlying event queue, returning void
valeyev 0:e056ac8fecf8 2241 *
valeyev 0:e056ac8fecf8 2242 * @param a0,a1,a2,a3,a4 Arguments to pass to the event
valeyev 0:e056ac8fecf8 2243 */
valeyev 0:e056ac8fecf8 2244 void operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const {
valeyev 0:e056ac8fecf8 2245 return call(a0, a1, a2, a3, a4);
valeyev 0:e056ac8fecf8 2246 }
valeyev 0:e056ac8fecf8 2247
valeyev 0:e056ac8fecf8 2248 /** Static thunk for passing as C-style function
valeyev 0:e056ac8fecf8 2249 *
valeyev 0:e056ac8fecf8 2250 * @param func Event to call passed as a void pointer
valeyev 0:e056ac8fecf8 2251 * @param a0,a1,a2,a3,a4 Arguments to pass to the event
valeyev 0:e056ac8fecf8 2252 */
valeyev 0:e056ac8fecf8 2253 static void thunk(void *func, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
valeyev 0:e056ac8fecf8 2254 return static_cast<Event*>(func)->call(a0, a1, a2, a3, a4);
valeyev 0:e056ac8fecf8 2255 }
valeyev 0:e056ac8fecf8 2256
valeyev 0:e056ac8fecf8 2257 /** Cancels the most recently posted event
valeyev 0:e056ac8fecf8 2258 *
valeyev 0:e056ac8fecf8 2259 * Attempts to cancel the most recently posted event. It is safe to call
valeyev 0:e056ac8fecf8 2260 * cancel after an event has already been dispatched.
valeyev 0:e056ac8fecf8 2261 *
valeyev 0:e056ac8fecf8 2262 * The cancel function is irq safe.
valeyev 0:e056ac8fecf8 2263 *
valeyev 0:e056ac8fecf8 2264 * If called while the event queue's dispatch loop is active, the cancel
valeyev 0:e056ac8fecf8 2265 * function does not garuntee that the event will not execute after it
valeyev 0:e056ac8fecf8 2266 * returns, as the event may have already begun executing.
valeyev 0:e056ac8fecf8 2267 */
valeyev 0:e056ac8fecf8 2268 void cancel() const {
valeyev 0:e056ac8fecf8 2269 if (_event) {
valeyev 0:e056ac8fecf8 2270 equeue_cancel(_event->equeue, _event->id);
valeyev 0:e056ac8fecf8 2271 }
valeyev 0:e056ac8fecf8 2272 }
valeyev 0:e056ac8fecf8 2273
valeyev 0:e056ac8fecf8 2274 private:
valeyev 0:e056ac8fecf8 2275 struct event {
valeyev 0:e056ac8fecf8 2276 unsigned ref;
valeyev 0:e056ac8fecf8 2277 equeue_t *equeue;
valeyev 0:e056ac8fecf8 2278 int id;
valeyev 0:e056ac8fecf8 2279
valeyev 0:e056ac8fecf8 2280 int delay;
valeyev 0:e056ac8fecf8 2281 int period;
valeyev 0:e056ac8fecf8 2282
valeyev 0:e056ac8fecf8 2283 int (*post)(struct event *, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4);
valeyev 0:e056ac8fecf8 2284 void (*dtor)(struct event *);
valeyev 0:e056ac8fecf8 2285
valeyev 0:e056ac8fecf8 2286 // F follows
valeyev 0:e056ac8fecf8 2287 } *_event;
valeyev 0:e056ac8fecf8 2288
valeyev 0:e056ac8fecf8 2289 // Event attributes
valeyev 0:e056ac8fecf8 2290 template <typename F>
valeyev 0:e056ac8fecf8 2291 static int event_post(struct event *e, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
valeyev 0:e056ac8fecf8 2292 typedef EventQueue::context50<F, A0, A1, A2, A3, A4> C;
valeyev 0:e056ac8fecf8 2293 void *p = equeue_alloc(e->equeue, sizeof(C));
valeyev 0:e056ac8fecf8 2294 if (!p) {
valeyev 0:e056ac8fecf8 2295 return 0;
valeyev 0:e056ac8fecf8 2296 }
valeyev 0:e056ac8fecf8 2297
valeyev 0:e056ac8fecf8 2298 new (p) C(*(F*)(e + 1), a0, a1, a2, a3, a4);
valeyev 0:e056ac8fecf8 2299 equeue_event_delay(p, e->delay);
valeyev 0:e056ac8fecf8 2300 equeue_event_period(p, e->period);
valeyev 0:e056ac8fecf8 2301 equeue_event_dtor(p, &EventQueue::function_dtor<C>);
valeyev 0:e056ac8fecf8 2302 return equeue_post(e->equeue, &EventQueue::function_call<C>, p);
valeyev 0:e056ac8fecf8 2303 }
valeyev 0:e056ac8fecf8 2304
valeyev 0:e056ac8fecf8 2305 template <typename F>
valeyev 0:e056ac8fecf8 2306 static void event_dtor(struct event *e) {
valeyev 0:e056ac8fecf8 2307 ((F*)(e + 1))->~F();
valeyev 0:e056ac8fecf8 2308 }
valeyev 0:e056ac8fecf8 2309
valeyev 0:e056ac8fecf8 2310 public:
valeyev 0:e056ac8fecf8 2311 /** Create an event
valeyev 0:e056ac8fecf8 2312 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 2313 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 2314 * @param c0 Argument to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 2315 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 2316 * memory pool. Must be type-compatible with b0, the
valeyev 0:e056ac8fecf8 2317 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 2318 */
valeyev 0:e056ac8fecf8 2319 template <typename F, typename C0>
valeyev 0:e056ac8fecf8 2320 Event(EventQueue *q, F f, C0 c0) {
valeyev 0:e056ac8fecf8 2321 new (this) Event(q, EventQueue::context15<F, C0, A0, A1, A2, A3, A4>(f, c0));
valeyev 0:e056ac8fecf8 2322 }
valeyev 0:e056ac8fecf8 2323
valeyev 0:e056ac8fecf8 2324 /** Create an event
valeyev 0:e056ac8fecf8 2325 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 2326 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 2327 * @param c0,c1 Arguments to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 2328 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 2329 * memory pool. Must be type-compatible with b0..b1, the
valeyev 0:e056ac8fecf8 2330 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 2331 */
valeyev 0:e056ac8fecf8 2332 template <typename F, typename C0, typename C1>
valeyev 0:e056ac8fecf8 2333 Event(EventQueue *q, F f, C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 2334 new (this) Event(q, EventQueue::context25<F, C0, C1, A0, A1, A2, A3, A4>(f, c0, c1));
valeyev 0:e056ac8fecf8 2335 }
valeyev 0:e056ac8fecf8 2336
valeyev 0:e056ac8fecf8 2337 /** Create an event
valeyev 0:e056ac8fecf8 2338 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 2339 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 2340 * @param c0,c1,c2 Arguments to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 2341 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 2342 * memory pool. Must be type-compatible with b0..b2, the
valeyev 0:e056ac8fecf8 2343 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 2344 */
valeyev 0:e056ac8fecf8 2345 template <typename F, typename C0, typename C1, typename C2>
valeyev 0:e056ac8fecf8 2346 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2) {
valeyev 0:e056ac8fecf8 2347 new (this) Event(q, EventQueue::context35<F, C0, C1, C2, A0, A1, A2, A3, A4>(f, c0, c1, c2));
valeyev 0:e056ac8fecf8 2348 }
valeyev 0:e056ac8fecf8 2349
valeyev 0:e056ac8fecf8 2350 /** Create an event
valeyev 0:e056ac8fecf8 2351 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 2352 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 2353 * @param c0,c1,c2,c3 Arguments to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 2354 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 2355 * memory pool. Must be type-compatible with b0..b3, the
valeyev 0:e056ac8fecf8 2356 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 2357 */
valeyev 0:e056ac8fecf8 2358 template <typename F, typename C0, typename C1, typename C2, typename C3>
valeyev 0:e056ac8fecf8 2359 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3) {
valeyev 0:e056ac8fecf8 2360 new (this) Event(q, EventQueue::context45<F, C0, C1, C2, C3, A0, A1, A2, A3, A4>(f, c0, c1, c2, c3));
valeyev 0:e056ac8fecf8 2361 }
valeyev 0:e056ac8fecf8 2362
valeyev 0:e056ac8fecf8 2363 /** Create an event
valeyev 0:e056ac8fecf8 2364 * @param q Event queue to dispatch on
valeyev 0:e056ac8fecf8 2365 * @param f Function to execute when the event is dispatched
valeyev 0:e056ac8fecf8 2366 * @param c0,c1,c2,c3,c4 Arguments to bind to the callback, these arguments are
valeyev 0:e056ac8fecf8 2367 * allocated on an irq-safe allocator from the event queue's
valeyev 0:e056ac8fecf8 2368 * memory pool. Must be type-compatible with b0..b4, the
valeyev 0:e056ac8fecf8 2369 * arguments to the underlying callback.
valeyev 0:e056ac8fecf8 2370 */
valeyev 0:e056ac8fecf8 2371 template <typename F, typename C0, typename C1, typename C2, typename C3, typename C4>
valeyev 0:e056ac8fecf8 2372 Event(EventQueue *q, F f, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {
valeyev 0:e056ac8fecf8 2373 new (this) Event(q, EventQueue::context55<F, C0, C1, C2, C3, C4, A0, A1, A2, A3, A4>(f, c0, c1, c2, c3, c4));
valeyev 0:e056ac8fecf8 2374 }
valeyev 0:e056ac8fecf8 2375
valeyev 0:e056ac8fecf8 2376 /** Create an event
valeyev 0:e056ac8fecf8 2377 * @see Event::Event
valeyev 0:e056ac8fecf8 2378 */
valeyev 0:e056ac8fecf8 2379 template <typename T, typename R, typename B0>
valeyev 0:e056ac8fecf8 2380 Event(EventQueue *q, T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4), B0 b0) {
valeyev 0:e056ac8fecf8 2381 new (this) Event(q, mbed::callback(obj, method), b0);
valeyev 0:e056ac8fecf8 2382 }
valeyev 0:e056ac8fecf8 2383
valeyev 0:e056ac8fecf8 2384 /** Create an event
valeyev 0:e056ac8fecf8 2385 * @see Event::Event
valeyev 0:e056ac8fecf8 2386 */
valeyev 0:e056ac8fecf8 2387 template <typename T, typename R, typename B0>
valeyev 0:e056ac8fecf8 2388 Event(EventQueue *q, const T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4) const, B0 b0) {
valeyev 0:e056ac8fecf8 2389 new (this) Event(q, mbed::callback(obj, method), b0);
valeyev 0:e056ac8fecf8 2390 }
valeyev 0:e056ac8fecf8 2391
valeyev 0:e056ac8fecf8 2392 /** Create an event
valeyev 0:e056ac8fecf8 2393 * @see Event::Event
valeyev 0:e056ac8fecf8 2394 */
valeyev 0:e056ac8fecf8 2395 template <typename T, typename R, typename B0>
valeyev 0:e056ac8fecf8 2396 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4) volatile, B0 b0) {
valeyev 0:e056ac8fecf8 2397 new (this) Event(q, mbed::callback(obj, method), b0);
valeyev 0:e056ac8fecf8 2398 }
valeyev 0:e056ac8fecf8 2399
valeyev 0:e056ac8fecf8 2400 /** Create an event
valeyev 0:e056ac8fecf8 2401 * @see Event::Event
valeyev 0:e056ac8fecf8 2402 */
valeyev 0:e056ac8fecf8 2403 template <typename T, typename R, typename B0>
valeyev 0:e056ac8fecf8 2404 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4) const volatile, B0 b0) {
valeyev 0:e056ac8fecf8 2405 new (this) Event(q, mbed::callback(obj, method), b0);
valeyev 0:e056ac8fecf8 2406 }
valeyev 0:e056ac8fecf8 2407
valeyev 0:e056ac8fecf8 2408 /** Create an event
valeyev 0:e056ac8fecf8 2409 * @see Event::Event
valeyev 0:e056ac8fecf8 2410 */
valeyev 0:e056ac8fecf8 2411 template <typename T, typename R, typename B0, typename B1>
valeyev 0:e056ac8fecf8 2412 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3, A4), B0 b0, B1 b1) {
valeyev 0:e056ac8fecf8 2413 new (this) Event(q, mbed::callback(obj, method), b0, b1);
valeyev 0:e056ac8fecf8 2414 }
valeyev 0:e056ac8fecf8 2415
valeyev 0:e056ac8fecf8 2416 /** Create an event
valeyev 0:e056ac8fecf8 2417 * @see Event::Event
valeyev 0:e056ac8fecf8 2418 */
valeyev 0:e056ac8fecf8 2419 template <typename T, typename R, typename B0, typename B1>
valeyev 0:e056ac8fecf8 2420 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3, A4) const, B0 b0, B1 b1) {
valeyev 0:e056ac8fecf8 2421 new (this) Event(q, mbed::callback(obj, method), b0, b1);
valeyev 0:e056ac8fecf8 2422 }
valeyev 0:e056ac8fecf8 2423
valeyev 0:e056ac8fecf8 2424 /** Create an event
valeyev 0:e056ac8fecf8 2425 * @see Event::Event
valeyev 0:e056ac8fecf8 2426 */
valeyev 0:e056ac8fecf8 2427 template <typename T, typename R, typename B0, typename B1>
valeyev 0:e056ac8fecf8 2428 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3, A4) volatile, B0 b0, B1 b1) {
valeyev 0:e056ac8fecf8 2429 new (this) Event(q, mbed::callback(obj, method), b0, b1);
valeyev 0:e056ac8fecf8 2430 }
valeyev 0:e056ac8fecf8 2431
valeyev 0:e056ac8fecf8 2432 /** Create an event
valeyev 0:e056ac8fecf8 2433 * @see Event::Event
valeyev 0:e056ac8fecf8 2434 */
valeyev 0:e056ac8fecf8 2435 template <typename T, typename R, typename B0, typename B1>
valeyev 0:e056ac8fecf8 2436 Event(EventQueue *q, const volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3, A4) const volatile, B0 b0, B1 b1) {
valeyev 0:e056ac8fecf8 2437 new (this) Event(q, mbed::callback(obj, method), b0, b1);
valeyev 0:e056ac8fecf8 2438 }
valeyev 0:e056ac8fecf8 2439
valeyev 0:e056ac8fecf8 2440 /** Create an event
valeyev 0:e056ac8fecf8 2441 * @see Event::Event
valeyev 0:e056ac8fecf8 2442 */
valeyev 0:e056ac8fecf8 2443 template <typename T, typename R, typename B0, typename B1, typename B2>
valeyev 0:e056ac8fecf8 2444 Event(EventQueue *q, T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3, A4), B0 b0, B1 b1, B2 b2) {
valeyev 0:e056ac8fecf8 2445 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
valeyev 0:e056ac8fecf8 2446 }
valeyev 0:e056ac8fecf8 2447
valeyev 0:e056ac8fecf8 2448 /** Create an event
valeyev 0:e056ac8fecf8 2449 * @see Event::Event
valeyev 0:e056ac8fecf8 2450 */
valeyev 0:e056ac8fecf8 2451 template <typename T, typename R, typename B0, typename B1, typename B2>
valeyev 0:e056ac8fecf8 2452 Event(EventQueue *q, const T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3, A4) const, B0 b0, B1 b1, B2 b2) {
valeyev 0:e056ac8fecf8 2453 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
valeyev 0:e056ac8fecf8 2454 }
valeyev 0:e056ac8fecf8 2455
valeyev 0:e056ac8fecf8 2456 /** Create an event
valeyev 0:e056ac8fecf8 2457 * @see Event::Event
valeyev 0:e056ac8fecf8 2458 */
valeyev 0:e056ac8fecf8 2459 template <typename T, typename R, typename B0, typename B1, typename B2>
valeyev 0:e056ac8fecf8 2460 Event(EventQueue *q, volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3, A4) volatile, B0 b0, B1 b1, B2 b2) {
valeyev 0:e056ac8fecf8 2461 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
valeyev 0:e056ac8fecf8 2462 }
valeyev 0:e056ac8fecf8 2463
valeyev 0:e056ac8fecf8 2464 /** Create an event
valeyev 0:e056ac8fecf8 2465 * @see Event::Event
valeyev 0:e056ac8fecf8 2466 */
valeyev 0:e056ac8fecf8 2467 template <typename T, typename R, typename B0, typename B1, typename B2>
valeyev 0:e056ac8fecf8 2468 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) {
valeyev 0:e056ac8fecf8 2469 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2);
valeyev 0:e056ac8fecf8 2470 }
valeyev 0:e056ac8fecf8 2471
valeyev 0:e056ac8fecf8 2472 /** Create an event
valeyev 0:e056ac8fecf8 2473 * @see Event::Event
valeyev 0:e056ac8fecf8 2474 */
valeyev 0:e056ac8fecf8 2475 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
valeyev 0:e056ac8fecf8 2476 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) {
valeyev 0:e056ac8fecf8 2477 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
valeyev 0:e056ac8fecf8 2478 }
valeyev 0:e056ac8fecf8 2479
valeyev 0:e056ac8fecf8 2480 /** Create an event
valeyev 0:e056ac8fecf8 2481 * @see Event::Event
valeyev 0:e056ac8fecf8 2482 */
valeyev 0:e056ac8fecf8 2483 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
valeyev 0:e056ac8fecf8 2484 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) {
valeyev 0:e056ac8fecf8 2485 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
valeyev 0:e056ac8fecf8 2486 }
valeyev 0:e056ac8fecf8 2487
valeyev 0:e056ac8fecf8 2488 /** Create an event
valeyev 0:e056ac8fecf8 2489 * @see Event::Event
valeyev 0:e056ac8fecf8 2490 */
valeyev 0:e056ac8fecf8 2491 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
valeyev 0:e056ac8fecf8 2492 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) {
valeyev 0:e056ac8fecf8 2493 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
valeyev 0:e056ac8fecf8 2494 }
valeyev 0:e056ac8fecf8 2495
valeyev 0:e056ac8fecf8 2496 /** Create an event
valeyev 0:e056ac8fecf8 2497 * @see Event::Event
valeyev 0:e056ac8fecf8 2498 */
valeyev 0:e056ac8fecf8 2499 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
valeyev 0:e056ac8fecf8 2500 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) {
valeyev 0:e056ac8fecf8 2501 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3);
valeyev 0:e056ac8fecf8 2502 }
valeyev 0:e056ac8fecf8 2503
valeyev 0:e056ac8fecf8 2504 /** Create an event
valeyev 0:e056ac8fecf8 2505 * @see Event::Event
valeyev 0:e056ac8fecf8 2506 */
valeyev 0:e056ac8fecf8 2507 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
valeyev 0:e056ac8fecf8 2508 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) {
valeyev 0:e056ac8fecf8 2509 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
valeyev 0:e056ac8fecf8 2510 }
valeyev 0:e056ac8fecf8 2511
valeyev 0:e056ac8fecf8 2512 /** Create an event
valeyev 0:e056ac8fecf8 2513 * @see Event::Event
valeyev 0:e056ac8fecf8 2514 */
valeyev 0:e056ac8fecf8 2515 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
valeyev 0:e056ac8fecf8 2516 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) {
valeyev 0:e056ac8fecf8 2517 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
valeyev 0:e056ac8fecf8 2518 }
valeyev 0:e056ac8fecf8 2519
valeyev 0:e056ac8fecf8 2520 /** Create an event
valeyev 0:e056ac8fecf8 2521 * @see Event::Event
valeyev 0:e056ac8fecf8 2522 */
valeyev 0:e056ac8fecf8 2523 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
valeyev 0:e056ac8fecf8 2524 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) {
valeyev 0:e056ac8fecf8 2525 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
valeyev 0:e056ac8fecf8 2526 }
valeyev 0:e056ac8fecf8 2527
valeyev 0:e056ac8fecf8 2528 /** Create an event
valeyev 0:e056ac8fecf8 2529 * @see Event::Event
valeyev 0:e056ac8fecf8 2530 */
valeyev 0:e056ac8fecf8 2531 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
valeyev 0:e056ac8fecf8 2532 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) {
valeyev 0:e056ac8fecf8 2533 new (this) Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4);
valeyev 0:e056ac8fecf8 2534 }
valeyev 0:e056ac8fecf8 2535 };
valeyev 0:e056ac8fecf8 2536
valeyev 0:e056ac8fecf8 2537
valeyev 0:e056ac8fecf8 2538 /** \addtogroup events */
valeyev 0:e056ac8fecf8 2539 /** @{ */
valeyev 0:e056ac8fecf8 2540
valeyev 0:e056ac8fecf8 2541 // Convenience functions declared here to avoid cyclic
valeyev 0:e056ac8fecf8 2542 // dependency between Event and EventQueue
valeyev 0:e056ac8fecf8 2543 template <typename R>
valeyev 0:e056ac8fecf8 2544 Event<void()> EventQueue::event(R (*func)()) {
valeyev 0:e056ac8fecf8 2545 return Event<void()>(this, func);
valeyev 0:e056ac8fecf8 2546 }
valeyev 0:e056ac8fecf8 2547
valeyev 0:e056ac8fecf8 2548 template <typename T, typename R>
valeyev 0:e056ac8fecf8 2549 Event<void()> EventQueue::event(T *obj, R (T::*method)()) {
valeyev 0:e056ac8fecf8 2550 return Event<void()>(this, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 2551 }
valeyev 0:e056ac8fecf8 2552
valeyev 0:e056ac8fecf8 2553 template <typename T, typename R>
valeyev 0:e056ac8fecf8 2554 Event<void()> EventQueue::event(const T *obj, R (T::*method)() const) {
valeyev 0:e056ac8fecf8 2555 return Event<void()>(this, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 2556 }
valeyev 0:e056ac8fecf8 2557
valeyev 0:e056ac8fecf8 2558 template <typename T, typename R>
valeyev 0:e056ac8fecf8 2559 Event<void()> EventQueue::event(volatile T *obj, R (T::*method)() volatile) {
valeyev 0:e056ac8fecf8 2560 return Event<void()>(this, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 2561 }
valeyev 0:e056ac8fecf8 2562
valeyev 0:e056ac8fecf8 2563 template <typename T, typename R>
valeyev 0:e056ac8fecf8 2564 Event<void()> EventQueue::event(const volatile T *obj, R (T::*method)() const volatile) {
valeyev 0:e056ac8fecf8 2565 return Event<void()>(this, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 2566 }
valeyev 0:e056ac8fecf8 2567
valeyev 0:e056ac8fecf8 2568 template <typename R>
valeyev 0:e056ac8fecf8 2569 Event<void()> EventQueue::event(mbed::Callback<R()> cb) {
valeyev 0:e056ac8fecf8 2570 return Event<void()>(this, cb);
valeyev 0:e056ac8fecf8 2571 }
valeyev 0:e056ac8fecf8 2572
valeyev 0:e056ac8fecf8 2573 template <typename R, typename B0, typename C0>
valeyev 0:e056ac8fecf8 2574 Event<void()> EventQueue::event(R (*func)(B0), C0 c0) {
valeyev 0:e056ac8fecf8 2575 return Event<void()>(this, func, c0);
valeyev 0:e056ac8fecf8 2576 }
valeyev 0:e056ac8fecf8 2577
valeyev 0:e056ac8fecf8 2578 template <typename T, typename R, typename B0, typename C0>
valeyev 0:e056ac8fecf8 2579 Event<void()> EventQueue::event(T *obj, R (T::*method)(B0), C0 c0) {
valeyev 0:e056ac8fecf8 2580 return Event<void()>(this, mbed::callback(obj, method), c0);
valeyev 0:e056ac8fecf8 2581 }
valeyev 0:e056ac8fecf8 2582
valeyev 0:e056ac8fecf8 2583 template <typename T, typename R, typename B0, typename C0>
valeyev 0:e056ac8fecf8 2584 Event<void()> EventQueue::event(const T *obj, R (T::*method)(B0) const, C0 c0) {
valeyev 0:e056ac8fecf8 2585 return Event<void()>(this, mbed::callback(obj, method), c0);
valeyev 0:e056ac8fecf8 2586 }
valeyev 0:e056ac8fecf8 2587
valeyev 0:e056ac8fecf8 2588 template <typename T, typename R, typename B0, typename C0>
valeyev 0:e056ac8fecf8 2589 Event<void()> EventQueue::event(volatile T *obj, R (T::*method)(B0) volatile, C0 c0) {
valeyev 0:e056ac8fecf8 2590 return Event<void()>(this, mbed::callback(obj, method), c0);
valeyev 0:e056ac8fecf8 2591 }
valeyev 0:e056ac8fecf8 2592
valeyev 0:e056ac8fecf8 2593 template <typename T, typename R, typename B0, typename C0>
valeyev 0:e056ac8fecf8 2594 Event<void()> EventQueue::event(const volatile T *obj, R (T::*method)(B0) const volatile, C0 c0) {
valeyev 0:e056ac8fecf8 2595 return Event<void()>(this, mbed::callback(obj, method), c0);
valeyev 0:e056ac8fecf8 2596 }
valeyev 0:e056ac8fecf8 2597
valeyev 0:e056ac8fecf8 2598 template <typename R, typename B0, typename C0>
valeyev 0:e056ac8fecf8 2599 Event<void()> EventQueue::event(mbed::Callback<R(B0)> cb, C0 c0) {
valeyev 0:e056ac8fecf8 2600 return Event<void()>(this, cb, c0);
valeyev 0:e056ac8fecf8 2601 }
valeyev 0:e056ac8fecf8 2602
valeyev 0:e056ac8fecf8 2603 template <typename R, typename B0, typename B1, typename C0, typename C1>
valeyev 0:e056ac8fecf8 2604 Event<void()> EventQueue::event(R (*func)(B0, B1), C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 2605 return Event<void()>(this, func, c0, c1);
valeyev 0:e056ac8fecf8 2606 }
valeyev 0:e056ac8fecf8 2607
valeyev 0:e056ac8fecf8 2608 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1>
valeyev 0:e056ac8fecf8 2609 Event<void()> EventQueue::event(T *obj, R (T::*method)(B0, B1), C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 2610 return Event<void()>(this, mbed::callback(obj, method), c0, c1);
valeyev 0:e056ac8fecf8 2611 }
valeyev 0:e056ac8fecf8 2612
valeyev 0:e056ac8fecf8 2613 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1>
valeyev 0:e056ac8fecf8 2614 Event<void()> EventQueue::event(const T *obj, R (T::*method)(B0, B1) const, C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 2615 return Event<void()>(this, mbed::callback(obj, method), c0, c1);
valeyev 0:e056ac8fecf8 2616 }
valeyev 0:e056ac8fecf8 2617
valeyev 0:e056ac8fecf8 2618 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1>
valeyev 0:e056ac8fecf8 2619 Event<void()> EventQueue::event(volatile T *obj, R (T::*method)(B0, B1) volatile, C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 2620 return Event<void()>(this, mbed::callback(obj, method), c0, c1);
valeyev 0:e056ac8fecf8 2621 }
valeyev 0:e056ac8fecf8 2622
valeyev 0:e056ac8fecf8 2623 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1>
valeyev 0:e056ac8fecf8 2624 Event<void()> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1) const volatile, C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 2625 return Event<void()>(this, mbed::callback(obj, method), c0, c1);
valeyev 0:e056ac8fecf8 2626 }
valeyev 0:e056ac8fecf8 2627
valeyev 0:e056ac8fecf8 2628 template <typename R, typename B0, typename B1, typename C0, typename C1>
valeyev 0:e056ac8fecf8 2629 Event<void()> EventQueue::event(mbed::Callback<R(B0, B1)> cb, C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 2630 return Event<void()>(this, cb, c0, c1);
valeyev 0:e056ac8fecf8 2631 }
valeyev 0:e056ac8fecf8 2632
valeyev 0:e056ac8fecf8 2633 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
valeyev 0:e056ac8fecf8 2634 Event<void()> EventQueue::event(R (*func)(B0, B1, B2), C0 c0, C1 c1, C2 c2) {
valeyev 0:e056ac8fecf8 2635 return Event<void()>(this, func, c0, c1, c2);
valeyev 0:e056ac8fecf8 2636 }
valeyev 0:e056ac8fecf8 2637
valeyev 0:e056ac8fecf8 2638 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
valeyev 0:e056ac8fecf8 2639 Event<void()> EventQueue::event(T *obj, R (T::*method)(B0, B1, B2), C0 c0, C1 c1, C2 c2) {
valeyev 0:e056ac8fecf8 2640 return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2);
valeyev 0:e056ac8fecf8 2641 }
valeyev 0:e056ac8fecf8 2642
valeyev 0:e056ac8fecf8 2643 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
valeyev 0:e056ac8fecf8 2644 Event<void()> EventQueue::event(const T *obj, R (T::*method)(B0, B1, B2) const, C0 c0, C1 c1, C2 c2) {
valeyev 0:e056ac8fecf8 2645 return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2);
valeyev 0:e056ac8fecf8 2646 }
valeyev 0:e056ac8fecf8 2647
valeyev 0:e056ac8fecf8 2648 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
valeyev 0:e056ac8fecf8 2649 Event<void()> EventQueue::event(volatile T *obj, R (T::*method)(B0, B1, B2) volatile, C0 c0, C1 c1, C2 c2) {
valeyev 0:e056ac8fecf8 2650 return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2);
valeyev 0:e056ac8fecf8 2651 }
valeyev 0:e056ac8fecf8 2652
valeyev 0:e056ac8fecf8 2653 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
valeyev 0:e056ac8fecf8 2654 Event<void()> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1, B2) const volatile, C0 c0, C1 c1, C2 c2) {
valeyev 0:e056ac8fecf8 2655 return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2);
valeyev 0:e056ac8fecf8 2656 }
valeyev 0:e056ac8fecf8 2657
valeyev 0:e056ac8fecf8 2658 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
valeyev 0:e056ac8fecf8 2659 Event<void()> EventQueue::event(mbed::Callback<R(B0, B1, B2)> cb, C0 c0, C1 c1, C2 c2) {
valeyev 0:e056ac8fecf8 2660 return Event<void()>(this, cb, c0, c1, c2);
valeyev 0:e056ac8fecf8 2661 }
valeyev 0:e056ac8fecf8 2662
valeyev 0:e056ac8fecf8 2663 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
valeyev 0:e056ac8fecf8 2664 Event<void()> EventQueue::event(R (*func)(B0, B1, B2, B3), C0 c0, C1 c1, C2 c2, C3 c3) {
valeyev 0:e056ac8fecf8 2665 return Event<void()>(this, func, c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 2666 }
valeyev 0:e056ac8fecf8 2667
valeyev 0:e056ac8fecf8 2668 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
valeyev 0:e056ac8fecf8 2669 Event<void()> EventQueue::event(T *obj, R (T::*method)(B0, B1, B2, B3), C0 c0, C1 c1, C2 c2, C3 c3) {
valeyev 0:e056ac8fecf8 2670 return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 2671 }
valeyev 0:e056ac8fecf8 2672
valeyev 0:e056ac8fecf8 2673 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
valeyev 0:e056ac8fecf8 2674 Event<void()> EventQueue::event(const T *obj, R (T::*method)(B0, B1, B2, B3) const, C0 c0, C1 c1, C2 c2, C3 c3) {
valeyev 0:e056ac8fecf8 2675 return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 2676 }
valeyev 0:e056ac8fecf8 2677
valeyev 0:e056ac8fecf8 2678 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
valeyev 0:e056ac8fecf8 2679 Event<void()> EventQueue::event(volatile T *obj, R (T::*method)(B0, B1, B2, B3) volatile, C0 c0, C1 c1, C2 c2, C3 c3) {
valeyev 0:e056ac8fecf8 2680 return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 2681 }
valeyev 0:e056ac8fecf8 2682
valeyev 0:e056ac8fecf8 2683 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
valeyev 0:e056ac8fecf8 2684 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) {
valeyev 0:e056ac8fecf8 2685 return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 2686 }
valeyev 0:e056ac8fecf8 2687
valeyev 0:e056ac8fecf8 2688 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
valeyev 0:e056ac8fecf8 2689 Event<void()> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3)> cb, C0 c0, C1 c1, C2 c2, C3 c3) {
valeyev 0:e056ac8fecf8 2690 return Event<void()>(this, cb, c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 2691 }
valeyev 0:e056ac8fecf8 2692
valeyev 0:e056ac8fecf8 2693 template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4>
valeyev 0:e056ac8fecf8 2694 Event<void()> EventQueue::event(R (*func)(B0, B1, B2, B3, B4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {
valeyev 0:e056ac8fecf8 2695 return Event<void()>(this, func, c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 2696 }
valeyev 0:e056ac8fecf8 2697
valeyev 0:e056ac8fecf8 2698 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>
valeyev 0:e056ac8fecf8 2699 Event<void()> EventQueue::event(T *obj, R (T::*method)(B0, B1, B2, B3, B4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {
valeyev 0:e056ac8fecf8 2700 return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 2701 }
valeyev 0:e056ac8fecf8 2702
valeyev 0:e056ac8fecf8 2703 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>
valeyev 0:e056ac8fecf8 2704 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) {
valeyev 0:e056ac8fecf8 2705 return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 2706 }
valeyev 0:e056ac8fecf8 2707
valeyev 0:e056ac8fecf8 2708 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>
valeyev 0:e056ac8fecf8 2709 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) {
valeyev 0:e056ac8fecf8 2710 return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 2711 }
valeyev 0:e056ac8fecf8 2712
valeyev 0:e056ac8fecf8 2713 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>
valeyev 0:e056ac8fecf8 2714 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) {
valeyev 0:e056ac8fecf8 2715 return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 2716 }
valeyev 0:e056ac8fecf8 2717
valeyev 0:e056ac8fecf8 2718 template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4>
valeyev 0:e056ac8fecf8 2719 Event<void()> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, B4)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {
valeyev 0:e056ac8fecf8 2720 return Event<void()>(this, cb, c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 2721 }
valeyev 0:e056ac8fecf8 2722
valeyev 0:e056ac8fecf8 2723 template <typename R, typename A0>
valeyev 0:e056ac8fecf8 2724 Event<void(A0)> EventQueue::event(R (*func)(A0)) {
valeyev 0:e056ac8fecf8 2725 return Event<void(A0)>(this, func);
valeyev 0:e056ac8fecf8 2726 }
valeyev 0:e056ac8fecf8 2727
valeyev 0:e056ac8fecf8 2728 template <typename T, typename R, typename A0>
valeyev 0:e056ac8fecf8 2729 Event<void(A0)> EventQueue::event(T *obj, R (T::*method)(A0)) {
valeyev 0:e056ac8fecf8 2730 return Event<void(A0)>(this, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 2731 }
valeyev 0:e056ac8fecf8 2732
valeyev 0:e056ac8fecf8 2733 template <typename T, typename R, typename A0>
valeyev 0:e056ac8fecf8 2734 Event<void(A0)> EventQueue::event(const T *obj, R (T::*method)(A0) const) {
valeyev 0:e056ac8fecf8 2735 return Event<void(A0)>(this, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 2736 }
valeyev 0:e056ac8fecf8 2737
valeyev 0:e056ac8fecf8 2738 template <typename T, typename R, typename A0>
valeyev 0:e056ac8fecf8 2739 Event<void(A0)> EventQueue::event(volatile T *obj, R (T::*method)(A0) volatile) {
valeyev 0:e056ac8fecf8 2740 return Event<void(A0)>(this, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 2741 }
valeyev 0:e056ac8fecf8 2742
valeyev 0:e056ac8fecf8 2743 template <typename T, typename R, typename A0>
valeyev 0:e056ac8fecf8 2744 Event<void(A0)> EventQueue::event(const volatile T *obj, R (T::*method)(A0) const volatile) {
valeyev 0:e056ac8fecf8 2745 return Event<void(A0)>(this, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 2746 }
valeyev 0:e056ac8fecf8 2747
valeyev 0:e056ac8fecf8 2748 template <typename R, typename A0>
valeyev 0:e056ac8fecf8 2749 Event<void(A0)> EventQueue::event(mbed::Callback<R(A0)> cb) {
valeyev 0:e056ac8fecf8 2750 return Event<void(A0)>(this, cb);
valeyev 0:e056ac8fecf8 2751 }
valeyev 0:e056ac8fecf8 2752
valeyev 0:e056ac8fecf8 2753 template <typename R, typename B0, typename C0, typename A0>
valeyev 0:e056ac8fecf8 2754 Event<void(A0)> EventQueue::event(R (*func)(B0, A0), C0 c0) {
valeyev 0:e056ac8fecf8 2755 return Event<void(A0)>(this, func, c0);
valeyev 0:e056ac8fecf8 2756 }
valeyev 0:e056ac8fecf8 2757
valeyev 0:e056ac8fecf8 2758 template <typename T, typename R, typename B0, typename C0, typename A0>
valeyev 0:e056ac8fecf8 2759 Event<void(A0)> EventQueue::event(T *obj, R (T::*method)(B0, A0), C0 c0) {
valeyev 0:e056ac8fecf8 2760 return Event<void(A0)>(this, mbed::callback(obj, method), c0);
valeyev 0:e056ac8fecf8 2761 }
valeyev 0:e056ac8fecf8 2762
valeyev 0:e056ac8fecf8 2763 template <typename T, typename R, typename B0, typename C0, typename A0>
valeyev 0:e056ac8fecf8 2764 Event<void(A0)> EventQueue::event(const T *obj, R (T::*method)(B0, A0) const, C0 c0) {
valeyev 0:e056ac8fecf8 2765 return Event<void(A0)>(this, mbed::callback(obj, method), c0);
valeyev 0:e056ac8fecf8 2766 }
valeyev 0:e056ac8fecf8 2767
valeyev 0:e056ac8fecf8 2768 template <typename T, typename R, typename B0, typename C0, typename A0>
valeyev 0:e056ac8fecf8 2769 Event<void(A0)> EventQueue::event(volatile T *obj, R (T::*method)(B0, A0) volatile, C0 c0) {
valeyev 0:e056ac8fecf8 2770 return Event<void(A0)>(this, mbed::callback(obj, method), c0);
valeyev 0:e056ac8fecf8 2771 }
valeyev 0:e056ac8fecf8 2772
valeyev 0:e056ac8fecf8 2773 template <typename T, typename R, typename B0, typename C0, typename A0>
valeyev 0:e056ac8fecf8 2774 Event<void(A0)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, A0) const volatile, C0 c0) {
valeyev 0:e056ac8fecf8 2775 return Event<void(A0)>(this, mbed::callback(obj, method), c0);
valeyev 0:e056ac8fecf8 2776 }
valeyev 0:e056ac8fecf8 2777
valeyev 0:e056ac8fecf8 2778 template <typename R, typename B0, typename C0, typename A0>
valeyev 0:e056ac8fecf8 2779 Event<void(A0)> EventQueue::event(mbed::Callback<R(B0, A0)> cb, C0 c0) {
valeyev 0:e056ac8fecf8 2780 return Event<void(A0)>(this, cb, c0);
valeyev 0:e056ac8fecf8 2781 }
valeyev 0:e056ac8fecf8 2782
valeyev 0:e056ac8fecf8 2783 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
valeyev 0:e056ac8fecf8 2784 Event<void(A0)> EventQueue::event(R (*func)(B0, B1, A0), C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 2785 return Event<void(A0)>(this, func, c0, c1);
valeyev 0:e056ac8fecf8 2786 }
valeyev 0:e056ac8fecf8 2787
valeyev 0:e056ac8fecf8 2788 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
valeyev 0:e056ac8fecf8 2789 Event<void(A0)> EventQueue::event(T *obj, R (T::*method)(B0, B1, A0), C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 2790 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1);
valeyev 0:e056ac8fecf8 2791 }
valeyev 0:e056ac8fecf8 2792
valeyev 0:e056ac8fecf8 2793 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
valeyev 0:e056ac8fecf8 2794 Event<void(A0)> EventQueue::event(const T *obj, R (T::*method)(B0, B1, A0) const, C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 2795 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1);
valeyev 0:e056ac8fecf8 2796 }
valeyev 0:e056ac8fecf8 2797
valeyev 0:e056ac8fecf8 2798 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
valeyev 0:e056ac8fecf8 2799 Event<void(A0)> EventQueue::event(volatile T *obj, R (T::*method)(B0, B1, A0) volatile, C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 2800 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1);
valeyev 0:e056ac8fecf8 2801 }
valeyev 0:e056ac8fecf8 2802
valeyev 0:e056ac8fecf8 2803 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
valeyev 0:e056ac8fecf8 2804 Event<void(A0)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1, A0) const volatile, C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 2805 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1);
valeyev 0:e056ac8fecf8 2806 }
valeyev 0:e056ac8fecf8 2807
valeyev 0:e056ac8fecf8 2808 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
valeyev 0:e056ac8fecf8 2809 Event<void(A0)> EventQueue::event(mbed::Callback<R(B0, B1, A0)> cb, C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 2810 return Event<void(A0)>(this, cb, c0, c1);
valeyev 0:e056ac8fecf8 2811 }
valeyev 0:e056ac8fecf8 2812
valeyev 0:e056ac8fecf8 2813 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
valeyev 0:e056ac8fecf8 2814 Event<void(A0)> EventQueue::event(R (*func)(B0, B1, B2, A0), C0 c0, C1 c1, C2 c2) {
valeyev 0:e056ac8fecf8 2815 return Event<void(A0)>(this, func, c0, c1, c2);
valeyev 0:e056ac8fecf8 2816 }
valeyev 0:e056ac8fecf8 2817
valeyev 0:e056ac8fecf8 2818 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
valeyev 0:e056ac8fecf8 2819 Event<void(A0)> EventQueue::event(T *obj, R (T::*method)(B0, B1, B2, A0), C0 c0, C1 c1, C2 c2) {
valeyev 0:e056ac8fecf8 2820 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2);
valeyev 0:e056ac8fecf8 2821 }
valeyev 0:e056ac8fecf8 2822
valeyev 0:e056ac8fecf8 2823 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
valeyev 0:e056ac8fecf8 2824 Event<void(A0)> EventQueue::event(const T *obj, R (T::*method)(B0, B1, B2, A0) const, C0 c0, C1 c1, C2 c2) {
valeyev 0:e056ac8fecf8 2825 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2);
valeyev 0:e056ac8fecf8 2826 }
valeyev 0:e056ac8fecf8 2827
valeyev 0:e056ac8fecf8 2828 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
valeyev 0:e056ac8fecf8 2829 Event<void(A0)> EventQueue::event(volatile T *obj, R (T::*method)(B0, B1, B2, A0) volatile, C0 c0, C1 c1, C2 c2) {
valeyev 0:e056ac8fecf8 2830 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2);
valeyev 0:e056ac8fecf8 2831 }
valeyev 0:e056ac8fecf8 2832
valeyev 0:e056ac8fecf8 2833 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
valeyev 0:e056ac8fecf8 2834 Event<void(A0)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1, B2, A0) const volatile, C0 c0, C1 c1, C2 c2) {
valeyev 0:e056ac8fecf8 2835 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2);
valeyev 0:e056ac8fecf8 2836 }
valeyev 0:e056ac8fecf8 2837
valeyev 0:e056ac8fecf8 2838 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
valeyev 0:e056ac8fecf8 2839 Event<void(A0)> EventQueue::event(mbed::Callback<R(B0, B1, B2, A0)> cb, C0 c0, C1 c1, C2 c2) {
valeyev 0:e056ac8fecf8 2840 return Event<void(A0)>(this, cb, c0, c1, c2);
valeyev 0:e056ac8fecf8 2841 }
valeyev 0:e056ac8fecf8 2842
valeyev 0:e056ac8fecf8 2843 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
valeyev 0:e056ac8fecf8 2844 Event<void(A0)> EventQueue::event(R (*func)(B0, B1, B2, B3, A0), C0 c0, C1 c1, C2 c2, C3 c3) {
valeyev 0:e056ac8fecf8 2845 return Event<void(A0)>(this, func, c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 2846 }
valeyev 0:e056ac8fecf8 2847
valeyev 0:e056ac8fecf8 2848 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
valeyev 0:e056ac8fecf8 2849 Event<void(A0)> EventQueue::event(T *obj, R (T::*method)(B0, B1, B2, B3, A0), C0 c0, C1 c1, C2 c2, C3 c3) {
valeyev 0:e056ac8fecf8 2850 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 2851 }
valeyev 0:e056ac8fecf8 2852
valeyev 0:e056ac8fecf8 2853 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
valeyev 0:e056ac8fecf8 2854 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) {
valeyev 0:e056ac8fecf8 2855 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 2856 }
valeyev 0:e056ac8fecf8 2857
valeyev 0:e056ac8fecf8 2858 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
valeyev 0:e056ac8fecf8 2859 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) {
valeyev 0:e056ac8fecf8 2860 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 2861 }
valeyev 0:e056ac8fecf8 2862
valeyev 0:e056ac8fecf8 2863 template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
valeyev 0:e056ac8fecf8 2864 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) {
valeyev 0:e056ac8fecf8 2865 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 2866 }
valeyev 0:e056ac8fecf8 2867
valeyev 0:e056ac8fecf8 2868 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
valeyev 0:e056ac8fecf8 2869 Event<void(A0)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, A0)> cb, C0 c0, C1 c1, C2 c2, C3 c3) {
valeyev 0:e056ac8fecf8 2870 return Event<void(A0)>(this, cb, c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 2871 }
valeyev 0:e056ac8fecf8 2872
valeyev 0:e056ac8fecf8 2873 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>
valeyev 0:e056ac8fecf8 2874 Event<void(A0)> EventQueue::event(R (*func)(B0, B1, B2, B3, B4, A0), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {
valeyev 0:e056ac8fecf8 2875 return Event<void(A0)>(this, func, c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 2876 }
valeyev 0:e056ac8fecf8 2877
valeyev 0:e056ac8fecf8 2878 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>
valeyev 0:e056ac8fecf8 2879 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) {
valeyev 0:e056ac8fecf8 2880 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 2881 }
valeyev 0:e056ac8fecf8 2882
valeyev 0:e056ac8fecf8 2883 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>
valeyev 0:e056ac8fecf8 2884 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) {
valeyev 0:e056ac8fecf8 2885 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 2886 }
valeyev 0:e056ac8fecf8 2887
valeyev 0:e056ac8fecf8 2888 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>
valeyev 0:e056ac8fecf8 2889 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) {
valeyev 0:e056ac8fecf8 2890 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 2891 }
valeyev 0:e056ac8fecf8 2892
valeyev 0:e056ac8fecf8 2893 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>
valeyev 0:e056ac8fecf8 2894 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) {
valeyev 0:e056ac8fecf8 2895 return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 2896 }
valeyev 0:e056ac8fecf8 2897
valeyev 0:e056ac8fecf8 2898 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>
valeyev 0:e056ac8fecf8 2899 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) {
valeyev 0:e056ac8fecf8 2900 return Event<void(A0)>(this, cb, c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 2901 }
valeyev 0:e056ac8fecf8 2902
valeyev 0:e056ac8fecf8 2903 template <typename R, typename A0, typename A1>
valeyev 0:e056ac8fecf8 2904 Event<void(A0, A1)> EventQueue::event(R (*func)(A0, A1)) {
valeyev 0:e056ac8fecf8 2905 return Event<void(A0, A1)>(this, func);
valeyev 0:e056ac8fecf8 2906 }
valeyev 0:e056ac8fecf8 2907
valeyev 0:e056ac8fecf8 2908 template <typename T, typename R, typename A0, typename A1>
valeyev 0:e056ac8fecf8 2909 Event<void(A0, A1)> EventQueue::event(T *obj, R (T::*method)(A0, A1)) {
valeyev 0:e056ac8fecf8 2910 return Event<void(A0, A1)>(this, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 2911 }
valeyev 0:e056ac8fecf8 2912
valeyev 0:e056ac8fecf8 2913 template <typename T, typename R, typename A0, typename A1>
valeyev 0:e056ac8fecf8 2914 Event<void(A0, A1)> EventQueue::event(const T *obj, R (T::*method)(A0, A1) const) {
valeyev 0:e056ac8fecf8 2915 return Event<void(A0, A1)>(this, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 2916 }
valeyev 0:e056ac8fecf8 2917
valeyev 0:e056ac8fecf8 2918 template <typename T, typename R, typename A0, typename A1>
valeyev 0:e056ac8fecf8 2919 Event<void(A0, A1)> EventQueue::event(volatile T *obj, R (T::*method)(A0, A1) volatile) {
valeyev 0:e056ac8fecf8 2920 return Event<void(A0, A1)>(this, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 2921 }
valeyev 0:e056ac8fecf8 2922
valeyev 0:e056ac8fecf8 2923 template <typename T, typename R, typename A0, typename A1>
valeyev 0:e056ac8fecf8 2924 Event<void(A0, A1)> EventQueue::event(const volatile T *obj, R (T::*method)(A0, A1) const volatile) {
valeyev 0:e056ac8fecf8 2925 return Event<void(A0, A1)>(this, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 2926 }
valeyev 0:e056ac8fecf8 2927
valeyev 0:e056ac8fecf8 2928 template <typename R, typename A0, typename A1>
valeyev 0:e056ac8fecf8 2929 Event<void(A0, A1)> EventQueue::event(mbed::Callback<R(A0, A1)> cb) {
valeyev 0:e056ac8fecf8 2930 return Event<void(A0, A1)>(this, cb);
valeyev 0:e056ac8fecf8 2931 }
valeyev 0:e056ac8fecf8 2932
valeyev 0:e056ac8fecf8 2933 template <typename R, typename B0, typename C0, typename A0, typename A1>
valeyev 0:e056ac8fecf8 2934 Event<void(A0, A1)> EventQueue::event(R (*func)(B0, A0, A1), C0 c0) {
valeyev 0:e056ac8fecf8 2935 return Event<void(A0, A1)>(this, func, c0);
valeyev 0:e056ac8fecf8 2936 }
valeyev 0:e056ac8fecf8 2937
valeyev 0:e056ac8fecf8 2938 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1>
valeyev 0:e056ac8fecf8 2939 Event<void(A0, A1)> EventQueue::event(T *obj, R (T::*method)(B0, A0, A1), C0 c0) {
valeyev 0:e056ac8fecf8 2940 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0);
valeyev 0:e056ac8fecf8 2941 }
valeyev 0:e056ac8fecf8 2942
valeyev 0:e056ac8fecf8 2943 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1>
valeyev 0:e056ac8fecf8 2944 Event<void(A0, A1)> EventQueue::event(const T *obj, R (T::*method)(B0, A0, A1) const, C0 c0) {
valeyev 0:e056ac8fecf8 2945 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0);
valeyev 0:e056ac8fecf8 2946 }
valeyev 0:e056ac8fecf8 2947
valeyev 0:e056ac8fecf8 2948 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1>
valeyev 0:e056ac8fecf8 2949 Event<void(A0, A1)> EventQueue::event(volatile T *obj, R (T::*method)(B0, A0, A1) volatile, C0 c0) {
valeyev 0:e056ac8fecf8 2950 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0);
valeyev 0:e056ac8fecf8 2951 }
valeyev 0:e056ac8fecf8 2952
valeyev 0:e056ac8fecf8 2953 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1>
valeyev 0:e056ac8fecf8 2954 Event<void(A0, A1)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, A0, A1) const volatile, C0 c0) {
valeyev 0:e056ac8fecf8 2955 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0);
valeyev 0:e056ac8fecf8 2956 }
valeyev 0:e056ac8fecf8 2957
valeyev 0:e056ac8fecf8 2958 template <typename R, typename B0, typename C0, typename A0, typename A1>
valeyev 0:e056ac8fecf8 2959 Event<void(A0, A1)> EventQueue::event(mbed::Callback<R(B0, A0, A1)> cb, C0 c0) {
valeyev 0:e056ac8fecf8 2960 return Event<void(A0, A1)>(this, cb, c0);
valeyev 0:e056ac8fecf8 2961 }
valeyev 0:e056ac8fecf8 2962
valeyev 0:e056ac8fecf8 2963 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
valeyev 0:e056ac8fecf8 2964 Event<void(A0, A1)> EventQueue::event(R (*func)(B0, B1, A0, A1), C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 2965 return Event<void(A0, A1)>(this, func, c0, c1);
valeyev 0:e056ac8fecf8 2966 }
valeyev 0:e056ac8fecf8 2967
valeyev 0:e056ac8fecf8 2968 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
valeyev 0:e056ac8fecf8 2969 Event<void(A0, A1)> EventQueue::event(T *obj, R (T::*method)(B0, B1, A0, A1), C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 2970 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1);
valeyev 0:e056ac8fecf8 2971 }
valeyev 0:e056ac8fecf8 2972
valeyev 0:e056ac8fecf8 2973 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
valeyev 0:e056ac8fecf8 2974 Event<void(A0, A1)> EventQueue::event(const T *obj, R (T::*method)(B0, B1, A0, A1) const, C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 2975 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1);
valeyev 0:e056ac8fecf8 2976 }
valeyev 0:e056ac8fecf8 2977
valeyev 0:e056ac8fecf8 2978 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
valeyev 0:e056ac8fecf8 2979 Event<void(A0, A1)> EventQueue::event(volatile T *obj, R (T::*method)(B0, B1, A0, A1) volatile, C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 2980 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1);
valeyev 0:e056ac8fecf8 2981 }
valeyev 0:e056ac8fecf8 2982
valeyev 0:e056ac8fecf8 2983 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
valeyev 0:e056ac8fecf8 2984 Event<void(A0, A1)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1, A0, A1) const volatile, C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 2985 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1);
valeyev 0:e056ac8fecf8 2986 }
valeyev 0:e056ac8fecf8 2987
valeyev 0:e056ac8fecf8 2988 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
valeyev 0:e056ac8fecf8 2989 Event<void(A0, A1)> EventQueue::event(mbed::Callback<R(B0, B1, A0, A1)> cb, C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 2990 return Event<void(A0, A1)>(this, cb, c0, c1);
valeyev 0:e056ac8fecf8 2991 }
valeyev 0:e056ac8fecf8 2992
valeyev 0:e056ac8fecf8 2993 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
valeyev 0:e056ac8fecf8 2994 Event<void(A0, A1)> EventQueue::event(R (*func)(B0, B1, B2, A0, A1), C0 c0, C1 c1, C2 c2) {
valeyev 0:e056ac8fecf8 2995 return Event<void(A0, A1)>(this, func, c0, c1, c2);
valeyev 0:e056ac8fecf8 2996 }
valeyev 0:e056ac8fecf8 2997
valeyev 0:e056ac8fecf8 2998 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
valeyev 0:e056ac8fecf8 2999 Event<void(A0, A1)> EventQueue::event(T *obj, R (T::*method)(B0, B1, B2, A0, A1), C0 c0, C1 c1, C2 c2) {
valeyev 0:e056ac8fecf8 3000 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2);
valeyev 0:e056ac8fecf8 3001 }
valeyev 0:e056ac8fecf8 3002
valeyev 0:e056ac8fecf8 3003 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
valeyev 0:e056ac8fecf8 3004 Event<void(A0, A1)> EventQueue::event(const T *obj, R (T::*method)(B0, B1, B2, A0, A1) const, C0 c0, C1 c1, C2 c2) {
valeyev 0:e056ac8fecf8 3005 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2);
valeyev 0:e056ac8fecf8 3006 }
valeyev 0:e056ac8fecf8 3007
valeyev 0:e056ac8fecf8 3008 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
valeyev 0:e056ac8fecf8 3009 Event<void(A0, A1)> EventQueue::event(volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1) volatile, C0 c0, C1 c1, C2 c2) {
valeyev 0:e056ac8fecf8 3010 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2);
valeyev 0:e056ac8fecf8 3011 }
valeyev 0:e056ac8fecf8 3012
valeyev 0:e056ac8fecf8 3013 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
valeyev 0:e056ac8fecf8 3014 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) {
valeyev 0:e056ac8fecf8 3015 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2);
valeyev 0:e056ac8fecf8 3016 }
valeyev 0:e056ac8fecf8 3017
valeyev 0:e056ac8fecf8 3018 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
valeyev 0:e056ac8fecf8 3019 Event<void(A0, A1)> EventQueue::event(mbed::Callback<R(B0, B1, B2, A0, A1)> cb, C0 c0, C1 c1, C2 c2) {
valeyev 0:e056ac8fecf8 3020 return Event<void(A0, A1)>(this, cb, c0, c1, c2);
valeyev 0:e056ac8fecf8 3021 }
valeyev 0:e056ac8fecf8 3022
valeyev 0:e056ac8fecf8 3023 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1>
valeyev 0:e056ac8fecf8 3024 Event<void(A0, A1)> EventQueue::event(R (*func)(B0, B1, B2, B3, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3) {
valeyev 0:e056ac8fecf8 3025 return Event<void(A0, A1)>(this, func, c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 3026 }
valeyev 0:e056ac8fecf8 3027
valeyev 0:e056ac8fecf8 3028 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>
valeyev 0:e056ac8fecf8 3029 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) {
valeyev 0:e056ac8fecf8 3030 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 3031 }
valeyev 0:e056ac8fecf8 3032
valeyev 0:e056ac8fecf8 3033 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>
valeyev 0:e056ac8fecf8 3034 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) {
valeyev 0:e056ac8fecf8 3035 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 3036 }
valeyev 0:e056ac8fecf8 3037
valeyev 0:e056ac8fecf8 3038 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>
valeyev 0:e056ac8fecf8 3039 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) {
valeyev 0:e056ac8fecf8 3040 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 3041 }
valeyev 0:e056ac8fecf8 3042
valeyev 0:e056ac8fecf8 3043 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>
valeyev 0:e056ac8fecf8 3044 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) {
valeyev 0:e056ac8fecf8 3045 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 3046 }
valeyev 0:e056ac8fecf8 3047
valeyev 0:e056ac8fecf8 3048 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1>
valeyev 0:e056ac8fecf8 3049 Event<void(A0, A1)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, A0, A1)> cb, C0 c0, C1 c1, C2 c2, C3 c3) {
valeyev 0:e056ac8fecf8 3050 return Event<void(A0, A1)>(this, cb, c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 3051 }
valeyev 0:e056ac8fecf8 3052
valeyev 0:e056ac8fecf8 3053 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>
valeyev 0:e056ac8fecf8 3054 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) {
valeyev 0:e056ac8fecf8 3055 return Event<void(A0, A1)>(this, func, c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 3056 }
valeyev 0:e056ac8fecf8 3057
valeyev 0:e056ac8fecf8 3058 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>
valeyev 0:e056ac8fecf8 3059 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) {
valeyev 0:e056ac8fecf8 3060 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 3061 }
valeyev 0:e056ac8fecf8 3062
valeyev 0:e056ac8fecf8 3063 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>
valeyev 0:e056ac8fecf8 3064 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) {
valeyev 0:e056ac8fecf8 3065 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 3066 }
valeyev 0:e056ac8fecf8 3067
valeyev 0:e056ac8fecf8 3068 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>
valeyev 0:e056ac8fecf8 3069 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) {
valeyev 0:e056ac8fecf8 3070 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 3071 }
valeyev 0:e056ac8fecf8 3072
valeyev 0:e056ac8fecf8 3073 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>
valeyev 0:e056ac8fecf8 3074 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) {
valeyev 0:e056ac8fecf8 3075 return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 3076 }
valeyev 0:e056ac8fecf8 3077
valeyev 0:e056ac8fecf8 3078 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>
valeyev 0:e056ac8fecf8 3079 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) {
valeyev 0:e056ac8fecf8 3080 return Event<void(A0, A1)>(this, cb, c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 3081 }
valeyev 0:e056ac8fecf8 3082
valeyev 0:e056ac8fecf8 3083 template <typename R, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 3084 Event<void(A0, A1, A2)> EventQueue::event(R (*func)(A0, A1, A2)) {
valeyev 0:e056ac8fecf8 3085 return Event<void(A0, A1, A2)>(this, func);
valeyev 0:e056ac8fecf8 3086 }
valeyev 0:e056ac8fecf8 3087
valeyev 0:e056ac8fecf8 3088 template <typename T, typename R, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 3089 Event<void(A0, A1, A2)> EventQueue::event(T *obj, R (T::*method)(A0, A1, A2)) {
valeyev 0:e056ac8fecf8 3090 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 3091 }
valeyev 0:e056ac8fecf8 3092
valeyev 0:e056ac8fecf8 3093 template <typename T, typename R, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 3094 Event<void(A0, A1, A2)> EventQueue::event(const T *obj, R (T::*method)(A0, A1, A2) const) {
valeyev 0:e056ac8fecf8 3095 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 3096 }
valeyev 0:e056ac8fecf8 3097
valeyev 0:e056ac8fecf8 3098 template <typename T, typename R, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 3099 Event<void(A0, A1, A2)> EventQueue::event(volatile T *obj, R (T::*method)(A0, A1, A2) volatile) {
valeyev 0:e056ac8fecf8 3100 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 3101 }
valeyev 0:e056ac8fecf8 3102
valeyev 0:e056ac8fecf8 3103 template <typename T, typename R, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 3104 Event<void(A0, A1, A2)> EventQueue::event(const volatile T *obj, R (T::*method)(A0, A1, A2) const volatile) {
valeyev 0:e056ac8fecf8 3105 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 3106 }
valeyev 0:e056ac8fecf8 3107
valeyev 0:e056ac8fecf8 3108 template <typename R, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 3109 Event<void(A0, A1, A2)> EventQueue::event(mbed::Callback<R(A0, A1, A2)> cb) {
valeyev 0:e056ac8fecf8 3110 return Event<void(A0, A1, A2)>(this, cb);
valeyev 0:e056ac8fecf8 3111 }
valeyev 0:e056ac8fecf8 3112
valeyev 0:e056ac8fecf8 3113 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 3114 Event<void(A0, A1, A2)> EventQueue::event(R (*func)(B0, A0, A1, A2), C0 c0) {
valeyev 0:e056ac8fecf8 3115 return Event<void(A0, A1, A2)>(this, func, c0);
valeyev 0:e056ac8fecf8 3116 }
valeyev 0:e056ac8fecf8 3117
valeyev 0:e056ac8fecf8 3118 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 3119 Event<void(A0, A1, A2)> EventQueue::event(T *obj, R (T::*method)(B0, A0, A1, A2), C0 c0) {
valeyev 0:e056ac8fecf8 3120 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0);
valeyev 0:e056ac8fecf8 3121 }
valeyev 0:e056ac8fecf8 3122
valeyev 0:e056ac8fecf8 3123 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 3124 Event<void(A0, A1, A2)> EventQueue::event(const T *obj, R (T::*method)(B0, A0, A1, A2) const, C0 c0) {
valeyev 0:e056ac8fecf8 3125 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0);
valeyev 0:e056ac8fecf8 3126 }
valeyev 0:e056ac8fecf8 3127
valeyev 0:e056ac8fecf8 3128 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 3129 Event<void(A0, A1, A2)> EventQueue::event(volatile T *obj, R (T::*method)(B0, A0, A1, A2) volatile, C0 c0) {
valeyev 0:e056ac8fecf8 3130 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0);
valeyev 0:e056ac8fecf8 3131 }
valeyev 0:e056ac8fecf8 3132
valeyev 0:e056ac8fecf8 3133 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 3134 Event<void(A0, A1, A2)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, A0, A1, A2) const volatile, C0 c0) {
valeyev 0:e056ac8fecf8 3135 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0);
valeyev 0:e056ac8fecf8 3136 }
valeyev 0:e056ac8fecf8 3137
valeyev 0:e056ac8fecf8 3138 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 3139 Event<void(A0, A1, A2)> EventQueue::event(mbed::Callback<R(B0, A0, A1, A2)> cb, C0 c0) {
valeyev 0:e056ac8fecf8 3140 return Event<void(A0, A1, A2)>(this, cb, c0);
valeyev 0:e056ac8fecf8 3141 }
valeyev 0:e056ac8fecf8 3142
valeyev 0:e056ac8fecf8 3143 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 3144 Event<void(A0, A1, A2)> EventQueue::event(R (*func)(B0, B1, A0, A1, A2), C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 3145 return Event<void(A0, A1, A2)>(this, func, c0, c1);
valeyev 0:e056ac8fecf8 3146 }
valeyev 0:e056ac8fecf8 3147
valeyev 0:e056ac8fecf8 3148 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 3149 Event<void(A0, A1, A2)> EventQueue::event(T *obj, R (T::*method)(B0, B1, A0, A1, A2), C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 3150 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1);
valeyev 0:e056ac8fecf8 3151 }
valeyev 0:e056ac8fecf8 3152
valeyev 0:e056ac8fecf8 3153 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 3154 Event<void(A0, A1, A2)> EventQueue::event(const T *obj, R (T::*method)(B0, B1, A0, A1, A2) const, C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 3155 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1);
valeyev 0:e056ac8fecf8 3156 }
valeyev 0:e056ac8fecf8 3157
valeyev 0:e056ac8fecf8 3158 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 3159 Event<void(A0, A1, A2)> EventQueue::event(volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2) volatile, C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 3160 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1);
valeyev 0:e056ac8fecf8 3161 }
valeyev 0:e056ac8fecf8 3162
valeyev 0:e056ac8fecf8 3163 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 3164 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) {
valeyev 0:e056ac8fecf8 3165 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1);
valeyev 0:e056ac8fecf8 3166 }
valeyev 0:e056ac8fecf8 3167
valeyev 0:e056ac8fecf8 3168 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 3169 Event<void(A0, A1, A2)> EventQueue::event(mbed::Callback<R(B0, B1, A0, A1, A2)> cb, C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 3170 return Event<void(A0, A1, A2)>(this, cb, c0, c1);
valeyev 0:e056ac8fecf8 3171 }
valeyev 0:e056ac8fecf8 3172
valeyev 0:e056ac8fecf8 3173 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 3174 Event<void(A0, A1, A2)> EventQueue::event(R (*func)(B0, B1, B2, A0, A1, A2), C0 c0, C1 c1, C2 c2) {
valeyev 0:e056ac8fecf8 3175 return Event<void(A0, A1, A2)>(this, func, c0, c1, c2);
valeyev 0:e056ac8fecf8 3176 }
valeyev 0:e056ac8fecf8 3177
valeyev 0:e056ac8fecf8 3178 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 3179 Event<void(A0, A1, A2)> EventQueue::event(T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2), C0 c0, C1 c1, C2 c2) {
valeyev 0:e056ac8fecf8 3180 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2);
valeyev 0:e056ac8fecf8 3181 }
valeyev 0:e056ac8fecf8 3182
valeyev 0:e056ac8fecf8 3183 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 3184 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) {
valeyev 0:e056ac8fecf8 3185 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2);
valeyev 0:e056ac8fecf8 3186 }
valeyev 0:e056ac8fecf8 3187
valeyev 0:e056ac8fecf8 3188 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 3189 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) {
valeyev 0:e056ac8fecf8 3190 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2);
valeyev 0:e056ac8fecf8 3191 }
valeyev 0:e056ac8fecf8 3192
valeyev 0:e056ac8fecf8 3193 template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 3194 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) {
valeyev 0:e056ac8fecf8 3195 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2);
valeyev 0:e056ac8fecf8 3196 }
valeyev 0:e056ac8fecf8 3197
valeyev 0:e056ac8fecf8 3198 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
valeyev 0:e056ac8fecf8 3199 Event<void(A0, A1, A2)> EventQueue::event(mbed::Callback<R(B0, B1, B2, A0, A1, A2)> cb, C0 c0, C1 c1, C2 c2) {
valeyev 0:e056ac8fecf8 3200 return Event<void(A0, A1, A2)>(this, cb, c0, c1, c2);
valeyev 0:e056ac8fecf8 3201 }
valeyev 0:e056ac8fecf8 3202
valeyev 0:e056ac8fecf8 3203 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>
valeyev 0:e056ac8fecf8 3204 Event<void(A0, A1, A2)> EventQueue::event(R (*func)(B0, B1, B2, B3, A0, A1, A2), C0 c0, C1 c1, C2 c2, C3 c3) {
valeyev 0:e056ac8fecf8 3205 return Event<void(A0, A1, A2)>(this, func, c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 3206 }
valeyev 0:e056ac8fecf8 3207
valeyev 0:e056ac8fecf8 3208 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>
valeyev 0:e056ac8fecf8 3209 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) {
valeyev 0:e056ac8fecf8 3210 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 3211 }
valeyev 0:e056ac8fecf8 3212
valeyev 0:e056ac8fecf8 3213 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>
valeyev 0:e056ac8fecf8 3214 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) {
valeyev 0:e056ac8fecf8 3215 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 3216 }
valeyev 0:e056ac8fecf8 3217
valeyev 0:e056ac8fecf8 3218 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>
valeyev 0:e056ac8fecf8 3219 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) {
valeyev 0:e056ac8fecf8 3220 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 3221 }
valeyev 0:e056ac8fecf8 3222
valeyev 0:e056ac8fecf8 3223 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>
valeyev 0:e056ac8fecf8 3224 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) {
valeyev 0:e056ac8fecf8 3225 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 3226 }
valeyev 0:e056ac8fecf8 3227
valeyev 0:e056ac8fecf8 3228 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>
valeyev 0:e056ac8fecf8 3229 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) {
valeyev 0:e056ac8fecf8 3230 return Event<void(A0, A1, A2)>(this, cb, c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 3231 }
valeyev 0:e056ac8fecf8 3232
valeyev 0:e056ac8fecf8 3233 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>
valeyev 0:e056ac8fecf8 3234 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) {
valeyev 0:e056ac8fecf8 3235 return Event<void(A0, A1, A2)>(this, func, c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 3236 }
valeyev 0:e056ac8fecf8 3237
valeyev 0:e056ac8fecf8 3238 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>
valeyev 0:e056ac8fecf8 3239 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) {
valeyev 0:e056ac8fecf8 3240 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 3241 }
valeyev 0:e056ac8fecf8 3242
valeyev 0:e056ac8fecf8 3243 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>
valeyev 0:e056ac8fecf8 3244 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) {
valeyev 0:e056ac8fecf8 3245 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 3246 }
valeyev 0:e056ac8fecf8 3247
valeyev 0:e056ac8fecf8 3248 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>
valeyev 0:e056ac8fecf8 3249 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) {
valeyev 0:e056ac8fecf8 3250 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 3251 }
valeyev 0:e056ac8fecf8 3252
valeyev 0:e056ac8fecf8 3253 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>
valeyev 0:e056ac8fecf8 3254 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) {
valeyev 0:e056ac8fecf8 3255 return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 3256 }
valeyev 0:e056ac8fecf8 3257
valeyev 0:e056ac8fecf8 3258 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>
valeyev 0:e056ac8fecf8 3259 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) {
valeyev 0:e056ac8fecf8 3260 return Event<void(A0, A1, A2)>(this, cb, c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 3261 }
valeyev 0:e056ac8fecf8 3262
valeyev 0:e056ac8fecf8 3263 template <typename R, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 3264 Event<void(A0, A1, A2, A3)> EventQueue::event(R (*func)(A0, A1, A2, A3)) {
valeyev 0:e056ac8fecf8 3265 return Event<void(A0, A1, A2, A3)>(this, func);
valeyev 0:e056ac8fecf8 3266 }
valeyev 0:e056ac8fecf8 3267
valeyev 0:e056ac8fecf8 3268 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 3269 Event<void(A0, A1, A2, A3)> EventQueue::event(T *obj, R (T::*method)(A0, A1, A2, A3)) {
valeyev 0:e056ac8fecf8 3270 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 3271 }
valeyev 0:e056ac8fecf8 3272
valeyev 0:e056ac8fecf8 3273 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 3274 Event<void(A0, A1, A2, A3)> EventQueue::event(const T *obj, R (T::*method)(A0, A1, A2, A3) const) {
valeyev 0:e056ac8fecf8 3275 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 3276 }
valeyev 0:e056ac8fecf8 3277
valeyev 0:e056ac8fecf8 3278 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 3279 Event<void(A0, A1, A2, A3)> EventQueue::event(volatile T *obj, R (T::*method)(A0, A1, A2, A3) volatile) {
valeyev 0:e056ac8fecf8 3280 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 3281 }
valeyev 0:e056ac8fecf8 3282
valeyev 0:e056ac8fecf8 3283 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 3284 Event<void(A0, A1, A2, A3)> EventQueue::event(const volatile T *obj, R (T::*method)(A0, A1, A2, A3) const volatile) {
valeyev 0:e056ac8fecf8 3285 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 3286 }
valeyev 0:e056ac8fecf8 3287
valeyev 0:e056ac8fecf8 3288 template <typename R, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 3289 Event<void(A0, A1, A2, A3)> EventQueue::event(mbed::Callback<R(A0, A1, A2, A3)> cb) {
valeyev 0:e056ac8fecf8 3290 return Event<void(A0, A1, A2, A3)>(this, cb);
valeyev 0:e056ac8fecf8 3291 }
valeyev 0:e056ac8fecf8 3292
valeyev 0:e056ac8fecf8 3293 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 3294 Event<void(A0, A1, A2, A3)> EventQueue::event(R (*func)(B0, A0, A1, A2, A3), C0 c0) {
valeyev 0:e056ac8fecf8 3295 return Event<void(A0, A1, A2, A3)>(this, func, c0);
valeyev 0:e056ac8fecf8 3296 }
valeyev 0:e056ac8fecf8 3297
valeyev 0:e056ac8fecf8 3298 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 3299 Event<void(A0, A1, A2, A3)> EventQueue::event(T *obj, R (T::*method)(B0, A0, A1, A2, A3), C0 c0) {
valeyev 0:e056ac8fecf8 3300 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0);
valeyev 0:e056ac8fecf8 3301 }
valeyev 0:e056ac8fecf8 3302
valeyev 0:e056ac8fecf8 3303 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 3304 Event<void(A0, A1, A2, A3)> EventQueue::event(const T *obj, R (T::*method)(B0, A0, A1, A2, A3) const, C0 c0) {
valeyev 0:e056ac8fecf8 3305 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0);
valeyev 0:e056ac8fecf8 3306 }
valeyev 0:e056ac8fecf8 3307
valeyev 0:e056ac8fecf8 3308 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 3309 Event<void(A0, A1, A2, A3)> EventQueue::event(volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3) volatile, C0 c0) {
valeyev 0:e056ac8fecf8 3310 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0);
valeyev 0:e056ac8fecf8 3311 }
valeyev 0:e056ac8fecf8 3312
valeyev 0:e056ac8fecf8 3313 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 3314 Event<void(A0, A1, A2, A3)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3) const volatile, C0 c0) {
valeyev 0:e056ac8fecf8 3315 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0);
valeyev 0:e056ac8fecf8 3316 }
valeyev 0:e056ac8fecf8 3317
valeyev 0:e056ac8fecf8 3318 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 3319 Event<void(A0, A1, A2, A3)> EventQueue::event(mbed::Callback<R(B0, A0, A1, A2, A3)> cb, C0 c0) {
valeyev 0:e056ac8fecf8 3320 return Event<void(A0, A1, A2, A3)>(this, cb, c0);
valeyev 0:e056ac8fecf8 3321 }
valeyev 0:e056ac8fecf8 3322
valeyev 0:e056ac8fecf8 3323 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 3324 Event<void(A0, A1, A2, A3)> EventQueue::event(R (*func)(B0, B1, A0, A1, A2, A3), C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 3325 return Event<void(A0, A1, A2, A3)>(this, func, c0, c1);
valeyev 0:e056ac8fecf8 3326 }
valeyev 0:e056ac8fecf8 3327
valeyev 0:e056ac8fecf8 3328 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 3329 Event<void(A0, A1, A2, A3)> EventQueue::event(T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3), C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 3330 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1);
valeyev 0:e056ac8fecf8 3331 }
valeyev 0:e056ac8fecf8 3332
valeyev 0:e056ac8fecf8 3333 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 3334 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) {
valeyev 0:e056ac8fecf8 3335 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1);
valeyev 0:e056ac8fecf8 3336 }
valeyev 0:e056ac8fecf8 3337
valeyev 0:e056ac8fecf8 3338 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 3339 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) {
valeyev 0:e056ac8fecf8 3340 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1);
valeyev 0:e056ac8fecf8 3341 }
valeyev 0:e056ac8fecf8 3342
valeyev 0:e056ac8fecf8 3343 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 3344 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) {
valeyev 0:e056ac8fecf8 3345 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1);
valeyev 0:e056ac8fecf8 3346 }
valeyev 0:e056ac8fecf8 3347
valeyev 0:e056ac8fecf8 3348 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 3349 Event<void(A0, A1, A2, A3)> EventQueue::event(mbed::Callback<R(B0, B1, A0, A1, A2, A3)> cb, C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 3350 return Event<void(A0, A1, A2, A3)>(this, cb, c0, c1);
valeyev 0:e056ac8fecf8 3351 }
valeyev 0:e056ac8fecf8 3352
valeyev 0:e056ac8fecf8 3353 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 3354 Event<void(A0, A1, A2, A3)> EventQueue::event(R (*func)(B0, B1, B2, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2) {
valeyev 0:e056ac8fecf8 3355 return Event<void(A0, A1, A2, A3)>(this, func, c0, c1, c2);
valeyev 0:e056ac8fecf8 3356 }
valeyev 0:e056ac8fecf8 3357
valeyev 0:e056ac8fecf8 3358 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>
valeyev 0:e056ac8fecf8 3359 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) {
valeyev 0:e056ac8fecf8 3360 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2);
valeyev 0:e056ac8fecf8 3361 }
valeyev 0:e056ac8fecf8 3362
valeyev 0:e056ac8fecf8 3363 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>
valeyev 0:e056ac8fecf8 3364 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) {
valeyev 0:e056ac8fecf8 3365 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2);
valeyev 0:e056ac8fecf8 3366 }
valeyev 0:e056ac8fecf8 3367
valeyev 0:e056ac8fecf8 3368 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>
valeyev 0:e056ac8fecf8 3369 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) {
valeyev 0:e056ac8fecf8 3370 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2);
valeyev 0:e056ac8fecf8 3371 }
valeyev 0:e056ac8fecf8 3372
valeyev 0:e056ac8fecf8 3373 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>
valeyev 0:e056ac8fecf8 3374 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) {
valeyev 0:e056ac8fecf8 3375 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2);
valeyev 0:e056ac8fecf8 3376 }
valeyev 0:e056ac8fecf8 3377
valeyev 0:e056ac8fecf8 3378 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3>
valeyev 0:e056ac8fecf8 3379 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) {
valeyev 0:e056ac8fecf8 3380 return Event<void(A0, A1, A2, A3)>(this, cb, c0, c1, c2);
valeyev 0:e056ac8fecf8 3381 }
valeyev 0:e056ac8fecf8 3382
valeyev 0:e056ac8fecf8 3383 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>
valeyev 0:e056ac8fecf8 3384 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) {
valeyev 0:e056ac8fecf8 3385 return Event<void(A0, A1, A2, A3)>(this, func, c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 3386 }
valeyev 0:e056ac8fecf8 3387
valeyev 0:e056ac8fecf8 3388 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>
valeyev 0:e056ac8fecf8 3389 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) {
valeyev 0:e056ac8fecf8 3390 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 3391 }
valeyev 0:e056ac8fecf8 3392
valeyev 0:e056ac8fecf8 3393 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>
valeyev 0:e056ac8fecf8 3394 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) {
valeyev 0:e056ac8fecf8 3395 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 3396 }
valeyev 0:e056ac8fecf8 3397
valeyev 0:e056ac8fecf8 3398 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>
valeyev 0:e056ac8fecf8 3399 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) {
valeyev 0:e056ac8fecf8 3400 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 3401 }
valeyev 0:e056ac8fecf8 3402
valeyev 0:e056ac8fecf8 3403 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>
valeyev 0:e056ac8fecf8 3404 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) {
valeyev 0:e056ac8fecf8 3405 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 3406 }
valeyev 0:e056ac8fecf8 3407
valeyev 0:e056ac8fecf8 3408 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>
valeyev 0:e056ac8fecf8 3409 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) {
valeyev 0:e056ac8fecf8 3410 return Event<void(A0, A1, A2, A3)>(this, cb, c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 3411 }
valeyev 0:e056ac8fecf8 3412
valeyev 0:e056ac8fecf8 3413 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>
valeyev 0:e056ac8fecf8 3414 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) {
valeyev 0:e056ac8fecf8 3415 return Event<void(A0, A1, A2, A3)>(this, func, c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 3416 }
valeyev 0:e056ac8fecf8 3417
valeyev 0:e056ac8fecf8 3418 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>
valeyev 0:e056ac8fecf8 3419 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) {
valeyev 0:e056ac8fecf8 3420 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 3421 }
valeyev 0:e056ac8fecf8 3422
valeyev 0:e056ac8fecf8 3423 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>
valeyev 0:e056ac8fecf8 3424 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) {
valeyev 0:e056ac8fecf8 3425 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 3426 }
valeyev 0:e056ac8fecf8 3427
valeyev 0:e056ac8fecf8 3428 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>
valeyev 0:e056ac8fecf8 3429 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) {
valeyev 0:e056ac8fecf8 3430 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 3431 }
valeyev 0:e056ac8fecf8 3432
valeyev 0:e056ac8fecf8 3433 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>
valeyev 0:e056ac8fecf8 3434 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) {
valeyev 0:e056ac8fecf8 3435 return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 3436 }
valeyev 0:e056ac8fecf8 3437
valeyev 0:e056ac8fecf8 3438 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>
valeyev 0:e056ac8fecf8 3439 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) {
valeyev 0:e056ac8fecf8 3440 return Event<void(A0, A1, A2, A3)>(this, cb, c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 3441 }
valeyev 0:e056ac8fecf8 3442
valeyev 0:e056ac8fecf8 3443 template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 3444 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(R (*func)(A0, A1, A2, A3, A4)) {
valeyev 0:e056ac8fecf8 3445 return Event<void(A0, A1, A2, A3, A4)>(this, func);
valeyev 0:e056ac8fecf8 3446 }
valeyev 0:e056ac8fecf8 3447
valeyev 0:e056ac8fecf8 3448 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 3449 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(T *obj, R (T::*method)(A0, A1, A2, A3, A4)) {
valeyev 0:e056ac8fecf8 3450 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 3451 }
valeyev 0:e056ac8fecf8 3452
valeyev 0:e056ac8fecf8 3453 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 3454 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(const T *obj, R (T::*method)(A0, A1, A2, A3, A4) const) {
valeyev 0:e056ac8fecf8 3455 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 3456 }
valeyev 0:e056ac8fecf8 3457
valeyev 0:e056ac8fecf8 3458 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 3459 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) volatile) {
valeyev 0:e056ac8fecf8 3460 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 3461 }
valeyev 0:e056ac8fecf8 3462
valeyev 0:e056ac8fecf8 3463 template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 3464 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(const volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) const volatile) {
valeyev 0:e056ac8fecf8 3465 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method));
valeyev 0:e056ac8fecf8 3466 }
valeyev 0:e056ac8fecf8 3467
valeyev 0:e056ac8fecf8 3468 template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 3469 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(mbed::Callback<R(A0, A1, A2, A3, A4)> cb) {
valeyev 0:e056ac8fecf8 3470 return Event<void(A0, A1, A2, A3, A4)>(this, cb);
valeyev 0:e056ac8fecf8 3471 }
valeyev 0:e056ac8fecf8 3472
valeyev 0:e056ac8fecf8 3473 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 3474 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(R (*func)(B0, A0, A1, A2, A3, A4), C0 c0) {
valeyev 0:e056ac8fecf8 3475 return Event<void(A0, A1, A2, A3, A4)>(this, func, c0);
valeyev 0:e056ac8fecf8 3476 }
valeyev 0:e056ac8fecf8 3477
valeyev 0:e056ac8fecf8 3478 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 3479 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4), C0 c0) {
valeyev 0:e056ac8fecf8 3480 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0);
valeyev 0:e056ac8fecf8 3481 }
valeyev 0:e056ac8fecf8 3482
valeyev 0:e056ac8fecf8 3483 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 3484 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(const T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4) const, C0 c0) {
valeyev 0:e056ac8fecf8 3485 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0);
valeyev 0:e056ac8fecf8 3486 }
valeyev 0:e056ac8fecf8 3487
valeyev 0:e056ac8fecf8 3488 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 3489 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4) volatile, C0 c0) {
valeyev 0:e056ac8fecf8 3490 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0);
valeyev 0:e056ac8fecf8 3491 }
valeyev 0:e056ac8fecf8 3492
valeyev 0:e056ac8fecf8 3493 template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 3494 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) {
valeyev 0:e056ac8fecf8 3495 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0);
valeyev 0:e056ac8fecf8 3496 }
valeyev 0:e056ac8fecf8 3497
valeyev 0:e056ac8fecf8 3498 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 3499 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(mbed::Callback<R(B0, A0, A1, A2, A3, A4)> cb, C0 c0) {
valeyev 0:e056ac8fecf8 3500 return Event<void(A0, A1, A2, A3, A4)>(this, cb, c0);
valeyev 0:e056ac8fecf8 3501 }
valeyev 0:e056ac8fecf8 3502
valeyev 0:e056ac8fecf8 3503 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 3504 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(R (*func)(B0, B1, A0, A1, A2, A3, A4), C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 3505 return Event<void(A0, A1, A2, A3, A4)>(this, func, c0, c1);
valeyev 0:e056ac8fecf8 3506 }
valeyev 0:e056ac8fecf8 3507
valeyev 0:e056ac8fecf8 3508 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 3509 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) {
valeyev 0:e056ac8fecf8 3510 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1);
valeyev 0:e056ac8fecf8 3511 }
valeyev 0:e056ac8fecf8 3512
valeyev 0:e056ac8fecf8 3513 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 3514 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) {
valeyev 0:e056ac8fecf8 3515 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1);
valeyev 0:e056ac8fecf8 3516 }
valeyev 0:e056ac8fecf8 3517
valeyev 0:e056ac8fecf8 3518 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 3519 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) {
valeyev 0:e056ac8fecf8 3520 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1);
valeyev 0:e056ac8fecf8 3521 }
valeyev 0:e056ac8fecf8 3522
valeyev 0:e056ac8fecf8 3523 template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 3524 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) {
valeyev 0:e056ac8fecf8 3525 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1);
valeyev 0:e056ac8fecf8 3526 }
valeyev 0:e056ac8fecf8 3527
valeyev 0:e056ac8fecf8 3528 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
valeyev 0:e056ac8fecf8 3529 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(mbed::Callback<R(B0, B1, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1) {
valeyev 0:e056ac8fecf8 3530 return Event<void(A0, A1, A2, A3, A4)>(this, cb, c0, c1);
valeyev 0:e056ac8fecf8 3531 }
valeyev 0:e056ac8fecf8 3532
valeyev 0:e056ac8fecf8 3533 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>
valeyev 0:e056ac8fecf8 3534 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) {
valeyev 0:e056ac8fecf8 3535 return Event<void(A0, A1, A2, A3, A4)>(this, func, c0, c1, c2);
valeyev 0:e056ac8fecf8 3536 }
valeyev 0:e056ac8fecf8 3537
valeyev 0:e056ac8fecf8 3538 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>
valeyev 0:e056ac8fecf8 3539 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) {
valeyev 0:e056ac8fecf8 3540 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2);
valeyev 0:e056ac8fecf8 3541 }
valeyev 0:e056ac8fecf8 3542
valeyev 0:e056ac8fecf8 3543 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>
valeyev 0:e056ac8fecf8 3544 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) {
valeyev 0:e056ac8fecf8 3545 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2);
valeyev 0:e056ac8fecf8 3546 }
valeyev 0:e056ac8fecf8 3547
valeyev 0:e056ac8fecf8 3548 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>
valeyev 0:e056ac8fecf8 3549 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) {
valeyev 0:e056ac8fecf8 3550 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2);
valeyev 0:e056ac8fecf8 3551 }
valeyev 0:e056ac8fecf8 3552
valeyev 0:e056ac8fecf8 3553 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>
valeyev 0:e056ac8fecf8 3554 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) {
valeyev 0:e056ac8fecf8 3555 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2);
valeyev 0:e056ac8fecf8 3556 }
valeyev 0:e056ac8fecf8 3557
valeyev 0:e056ac8fecf8 3558 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>
valeyev 0:e056ac8fecf8 3559 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) {
valeyev 0:e056ac8fecf8 3560 return Event<void(A0, A1, A2, A3, A4)>(this, cb, c0, c1, c2);
valeyev 0:e056ac8fecf8 3561 }
valeyev 0:e056ac8fecf8 3562
valeyev 0:e056ac8fecf8 3563 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>
valeyev 0:e056ac8fecf8 3564 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) {
valeyev 0:e056ac8fecf8 3565 return Event<void(A0, A1, A2, A3, A4)>(this, func, c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 3566 }
valeyev 0:e056ac8fecf8 3567
valeyev 0:e056ac8fecf8 3568 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>
valeyev 0:e056ac8fecf8 3569 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) {
valeyev 0:e056ac8fecf8 3570 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 3571 }
valeyev 0:e056ac8fecf8 3572
valeyev 0:e056ac8fecf8 3573 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>
valeyev 0:e056ac8fecf8 3574 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) {
valeyev 0:e056ac8fecf8 3575 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 3576 }
valeyev 0:e056ac8fecf8 3577
valeyev 0:e056ac8fecf8 3578 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>
valeyev 0:e056ac8fecf8 3579 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) {
valeyev 0:e056ac8fecf8 3580 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 3581 }
valeyev 0:e056ac8fecf8 3582
valeyev 0:e056ac8fecf8 3583 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>
valeyev 0:e056ac8fecf8 3584 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) {
valeyev 0:e056ac8fecf8 3585 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 3586 }
valeyev 0:e056ac8fecf8 3587
valeyev 0:e056ac8fecf8 3588 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>
valeyev 0:e056ac8fecf8 3589 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) {
valeyev 0:e056ac8fecf8 3590 return Event<void(A0, A1, A2, A3, A4)>(this, cb, c0, c1, c2, c3);
valeyev 0:e056ac8fecf8 3591 }
valeyev 0:e056ac8fecf8 3592
valeyev 0:e056ac8fecf8 3593 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>
valeyev 0:e056ac8fecf8 3594 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) {
valeyev 0:e056ac8fecf8 3595 return Event<void(A0, A1, A2, A3, A4)>(this, func, c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 3596 }
valeyev 0:e056ac8fecf8 3597
valeyev 0:e056ac8fecf8 3598 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>
valeyev 0:e056ac8fecf8 3599 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) {
valeyev 0:e056ac8fecf8 3600 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 3601 }
valeyev 0:e056ac8fecf8 3602
valeyev 0:e056ac8fecf8 3603 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>
valeyev 0:e056ac8fecf8 3604 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) {
valeyev 0:e056ac8fecf8 3605 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 3606 }
valeyev 0:e056ac8fecf8 3607
valeyev 0:e056ac8fecf8 3608 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>
valeyev 0:e056ac8fecf8 3609 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) {
valeyev 0:e056ac8fecf8 3610 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 3611 }
valeyev 0:e056ac8fecf8 3612
valeyev 0:e056ac8fecf8 3613 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>
valeyev 0:e056ac8fecf8 3614 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) {
valeyev 0:e056ac8fecf8 3615 return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 3616 }
valeyev 0:e056ac8fecf8 3617
valeyev 0:e056ac8fecf8 3618 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>
valeyev 0:e056ac8fecf8 3619 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) {
valeyev 0:e056ac8fecf8 3620 return Event<void(A0, A1, A2, A3, A4)>(this, cb, c0, c1, c2, c3, c4);
valeyev 0:e056ac8fecf8 3621 }
valeyev 0:e056ac8fecf8 3622
valeyev 0:e056ac8fecf8 3623 }
valeyev 0:e056ac8fecf8 3624
valeyev 0:e056ac8fecf8 3625 #endif
valeyev 0:e056ac8fecf8 3626
valeyev 0:e056ac8fecf8 3627 /** @}*/