include/slist.h

Go to the documentation of this file.

#ifndef SLIST_H_INCLUDED
#define SLIST_H_INCLUDED

#include <assert.h>
#include <types.h>

struct slist_node {
        struct slist_node       *next;  
};

struct slist {
        struct slist_node       first;
        struct slist_node       *last;
};

static inline void slist_init(struct slist *list)
{
        list->first.next = &list->first;
        list->last = &list->first;
}

static inline bool slist_is_empty(struct slist *list)
{
        return list->first.next == &list->first;
}

static inline bool slist_node_is_last(struct slist *list,
                struct slist_node *node)
{
        return node == list->last;
}

static inline bool slist_node_is_valid(struct slist *list,
                struct slist_node *node)
{
        return node != &list->first;
}

#define slist_entry(node, type, member)                         \
        container_of(node, type, member)

static inline void slist_insert_head(struct slist *list,
                struct slist_node *node)
{
        node->next = list->first.next;
        if (list->last == &list->first)
                list->last = node;
        list->first.next = node;
}

static inline void slist_insert_tail(struct slist *list,
                struct slist_node *node)
{
        node->next = &list->first;
        list->last->next = node;
        list->last = node;
}

static inline void slist_borrow_to_tail(struct slist *to, struct slist *from)
{
        assert(!slist_is_empty(from));

        from->last->next = &to->first;
        to->last->next = from->first.next;
        to->last = from->last;
}

static inline void slist_give_back_head(struct slist *to, struct slist *from)
{
        from->first.next = to->last->next;
        if (from->first.next == &from->first)
                from->last = &from->first;
        to->last->next = &to->first;
}

static inline void slist_move_to_tail(struct slist *to, struct slist *from)
{
        slist_borrow_to_tail(to, from);
        slist_init(from);
}

static inline void slist_move_to_head(struct slist *to, struct slist *from)
{
        assert(!slist_is_empty(from));

        from->last->next = to->first.next;
        to->first.next = from->first.next;
        if (to->last == &to->first)
                to->last = from->last;
        slist_init(from);
}

static inline struct slist_node *slist_peek_head_node(struct slist *list)
{
        assert(list);
        return list->first.next;
}

#define slist_peek_head(list, type, member)                     \
        slist_entry(slist_peek_head_node(list), type, member)

static inline struct slist_node *slist_peek_tail_node(struct slist *list)
{
        assert(list);
        return list->last;
}

#define slist_peek_tail(list, type, member)                     \
        slist_entry(slist_peek_tail_node(list), type, member)

static inline struct slist_node *slist_peek_next_node(struct slist_node *node)
{
        assert(node);
        return node->next;
}

#define slist_peek_next(node, type, member)                     \
        slist_entry(slist_peek_next_node(node), type, member)

static inline struct slist_node *slist_pop_head_node(struct slist *list)
{
        struct slist_node *node;

        assert(list);
        assert(list->first.next != &list->first);

        node = list->first.next;
        list->first.next = node->next;
        if (list->last == node)
                list->last = &list->first;

        return node;
}

#define slist_pop_head(list, type, member)                              \
        container_of(slist_pop_head_node(list), type, member)

#endif /* SLIST_H_INCLUDED */

---