ringq.h

Go to the documentation of this file.

/*
 * Copyright (c) 2025 Måns Ansgariusson <mansgariusson@gmail.com>
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_SYS_RINGQ_H_
#define ZEPHYR_INCLUDE_SYS_RINGQ_H_
 
#include <zephyr/sys/ring_buffer.h>
 
#ifdef __cplusplus
extern "C" {
#endif


struct sys_ringq {
        struct ring_buf rb;
        ring_buf_idx_t item_size;
};

 
#define SYS_RINGQ_INIT(buf, item_sz, item_capacity)                     \
{                                                                       \
        .rb = RING_BUF_INIT(buf, item_sz * item_capacity),              \
        .item_size = item_sz,                                           \
}


#define SYS_RINGQ_DEFINE(name, item_size, item_capacity)                                        \
        static uint8_t __noinit CONCAT(_ringq_data_, name)[item_size * item_capacity];          \
        struct sys_ringq name = SYS_RINGQ_INIT(CONCAT(_ringq_data_, name), item_size, item_capacity)

static inline void sys_ringq_init(struct sys_ringq *ringq, uint8_t *data, size_t data_size,
                                size_t item_size)
{
        __ASSERT(data != NULL, "Data buffer should not be NULL");
        __ASSERT(item_size > 0, "item_size should be greater than 0");
 
        /* Adjust data size to be a multiple of item size */
        data_size = (data_size / item_size) * item_size;
        __ASSERT(data_size > 0, "data_size should be a multiple of item_size and greater than 0");
 
        ring_buf_init(&ringq->rb, data_size, data);
        ringq->item_size = item_size;
}

static inline void sys_ringq_reset(struct sys_ringq *ringq)
{
        ring_buf_reset(&ringq->rb);
}

static inline bool sys_ringq_empty(const struct sys_ringq *ringq)
{
        return ring_buf_is_empty(&ringq->rb);
}

static inline bool sys_ringq_full(const struct sys_ringq *ringq)
{
        return ring_buf_space_get(&ringq->rb) == 0;
}

static inline size_t sys_ringq_space(const struct sys_ringq *ringq)
{
        return ring_buf_space_get(&ringq->rb) / ringq->item_size;
}

static inline size_t sys_ringq_capacity(const struct sys_ringq *ringq)
{
        return ring_buf_capacity_get(&ringq->rb) / ringq->item_size;
}

static inline size_t sys_ringq_size(const struct sys_ringq *ringq)
{
        return ring_buf_size_get(&ringq->rb) / ringq->item_size;
}

static inline int sys_ringq_put(struct sys_ringq *ringq, const void *element)
{
        return ring_buf_put(&ringq->rb, (const uint8_t *)element, ringq->item_size) == 0 ?
                -ENOSPC : 0;
}

static inline int sys_ringq_get(struct sys_ringq *ringq, void *element)
{
        return ring_buf_get(&ringq->rb, (uint8_t *)element, ringq->item_size) == 0 ? -ENODATA : 0;
}

static inline int sys_ringq_peek(struct sys_ringq *ringq, void *data)
{
        return ring_buf_peek(&ringq->rb, (uint8_t *)data, ringq->item_size) == 0 ? -ENODATA : 0;
}

 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_SYS_RINGQ_H_ */