slist.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef __SLIST_H__
#define __SLIST_H__
 
#include <stddef.h>
#include <stdbool.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
struct _snode {
    struct _snode *next;
};
 
typedef struct _snode sys_snode_t;
 
struct _slist {
    sys_snode_t *head;
    sys_snode_t *tail;
};
 
typedef struct _slist sys_slist_t;
 
#define SYS_SLIST_FOR_EACH_NODE(__sl, __sn)             \
    for (__sn = sys_slist_peek_head(__sl); __sn;            \
         __sn = sys_slist_peek_next(__sn))
 
#define SYS_SLIST_ITERATE_FROM_NODE(__sl, __sn)             \
    for (__sn = __sn ? sys_slist_peek_next_no_check(__sn)       \
             : sys_slist_peek_head(__sl);           \
         __sn;                          \
         __sn = sys_slist_peek_next(__sn))
 
#define SYS_SLIST_FOR_EACH_NODE_SAFE(__sl, __sn, __sns)         \
    for (__sn = sys_slist_peek_head(__sl),              \
             __sns = sys_slist_peek_next(__sn);         \
         __sn; __sn = __sns,                    \
             __sns = sys_slist_peek_next(__sn))
 
/*
 * @brief Provide the primitive to resolve the container of a list node
 * Note: it is safe to use with NULL pointer nodes
 *
 * @param __ln A pointer on a sys_node_t to get its container
 * @param __cn Container struct type pointer
 * @param __n The field name of sys_node_t within the container struct
 */
#define SYS_SLIST_CONTAINER(__ln, __cn, __n) \
    ((__ln) ? CONTAINER_OF((__ln), __typeof__(*(__cn)), __n) : NULL)
/*
 * @brief Provide the primitive to peek container of the list head
 *
 * @param __sl A pointer on a sys_slist_t to peek
 * @param __cn Container struct type pointer
 * @param __n The field name of sys_node_t within the container struct
 */
#define SYS_SLIST_PEEK_HEAD_CONTAINER(__sl, __cn, __n) \
    SYS_SLIST_CONTAINER(sys_slist_peek_head(__sl), __cn, __n)
 
/*
 * @brief Provide the primitive to peek container of the list tail
 *
 * @param __sl A pointer on a sys_slist_t to peek
 * @param __cn Container struct type pointer
 * @param __n The field name of sys_node_t within the container struct
 */
#define SYS_SLIST_PEEK_TAIL_CONTAINER(__sl, __cn, __n) \
    SYS_SLIST_CONTAINER(sys_slist_peek_tail(__sl), __cn, __n)
 
/*
 * @brief Provide the primitive to peek the next container
 *
 * @param __cn Container struct type pointer
 * @param __n The field name of sys_node_t within the container struct
 */
 
#define SYS_SLIST_PEEK_NEXT_CONTAINER(__cn, __n) \
    ((__cn) ? SYS_SLIST_CONTAINER(sys_slist_peek_next(&((__cn)->__n)), \
                      __cn, __n) : NULL)
 
#define SYS_SLIST_FOR_EACH_CONTAINER(__sl, __cn, __n)           \
    for (__cn = SYS_SLIST_PEEK_HEAD_CONTAINER(__sl, __cn, __n); __cn; \
         __cn = SYS_SLIST_PEEK_NEXT_CONTAINER(__cn, __n))
 
#define SYS_SLIST_FOR_EACH_CONTAINER_SAFE(__sl, __cn, __cns, __n)   \
    for (__cn = SYS_SLIST_PEEK_HEAD_CONTAINER(__sl, __cn, __n), \
         __cns = SYS_SLIST_PEEK_NEXT_CONTAINER(__cn, __n); __cn;    \
         __cn = __cns, __cns = SYS_SLIST_PEEK_NEXT_CONTAINER(__cn, __n))
 
static inline void sys_slist_init(sys_slist_t *list)
{
    list->head = NULL;
    list->tail = NULL;
}
 
#define SYS_SLIST_STATIC_INIT(ptr_to_list) {NULL, NULL}
 
static inline bool sys_slist_is_empty(sys_slist_t *list)
{
    return (!list->head);
}
 
static inline sys_snode_t *sys_slist_peek_head(sys_slist_t *list)
{
    return list->head;
}
 
static inline sys_snode_t *sys_slist_peek_tail(sys_slist_t *list)
{
    return list->tail;
}
 
static inline sys_snode_t *sys_slist_peek_next_no_check(sys_snode_t *node)
{
    return node->next;
}
 
static inline sys_snode_t *sys_slist_peek_next(sys_snode_t *node)
{
    return node ? sys_slist_peek_next_no_check(node) : NULL;
}
 
static inline void sys_slist_prepend(sys_slist_t *list,
                     sys_snode_t *node)
{
    node->next = list->head;
    list->head = node;
 
    if (!list->tail) {
        list->tail = list->head;
    }
}
 
static inline void sys_slist_append(sys_slist_t *list,
                    sys_snode_t *node)
{
    node->next = NULL;
 
    if (!list->tail) {
        list->tail = node;
        list->head = node;
    } else {
        list->tail->next = node;
        list->tail = node;
    }
}
 
static inline void sys_slist_append_list(sys_slist_t *list,
                     void *head, void *tail)
{
    if (!list->tail) {
        list->head = (sys_snode_t *)head;
        list->tail = (sys_snode_t *)tail;
    } else {
        list->tail->next = (sys_snode_t *)head;
        list->tail = (sys_snode_t *)tail;
    }
}
 
static inline void sys_slist_merge_slist(sys_slist_t *list,
                     sys_slist_t *list_to_append)
{
    sys_slist_append_list(list, list_to_append->head,
                    list_to_append->tail);
    sys_slist_init(list_to_append);
}
 
static inline void sys_slist_insert(sys_slist_t *list,
                    sys_snode_t *prev,
                    sys_snode_t *node)
{
    if (!prev) {
        sys_slist_prepend(list, node);
    } else if (!prev->next) {
        sys_slist_append(list, node);
    } else {
        node->next = prev->next;
        prev->next = node;
    }
}
 
static inline sys_snode_t *sys_slist_get_not_empty(sys_slist_t *list)
{
    sys_snode_t *node = list->head;
 
    list->head = node->next;
    if (list->tail == node) {
        list->tail = list->head;
    }
 
    return node;
}
 
static inline sys_snode_t *sys_slist_get(sys_slist_t *list)
{
    return sys_slist_is_empty(list) ? NULL : sys_slist_get_not_empty(list);
}
 
static inline void sys_slist_remove(sys_slist_t *list,
                    sys_snode_t *prev_node,
                    sys_snode_t *node)
{
    if (!prev_node) {
        list->head = node->next;
 
        /* Was node also the tail? */
        if (list->tail == node) {
            list->tail = list->head;
        }
    } else {
        prev_node->next = node->next;
 
        /* Was node the tail? */
        if (list->tail == node) {
            list->tail = prev_node;
        }
    }
 
    node->next = NULL;
}
 
static inline bool sys_slist_find_and_remove(sys_slist_t *list,
                         sys_snode_t *node)
{
    sys_snode_t *prev = NULL;
    sys_snode_t *test;
 
    SYS_SLIST_FOR_EACH_NODE(list, test) {
        if (test == node) {
            sys_slist_remove(list, prev, node);
            return true;
        }
 
        prev = test;
    }
 
    return false;
}
 
 
#ifdef __cplusplus
}
#endif
 
#endif /* __SLIST_H__ */