Add fifo and lifo collections

include/zenoh-pico/collections/fifo.h

@@ -0,0 +1,63 @@
+//
+// Copyright (c) 2022 ZettaScale Technology
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
+// which is available at https://www.apache.org/licenses/LICENSE-2.0.
+//
+// SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
+//
+// Contributors:
+//   ZettaScale Zenoh Team, <[email protected]>
+//
+#ifndef ZENOH_PICO_COLLECTIONS_FIFO_H
+#define ZENOH_PICO_COLLECTIONS_FIFO_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "zenoh-pico/collections/element.h"
+#include "zenoh-pico/collections/ring.h"
+
+/*-------- Fifo Buffer --------*/
+typedef struct {
+    _z_ring_t _ring;
+} _z_fifo_t;
+
+int8_t _z_fifo_init(_z_fifo_t *fifo, size_t capacity);
+_z_fifo_t _z_fifo_make(size_t capacity);
+
+size_t _z_fifo_capacity(const _z_fifo_t *r);
+size_t _z_fifo_len(const _z_fifo_t *r);
+_Bool _z_fifo_is_empty(const _z_fifo_t *r);
+_Bool _z_fifo_is_full(const _z_fifo_t *r);
+
+void *_z_fifo_push(_z_fifo_t *r, void *e);
+void _z_fifo_push_drop(_z_fifo_t *r, void *e, z_element_free_f f);
+void *_z_fifo_pull(_z_fifo_t *r);
+
+_z_fifo_t *_z_fifo_clone(const _z_fifo_t *xs, z_element_clone_f d_f);
+
+void _z_fifo_clear(_z_fifo_t *v, z_element_free_f f);
+void _z_fifo_free(_z_fifo_t **xs, z_element_free_f f_f);
+
+#define _Z_FIFO_DEFINE(name, type)                                                                         \
+    typedef _z_fifo_t name##_fifo_t;                                                                       \
+    static inline int8_t name##_fifo_init(name##_fifo_t *fifo, size_t capacity) {                          \
+        return _z_fifo_init(fifo, capacity);                                                               \
+    }                                                                                                      \
+    static inline name##_fifo_t name##_fifo_make(size_t capacity) { return _z_fifo_make(capacity); }       \
+    static inline size_t name##_fifo_capacity(const name##_fifo_t *r) { return _z_fifo_capacity(r); }      \
+    static inline size_t name##_fifo_len(const name##_fifo_t *r) { return _z_fifo_len(r); }                \
+    static inline _Bool name##_fifo_is_empty(const name##_fifo_t *r) { return _z_fifo_is_empty(r); }       \
+    static inline _Bool name##_fifo_is_full(const name##_fifo_t *r) { return _z_fifo_is_full(r); }         \
+    static inline type *name##_fifo_push(name##_fifo_t *r, type *e) { return _z_fifo_push(r, (void *)e); } \
+    static inline void name##_fifo_push_drop(name##_fifo_t *r, type *e) {                                  \
+        return _z_fifo_push_drop(r, (void *)e, name##_elem_free);                                          \
+    }                                                                                                      \
+    static inline type *name##_fifo_pull(name##_fifo_t *r) { return (type *)_z_fifo_pull(r); }             \
+    static inline void name##_fifo_clear(name##_fifo_t *r) { _z_fifo_clear(r, name##_elem_free); }         \
+    static inline void name##_fifo_free(name##_fifo_t **r) { _z_fifo_free(r, name##_elem_free); }
+
+#endif /* ZENOH_PICO_COLLECTIONS_FIFO_H */

include/zenoh-pico/collections/lifo.h

@@ -0,0 +1,64 @@
+//
+// Copyright (c) 2022 ZettaScale Technology
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
+// which is available at https://www.apache.org/licenses/LICENSE-2.0.
+//
+// SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
+//
+// Contributors:
+//   ZettaScale Zenoh Team, <[email protected]>
+//
+#ifndef ZENOH_PICO_COLLECTIONS_LIFO_H
+#define ZENOH_PICO_COLLECTIONS_LIFO_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "zenoh-pico/collections/element.h"
+
+/*-------- Ring Buffer --------*/
+typedef struct {
+    void **_val;
+    size_t _capacity;
+    size_t _len;
+} _z_lifo_t;
+
+int8_t _z_lifo_init(_z_lifo_t *lifo, size_t capacity);
+_z_lifo_t _z_lifo_make(size_t capacity);
+
+size_t _z_lifo_capacity(const _z_lifo_t *r);
+size_t _z_lifo_len(const _z_lifo_t *r);
+_Bool _z_lifo_is_empty(const _z_lifo_t *r);
+_Bool _z_lifo_is_full(const _z_lifo_t *r);
+
+void *_z_lifo_push(_z_lifo_t *r, void *e);
+void _z_lifo_push_drop(_z_lifo_t *r, void *e, z_element_free_f f);
+void *_z_lifo_pull(_z_lifo_t *r);
+
+_z_lifo_t *_z_lifo_clone(const _z_lifo_t *xs, z_element_clone_f d_f);
+
+void _z_lifo_clear(_z_lifo_t *v, z_element_free_f f);
+void _z_lifo_free(_z_lifo_t **xs, z_element_free_f f_f);
+
+#define _Z_LIFO_DEFINE(name, type)                                                                         \
+    typedef _z_lifo_t name##_lifo_t;                                                                       \
+    static inline int8_t name##_lifo_init(name##_lifo_t *lifo, size_t capacity) {                          \
+        return _z_lifo_init(lifo, capacity);                                                               \
+    }                                                                                                      \
+    static inline name##_lifo_t name##_lifo_make(size_t capacity) { return _z_lifo_make(capacity); }       \
+    static inline size_t name##_lifo_capacity(const name##_lifo_t *r) { return _z_lifo_capacity(r); }      \
+    static inline size_t name##_lifo_len(const name##_lifo_t *r) { return _z_lifo_len(r); }                \
+    static inline _Bool name##_lifo_is_empty(const name##_lifo_t *r) { return _z_lifo_is_empty(r); }       \
+    static inline _Bool name##_lifo_is_full(const name##_lifo_t *r) { return _z_lifo_is_full(r); }         \
+    static inline type *name##_lifo_push(name##_lifo_t *r, type *e) { return _z_lifo_push(r, (void *)e); } \
+    static inline void name##_lifo_push_drop(name##_lifo_t *r, type *e) {                                  \
+        return _z_lifo_push_drop(r, (void *)e, name##_elem_free);                                          \
+    }                                                                                                      \
+    static inline type *name##_lifo_pull(name##_lifo_t *r) { return (type *)_z_lifo_pull(r); }             \
+    static inline void name##_lifo_clear(name##_lifo_t *r) { _z_lifo_clear(r, name##_elem_free); }         \
+    static inline void name##_lifo_free(name##_lifo_t **r) { _z_lifo_free(r, name##_elem_free); }
+
+#endif /* ZENOH_PICO_COLLECTIONS_LIFO_H */

src/collections/fifo.c

@@ -0,0 +1,53 @@
+//
+// Copyright (c) 2022 ZettaScale Technology
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
+// which is available at https://www.apache.org/licenses/LICENSE-2.0.
+//
+// SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
+//
+// Contributors:
+//   ZettaScale Zenoh Team, <[email protected]>
+//
+#include "zenoh-pico/collections/fifo.h"
+
+#include <assert.h>
+#include <stddef.h>
+#include <string.h>
+
+/*-------- fifo --------*/
+int8_t _z_fifo_init(_z_fifo_t *r, size_t capacity) {
+    _z_ring_init(&r->_ring, capacity);
+    return 0;
+}
+
+_z_fifo_t _z_fifo_make(size_t capacity) {
+    _z_fifo_t v;
+    _z_fifo_init(&v, capacity);
+    return v;
+}
+
+size_t _z_fifo_capacity(const _z_fifo_t *r) { return _z_ring_capacity(&r->_ring); }
+size_t _z_fifo_len(const _z_fifo_t *r) { return _z_ring_len(&r->_ring); }
+bool _z_fifo_is_empty(const _z_fifo_t *r) { return _z_ring_is_empty(&r->_ring); }
+bool _z_fifo_is_full(const _z_fifo_t *r) { return _z_fifo_len(r) == _z_fifo_capacity(r); }
+
+void *_z_fifo_push(_z_fifo_t *r, void *e) { return _z_ring_push(&r->_ring, e); }
+void _z_fifo_push_drop(_z_fifo_t *r, void *e, z_element_free_f free_f) {
+    void *ret = _z_fifo_push(r, e);
+    if (ret != NULL) {
+        free_f(&ret);
+    }
+}
+void *_z_fifo_pull(_z_fifo_t *r) { return _z_ring_pull(&r->_ring); }
+void _z_fifo_clear(_z_fifo_t *r, z_element_free_f free_f) { _z_ring_clear(&r->_ring, free_f); }
+void _z_fifo_free(_z_fifo_t **r, z_element_free_f free_f) {
+    _z_fifo_t *ptr = (_z_fifo_t *)*r;
+    if (ptr != NULL) {
+        _z_fifo_clear(ptr, free_f);
+        zp_free(ptr);
+        *r = NULL;
+    }
+}

src/collections/lifo.c

@@ -0,0 +1,90 @@
+//
+// Copyright (c) 2022 ZettaScale Technology
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
+// which is available at https://www.apache.org/licenses/LICENSE-2.0.
+//
+// SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
+//
+// Contributors:
+//   ZettaScale Zenoh Team, <[email protected]>
+//
+#include "zenoh-pico/collections/lifo.h"
+
+#include <assert.h>
+#include <stddef.h>
+#include <string.h>
+
+/*-------- lifo --------*/
+int8_t _z_lifo_init(_z_lifo_t *r, size_t capacity) {
+    memset(r, 0, sizeof(_z_lifo_t));
+    if (capacity != (size_t)0) {
+        r->_val = (void **)zp_malloc(sizeof(void *) * capacity);
+    }
+    if (r->_val != NULL) {
+        memset(r->_val, 0, capacity);
+        r->_capacity = capacity;
+    }
+    return 0;
+}
+
+_z_lifo_t _z_lifo_make(size_t capacity) {
+    _z_lifo_t v;
+    _z_lifo_init(&v, capacity);
+    return v;
+}
+
+size_t _z_lifo_capacity(const _z_lifo_t *r) { return r->_capacity; }
+size_t _z_lifo_len(const _z_lifo_t *r) { return r->_len; }
+_Bool _z_lifo_is_empty(const _z_lifo_t *r) { return r->_len == 0; }
+_Bool _z_lifo_is_full(const _z_lifo_t *r) { return r->_len == r->_capacity; }
+
+void *_z_lifo_push(_z_lifo_t *r, void *e) {
+    void *ret = e;
+    if (!_z_lifo_is_full(r)) {
+        r->_val[r->_len] = e;
+        r->_len++;
+        ret = NULL;
+    }
+    return ret;
+}
+
+void _z_lifo_push_drop(_z_lifo_t *r, void *e, z_element_free_f free_f) {
+    void *ret = _z_lifo_push(r, e);
+    if (ret != NULL) {
+        free_f(&ret);
+    }
+}
+
+void *_z_lifo_pull(_z_lifo_t *r) {
+    void *ret = NULL;
+    if (!_z_lifo_is_empty(r)) {
+        r->_len--;
+        ret = r->_val[r->_len];
+    }
+    return ret;
+}
+
+void _z_lifo_clear(_z_lifo_t *r, z_element_free_f free_f) {
+    void *e = _z_lifo_pull(r);
+    while (e != NULL) {
+        free_f(&e);
+        e = _z_lifo_pull(r);
+    }
+    zp_free(r->_val);
+
+    r->_val = NULL;
+    r->_capacity = (size_t)0;
+    r->_len = (size_t)0;
+}
+
+void _z_lifo_free(_z_lifo_t **r, z_element_free_f free_f) {
+    _z_lifo_t *ptr = (_z_lifo_t *)*r;
+    if (ptr != NULL) {
+        _z_lifo_clear(ptr, free_f);
+        zp_free(ptr);
+        *r = NULL;
+    }
+}