dpl_eventq.h

Go to the documentation of this file.

/*
 * Copyright (C) 2020 Inria
 *
 * This file is subject to the terms and conditions of the GNU Lesser
 * General Public License v2.1. See the file LICENSE in the top level
 * directory for more details.
 */
 
#ifndef DPL_DPL_EVENTQ_H
#define DPL_DPL_EVENTQ_H
 
#include <dpl/dpl_types.h>
 
#include "uwb_core.h"
#include "event/callback.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct dpl_event
{
    event_callback_t e; 
    void *arg;          
};
 
struct dpl_eventq
{
    event_queue_t q;    
};
 
typedef void dpl_event_fn(struct dpl_event *ev);
 
static inline void dpl_event_init(struct dpl_event *ev, dpl_event_fn * fn,
                                 void *arg)
{
    /*
     * Need to clear list_node manually since init function below does not do
     * this.
     */
    ev->e.super.list_node.next = NULL;
    event_callback_init(&ev->e, (void(*)(void *))fn, ev);
    ev->arg = arg;
}
 
static inline bool dpl_event_is_queued(struct dpl_event *ev)
{
    return (ev->e.super.list_node.next != NULL);
}
 
static inline void *dpl_event_get_arg(struct dpl_event *ev)
{
    return ev->arg;
}
 
static inline void dpl_event_set_arg(struct dpl_event *ev, void *arg)
{
    ev->arg = arg;
}
 
static inline void dpl_event_run(struct dpl_event *ev)
{
    ev->e.super.handler(&ev->e.super);
}
 
static inline void dpl_eventq_init(struct dpl_eventq *evq)
{
    event_queue_init_detached(&evq->q);
}
 
static inline int dpl_eventq_inited(struct dpl_eventq *evq)
{
    return evq->q.waiter != NULL;
}
 
static inline void dpl_eventq_deinit(struct dpl_eventq *evq)
{
    (void) evq;
    /* Can't deinit an eventq in RIOT */
}
 
static inline struct dpl_event * dpl_eventq_get(struct dpl_eventq *evq)
{
    if (evq->q.waiter == NULL) {
        event_queue_claim(&evq->q);
    }
 
    return (struct dpl_event *) event_wait(&evq->q);
}
 
static inline struct dpl_event * dpl_eventq_get_no_wait(struct dpl_eventq *evq)
{
    if (evq->q.waiter == NULL) {
        event_queue_claim(&evq->q);
    }
 
    return (struct dpl_event *) event_get(&evq->q);
}
 
static inline void dpl_eventq_put(struct dpl_eventq *evq, struct dpl_event *ev)
{
    event_post(&evq->q, &ev->e.super);
}
 
static inline void dpl_eventq_remove(struct dpl_eventq *evq, struct dpl_event *ev)
{
    event_cancel(&evq->q, &ev->e.super);
}
 
static inline void dpl_eventq_run(struct dpl_eventq *evq)
{
    struct dpl_event *ev = dpl_eventq_get(evq);
    dpl_event_run(ev);
}
 
static inline bool dpl_eventq_is_empty(struct dpl_eventq *evq)
{
    return clist_count(&(evq->q.event_list)) == 0;
}
 
static inline struct dpl_eventq * dpl_eventq_dflt_get(void)
{
    return (struct dpl_eventq*) uwb_core_get_eventq();
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* DPL_DPL_EVENTQ_H */