Event.h

/*
 * Copyright (c) 2016-2019 ARM Limited
 * SPDX-License-Identifier: Apache-2.0
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#ifndef EVENT_H
#define EVENT_H
 
#include <utility>
#include "events/EventQueue.h"
#include "platform/mbed_assert.h"
#include "platform/mbed_error.h"
 
namespace events {
/** \defgroup events-public-api Events
 * \ingroup mbed-os-public
 * @{
 */
 
static constexpr std::chrono::duration<int, std::milli> non_periodic{-1};
 
/** Event
 *
 *  Representation of an event for fine-grain dispatch control
 */
template <typename F>
class Event;
 
/**
 * \defgroup events_Event Event classes
 * @{
 */
 
/** Event
 *
 *  Representation of an event for fine-grain dispatch control
 */
template <typename... ArgTs>
class Event<void(ArgTs...)> {
public:
    using duration = std::chrono::duration<int, std::milli>;
 
    /** Create an event
     *
     *  Constructs an event bound to the specified event queue. The specified
     *  callback acts as the target for the event and is executed in the
     *  context of the event queue's dispatch loop once posted.
     *
     *  @param q        Event queue to dispatch on
     *  @param f        Function to execute when the event is dispatched
     */
    template <typename F>
    Event(EventQueue *q, F f)
    {
        _event = static_cast<struct event *>(
                     equeue_alloc(&q->_equeue, sizeof(struct event) + sizeof(F)));
 
        if (_event) {
            _event->equeue = &q->_equeue;
            _event->id = 0;
            _event->delay = duration(0);
            _event->period = non_periodic;
 
            _event->post = &Event::event_post<F>;
            _event->dtor = &Event::event_dtor<F>;
 
            new (_event + 1) F(std::move(f));
 
            _event->ref = 1;
        }
    }
 
    /** Copy constructor for events
     */
    Event(const Event &e)
    {
        _event = 0;
        if (e._event) {
            _event = e._event;
            _event->ref += 1;
        }
    }
 
    /** Assignment operator for events
     */
    Event &operator=(const Event &that)
    {
        if (this != &that) {
            this->~Event();
            new (this) Event(that);
        }
 
        return *this;
    }
 
    /** Destructor for events
     */
    ~Event()
    {
        if (_event) {
            _event->ref -= 1;
            if (_event->ref == 0) {
                _event->dtor(_event);
                equeue_dealloc(_event->equeue, _event);
            }
        }
    }
 
    /** Configure the delay of an event
     *
     *  @param d    Delay (in milliseconds) before dispatching the event, expressed as a Chrono duration.
     *              E.g. delay(50ms)
     */
    void delay(duration d)
    {
        if (_event) {
            _event->delay = d;
        }
    }
 
    /** Configure the delay of an event
     *  @deprecated Pass a chrono duration, not an integer millisecond count. For example use `5s` rather than `5000`.
     *
     *  @param d    Millisecond delay before dispatching the event
     */
    MBED_DEPRECATED_SINCE("mbed-os-6.0.0", "Pass a chrono duration, not an integer millisecond count. For example use `5s` rather than `5000`.")
    void delay(int d)
    {
        delay(duration(d));
    }
 
    /** Configure the period of an event
     *
     *  @param p   Period (in milliseconds) for repeatedly dispatching an event, expressed as a Chrono
     *             duration. Period must be either non_periodic or > 0ms. If an invalid period is supplied
     *             then a default non_periodic value is used.
     *             E.g. period(200ms)
     */
    void period(duration p)
    {
        if (_event) {
            if (p > duration(0)) {
                _event->period = p;
 
            } else {
                if (p != non_periodic) {
                    MBED_WARNING(MBED_ERROR_INVALID_ARGUMENT,
                                 "Invalid period specified, defaulting to non_periodic.");
                }
                _event->period = non_periodic;
            }
        }
    }
 
    /** Configure the period of an event
     *  @deprecated Pass a chrono duration, not an integer millisecond count. For example use `5s` rather than `5000`.
     *
     *  @param p   Millisecond period for repeatedly dispatching an event
     */
    MBED_DEPRECATED_SINCE("mbed-os-6.0.0", "Pass a chrono duration, not an integer millisecond count. For example use `5s` rather than `5000`.")
    void period(int p)
    {
        period(duration(p));
    }
 
    /** Posts an event onto the underlying event queue
     *
     *  The event is posted to the underlying queue and is executed in the
     *  context of the event queue's dispatch loop.
     *
     *  The post function is IRQ safe and can act as a mechanism for moving
     *  events out of IRQ contexts.
     *
     *  @param args     Arguments to pass to the event
     *  @return         A unique id that represents the posted event and can
     *                  be passed to EventQueue::cancel, or an id of 0 if
     *                  there is not enough memory to allocate the event.
     */
    int post(ArgTs... args) const
    {
        if (!_event) {
            return 0;
        }
 
        _event->id = _event->post(_event, args...);
        return _event->id;
    }
 
    /** Posts an event onto the underlying event queue, returning void
     *
     *  @param args     Arguments to pass to the event
     */
    void call(ArgTs... args) const
    {
        MBED_UNUSED int id = post(args...);
        MBED_ASSERT(id);
    }
 
    /** Posts an event onto the underlying event queue, returning void
     *
     *  @param args     Arguments to pass to the event
     */
    void operator()(ArgTs... args) const
    {
        return call(args...);
    }
 
    /** Static thunk for passing as C-style function
     *
     *  @param func     Event to call passed as a void pointer
     *  @param args     Arguments to pass to the event
     */
    static void thunk(void *func, ArgTs... args)
    {
        return static_cast<Event *>(func)->call(args...);
    }
 
    /** Cancels the most recently posted event
     *
     *  Attempts to cancel the most recently posted event. It is not safe to call
     *  cancel after an event has already been dispatched.
     *
     *  The cancel function is IRQ safe.
     *
     *  If called while the event queue's dispatch loop is active, the cancel
     *  function does not guarantee that the event will not execute after it
     *  returns, as the event may have already begun executing.
     */
    void cancel() const
    {
        if (_event) {
            equeue_cancel(_event->equeue, _event->id);
        }
    }
 
private:
    struct event {
        unsigned ref;
        equeue_t *equeue;
        int id;
 
        duration delay;
        duration period;
 
        int (*post)(struct event *, ArgTs... args);
        void (*dtor)(struct event *);
 
        // F follows
    } *_event;
 
    // Event attributes
    template <typename F>
    static int event_post(struct event *e, ArgTs... args)
    {
        typedef EventQueue::context<F, ArgTs...> C;
        void *p = equeue_alloc(e->equeue, sizeof(C));
        if (!p) {
            return 0;
        }
 
        new (p) C(*(F *)(e + 1), args...);
        equeue_event_delay(p, e->delay.count());
        equeue_event_period(p, e->period.count());
        equeue_event_dtor(p, &EventQueue::function_dtor<C>);
        return equeue_post(e->equeue, &EventQueue::function_call<C>, p);
    }
 
    template <typename F>
    static void event_dtor(struct event *e)
    {
        ((F *)(e + 1))->~F();
    }
 
public:
    /** Create an event
     *  @param q                Event queue to dispatch on
     *  @param f                Function to execute when the event is dispatched
     *  @param context_args     Arguments to bind to the callback, these arguments are
     *                          allocated on an IRQ-safe allocator from the event queue's
     *                          memory pool. Must be type-compatible with bound_args, the
     *                          arguments to the underlying callback.
     */
    template <typename F, typename... ContextArgTs>
    Event(EventQueue *q, F f, ContextArgTs... context_args) :
        Event(q, EventQueue::context<F, ContextArgTs...>(f, context_args...)) { }
 
    /** Create an event
     *  @see Event::Event
     */
    template <typename T, typename R, typename B0>
    Event(EventQueue *q, T *obj, R(T::*method)(B0, ArgTs...), B0 b0) :
        Event(q, mbed::callback(obj, method), b0) { }
 
    /** Create an event
     *  @see Event::Event
     */
    template <typename T, typename R, typename B0>
    Event(EventQueue *q, const T *obj, R(T::*method)(B0, ArgTs...) const, B0 b0) :
        Event(q, mbed::callback(obj, method), b0) { }
 
    /** Create an event
     *  @see Event::Event
     */
    template <typename T, typename R, typename B0>
    Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, ArgTs...) volatile, B0 b0) :
        Event(q, mbed::callback(obj, method), b0) { }
 
    /** Create an event
     *  @see Event::Event
     */
    template <typename T, typename R, typename B0>
    Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, ArgTs...) const volatile, B0 b0) :
        Event(q, mbed::callback(obj, method), b0) { }
 
    /** Create an event
     *  @see Event::Event
     */
    template <typename T, typename R, typename B0, typename B1>
    Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, ArgTs...), B0 b0, B1 b1) :
        Event(q, mbed::callback(obj, method), b0, b1) { }
 
    /** Create an event
     *  @see Event::Event
     */
    template <typename T, typename R, typename B0, typename B1>
    Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, ArgTs...) const, B0 b0, B1 b1) :
        Event(q, mbed::callback(obj, method), b0, b1) { }
 
    /** Create an event
     *  @see Event::Event
     */
    template <typename T, typename R, typename B0, typename B1>
    Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, ArgTs...) volatile, B0 b0, B1 b1) :
        Event(q, mbed::callback(obj, method), b0, b1) { }
 
    /** Create an event
     *  @see Event::Event
     */
    template <typename T, typename R, typename B0, typename B1>
    Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, ArgTs...) const volatile, B0 b0, B1 b1) :
        Event(q, mbed::callback(obj, method), b0, b1) { }
 
    /** Create an event
     *  @see Event::Event
     */
    template <typename T, typename R, typename B0, typename B1, typename B2>
    Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, ArgTs...), B0 b0, B1 b1, B2 b2) :
        Event(q, mbed::callback(obj, method), b0, b1, b2) { }
 
    /** Create an event
     *  @see Event::Event
     */
    template <typename T, typename R, typename B0, typename B1, typename B2>
    Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, ArgTs...) const, B0 b0, B1 b1, B2 b2) :
        Event(q, mbed::callback(obj, method), b0, b1, b2) { }
 
    /** Create an event
     *  @see Event::Event
     */
    template <typename T, typename R, typename B0, typename B1, typename B2>
    Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, ArgTs...) volatile, B0 b0, B1 b1, B2 b2) :
        Event(q, mbed::callback(obj, method), b0, b1, b2) { }
 
    /** Create an event
     *  @see Event::Event
     */
    template <typename T, typename R, typename B0, typename B1, typename B2>
    Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, ArgTs...) const volatile, B0 b0, B1 b1, B2 b2) :
        Event(q, mbed::callback(obj, method), b0, b1, b2) { }
 
    /** Create an event
     *  @see Event::Event
     */
    template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
    Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, ArgTs...), B0 b0, B1 b1, B2 b2, B3 b3) :
        Event(q, mbed::callback(obj, method), b0, b1, b2, b3) { }
 
    /** Create an event
     *  @see Event::Event
     */
    template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
    Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, ArgTs...) const, B0 b0, B1 b1, B2 b2, B3 b3) :
        Event(q, mbed::callback(obj, method), b0, b1, b2, b3) { }
 
    /** Create an event
     *  @see Event::Event
     */
    template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
    Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, ArgTs...) volatile, B0 b0, B1 b1, B2 b2, B3 b3) :
        Event(q, mbed::callback(obj, method), b0, b1, b2, b3) { }
 
    /** Create an event
     *  @see Event::Event
     */
    template <typename T, typename R, typename B0, typename B1, typename B2, typename B3>
    Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, ArgTs...) const volatile, B0 b0, B1 b1, B2 b2, B3 b3) :
        Event(q, mbed::callback(obj, method), b0, b1, b2, b3) { }
 
    /** Create an event
     *  @see Event::Event
     */
    template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
    Event(EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, B4, ArgTs...), B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) :
        Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4) { }
 
    /** Create an event
     *  @see Event::Event
     */
    template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
    Event(EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, B4, ArgTs...) const, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) :
        Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4) { }
 
    /** Create an event
     *  @see Event::Event
     */
    template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
    Event(EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, ArgTs...) volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) :
        Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4) { }
 
    /** Create an event
     *  @see Event::Event
     */
    template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4>
    Event(EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, ArgTs...) const volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) :
        Event(q, mbed::callback(obj, method), b0, b1, b2, b3, b4) { }
};
 
/** @}*/
 
#if !defined(DOXYGEN_ONLY)
 
// Convenience functions declared here to avoid cyclic
// dependency between Event and EventQueue
template <typename R, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(R(*func)(ArgTs...))
{
    return Event<void(ArgTs...)>(this, func);
}
 
template <typename T, typename R, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(T *obj, R(T::*method)(ArgTs...))
{
    return Event<void(ArgTs...)>(this, mbed::callback(obj, method));
}
 
template <typename T, typename R, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(const T *obj, R(T::*method)(ArgTs...) const)
{
    return Event<void(ArgTs...)>(this, mbed::callback(obj, method));
}
 
template <typename T, typename R, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(volatile T *obj, R(T::*method)(ArgTs...) volatile)
{
    return Event<void(ArgTs...)>(this, mbed::callback(obj, method));
}
 
template <typename T, typename R, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(const volatile T *obj, R(T::*method)(ArgTs...) const volatile)
{
    return Event<void(ArgTs...)>(this, mbed::callback(obj, method));
}
 
template <typename R, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(mbed::Callback<R(ArgTs...)> cb)
{
    return Event<void(ArgTs...)>(this, cb);
}
 
template <typename R, typename B0, typename C0, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(R(*func)(B0, ArgTs...), C0 c0)
{
    return Event<void(ArgTs...)>(this, func, c0);
}
 
template <typename T, typename R, typename B0, typename C0, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(T *obj, R(T::*method)(B0, ArgTs...), C0 c0)
{
    return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0);
}
 
template <typename T, typename R, typename B0, typename C0, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(const T *obj, R(T::*method)(B0, ArgTs...) const, C0 c0)
{
    return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0);
}
 
template <typename T, typename R, typename B0, typename C0, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(volatile T *obj, R(T::*method)(B0, ArgTs...) volatile, C0 c0)
{
    return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0);
}
 
template <typename T, typename R, typename B0, typename C0, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(const volatile T *obj, R(T::*method)(B0, ArgTs...) const volatile, C0 c0)
{
    return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0);
}
 
template <typename R, typename B0, typename C0, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(mbed::Callback<R(B0, ArgTs...)> cb, C0 c0)
{
    return Event<void(ArgTs...)>(this, cb, c0);
}
 
template <typename R, typename B0, typename B1, typename C0, typename C1, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(R(*func)(B0, B1, ArgTs...), C0 c0, C1 c1)
{
    return Event<void(ArgTs...)>(this, func, c0, c1);
}
 
template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(T *obj, R(T::*method)(B0, B1, ArgTs...), C0 c0, C1 c1)
{
    return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1);
}
 
template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(const T *obj, R(T::*method)(B0, B1, ArgTs...) const, C0 c0, C1 c1)
{
    return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1);
}
 
template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(volatile T *obj, R(T::*method)(B0, B1, ArgTs...) volatile, C0 c0, C1 c1)
{
    return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1);
}
 
template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(const volatile T *obj, R(T::*method)(B0, B1, ArgTs...) const volatile, C0 c0, C1 c1)
{
    return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1);
}
 
template <typename R, typename B0, typename B1, typename C0, typename C1, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(mbed::Callback<R(B0, B1, ArgTs...)> cb, C0 c0, C1 c1)
{
    return Event<void(ArgTs...)>(this, cb, c0, c1);
}
 
template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(R(*func)(B0, B1, B2, ArgTs...), C0 c0, C1 c1, C2 c2)
{
    return Event<void(ArgTs...)>(this, func, c0, c1, c2);
}
 
template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(T *obj, R(T::*method)(B0, B1, B2, ArgTs...), C0 c0, C1 c1, C2 c2)
{
    return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1, c2);
}
 
template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(const T *obj, R(T::*method)(B0, B1, B2, ArgTs...) const, C0 c0, C1 c1, C2 c2)
{
    return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1, c2);
}
 
template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(volatile T *obj, R(T::*method)(B0, B1, B2, ArgTs...) volatile, C0 c0, C1 c1, C2 c2)
{
    return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1, c2);
}
 
template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(const volatile T *obj, R(T::*method)(B0, B1, B2, ArgTs...) const volatile, C0 c0, C1 c1, C2 c2)
{
    return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1, c2);
}
 
template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(mbed::Callback<R(B0, B1, B2, ArgTs...)> cb, C0 c0, C1 c1, C2 c2)
{
    return Event<void(ArgTs...)>(this, cb, c0, c1, c2);
}
 
template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(R(*func)(B0, B1, B2, B3, ArgTs...), C0 c0, C1 c1, C2 c2, C3 c3)
{
    return Event<void(ArgTs...)>(this, func, c0, c1, c2, c3);
}
 
template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(T *obj, R(T::*method)(B0, B1, B2, B3, ArgTs...), C0 c0, C1 c1, C2 c2, C3 c3)
{
    return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
}
 
template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(const T *obj, R(T::*method)(B0, B1, B2, B3, ArgTs...) const, C0 c0, C1 c1, C2 c2, C3 c3)
{
    return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
}
 
template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(volatile T *obj, R(T::*method)(B0, B1, B2, B3, ArgTs...) volatile, C0 c0, C1 c1, C2 c2, C3 c3)
{
    return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
}
 
template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(const volatile T *obj, R(T::*method)(B0, B1, B2, B3, ArgTs...) const volatile, C0 c0, C1 c1, C2 c2, C3 c3)
{
    return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
}
 
template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, ArgTs...)> cb, C0 c0, C1 c1, C2 c2, C3 c3)
{
    return Event<void(ArgTs...)>(this, cb, c0, c1, c2, c3);
}
 
template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(R(*func)(B0, B1, B2, B3, B4, ArgTs...), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
{
    return Event<void(ArgTs...)>(this, func, c0, c1, c2, c3, c4);
}
 
template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(T *obj, R(T::*method)(B0, B1, B2, B3, B4, ArgTs...), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
{
    return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
}
 
template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(const T *obj, R(T::*method)(B0, B1, B2, B3, B4, ArgTs...) const, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
{
    return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
}
 
template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, ArgTs...) volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
{
    return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
}
 
template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(const volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, ArgTs...) const volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
{
    return Event<void(ArgTs...)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
}
 
template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename... ArgTs>
Event<void(ArgTs...)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, B4, ArgTs...)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4)
{
    return Event<void(ArgTs...)>(this, cb, c0, c1, c2, c3, c4);
}
 
#endif // !defined(DOXYGEN_ONLY)
 
/** @}*/
}
#endif