bclst.h

浏览该文件的文档.

 
#ifndef __xwos_lib_bclst_h__
#define __xwos_lib_bclst_h__
 
#include <xwos/standard.h>
 
struct xwlib_bclst_node {
        struct xwlib_bclst_node * next; 
        struct xwlib_bclst_node * prev; 
};
 
#define xwlib_bclst_head        xwlib_bclst_node
 
#define XWLIB_BCLST_HEAD_INIT(n) (struct xwlib_bclst_head){&(n), &(n)}
 
#define XWLIB_BCLST_NODE_INIT(n) (struct xwlib_bclst_node){&(n), &(n)}
 
#define xwlib_bclst_entry(ptr, type, member) xwcc_derof((ptr), type, member)
 
#define xwlib_bclst_first_entry(head, type, member) \
        xwlib_bclst_entry((head)->next, type, member)
 
#define xwlib_bclst_last_entry(head, type, member) \
        xwlib_bclst_entry((head)->prev, type, member)
 
#define xwlib_bclst_next_entry(p, type, member) \
        xwlib_bclst_entry((p)->member.next, type, member)
 
#define xwlib_bclst_prev_entry(p, type, member) \
        xwlib_bclst_entry((p)->member.prev, type, member)
 
#define xwlib_bclst_itr_next(p, head) \
        for ((p) = (head)->next; (p) != (head); (p) = (p)->next)
 
#define xwlib_bclst_itr_prev(p, head) \
        for ((p) = (head)->prev; (p) != (head); (p) = (p)->prev)
 
#define xwlib_bclst_itr_next_safe(p, n, head) \
        for ((p) = (head)->next, (n) = (p)->next; \
             (p) != (head); \
             (p) = (n), (n) = (p)->next)
 
#define xwlib_bclst_itr_prev_safe(p, n, head) \
        for ((p) = (head)->prev, (n) = (p)->prev; \
             (p) != (head); \
             (p) = (n), (n) = (p)->prev)
 
#define xwlib_bclst_itr_next_entry(p, head, type, member) \
        for ((p) = xwlib_bclst_first_entry(head, type, member); \
             &(p)->member != (head); \
             (p) = xwlib_bclst_next_entry((p), type, member))
 
#define xwlib_bclst_itr_prev_entry(p, head, type, member) \
        for ((p) = xwlib_bclst_last_entry(head, type, member); \
             &(p)->member != (head); \
             (p) = xwlib_bclst_prev_entry((p), type, member))
 
#define xwlib_bclst_itr_next_entry_safe(p, n, head, type, member) \
        for ((p) = xwlib_bclst_first_entry(head, type, member), \
             (n) = xwlib_bclst_next_entry((p), type, member); \
             &(p)->member != (head); \
             (p) = (n), (n) = xwlib_bclst_next_entry((n), type, member))
 
#define xwlib_bclst_itr_next_entry_del(p, head, type, member) \
        for ((p) = xwlib_bclst_first_entry(head, type, member); \
             &(p)->member != (head); \
             (p) = xwlib_bclst_first_entry(head, type, member))
 
#define xwlib_bclst_itr_prev_entry_safe(p, n, head, type, member) \
        for ((p) = xwlib_bclst_last_entry(head, type, member), \
             (n) = xwlib_bclst_prev_entry((p), type, member); \
             &(p)->member != (head); \
             (p) = (n), (n) = xwlib_bclst_prev_entry((n), type, member))
 
#define xwlib_bclst_itr_prev_entry_del(p, head, type, member) \
        for ((p) = xwlib_bclst_last_entry(head, type, member); \
             &(p)->member != (head); \
             (p) = xwlib_bclst_last_entry(head, type, member))
 
static __xwlib_inline
void xwlib_bclst_init_head(struct xwlib_bclst_head * h)
{
        h->next = h;
        h->prev = h;
}
 
static __xwlib_inline
void xwlib_bclst_init_node(struct xwlib_bclst_node * n)
{
        n->next = n;
        n->prev = n;
}
 
static __xwlib_inline
bool xwlib_bclst_tst_empty(const struct xwlib_bclst_head * h)
{
        return (h->next == h);
}
 
static __xwlib_inline
bool xwlib_bclst_tst_first(struct xwlib_bclst_node * h, struct xwlib_bclst_node * n)
{
        return (n == h->next);
}
 
static __xwlib_inline
bool xwlib_bclst_tst_last(struct xwlib_bclst_node * h, struct xwlib_bclst_node * n)
{
        return (n == h->prev);
}
 
static __xwlib_inline
bool xwlib_bclst_tst_empty_carefully(const struct xwlib_bclst_head * h)
{
        struct xwlib_bclst_node * next = h->next;
        return ((next == (const struct xwlib_bclst_node *)h) && (next == h->prev));
}
 
static __xwlib_inline
void xwlib_bclst_add_between(struct xwlib_bclst_node * newn,
                             struct xwlib_bclst_node * prev,
                             struct xwlib_bclst_node * next)
{
        next->prev = newn;
        newn->next = next;
        newn->prev = prev;
        prev->next = newn;
}
 
static __xwlib_inline
void xwlib_bclst_add_front(struct xwlib_bclst_node * newn,
                           struct xwlib_bclst_node * next)
{
        xwlib_bclst_add_between(newn, next->prev, next);
 
}
 
static __xwlib_inline
void xwlib_bclst_add_behind(struct xwlib_bclst_node * newn,
                            struct xwlib_bclst_node * prev)
{
        xwlib_bclst_add_between(newn, prev, prev->next);
}
 
static __xwlib_inline
void xwlib_bclst_add_head(struct xwlib_bclst_head * head,
                          struct xwlib_bclst_node * newn)
{
        xwlib_bclst_add_between(newn, head, head->next);
}
 
static __xwlib_inline
void xwlib_bclst_add_tail(struct xwlib_bclst_head * head,
                          struct xwlib_bclst_node * newn)
{
        xwlib_bclst_add_between(newn, head->prev, head);
}
 
static __xwlib_inline
void xwlib_bclst_del_between(struct xwlib_bclst_node * prev,
                             struct xwlib_bclst_node * next)
{
        next->prev = prev;
        prev->next = next;
}
 
static __xwlib_inline
void xwlib_bclst_del(struct xwlib_bclst_node * node)
{
        xwlib_bclst_del_between(node->prev, node->next);
}
 
static __xwlib_inline
void xwlib_bclst_del_init(struct xwlib_bclst_node * node)
{
        xwlib_bclst_del_between(node->prev, node->next);
        xwlib_bclst_init_node(node);
}
 
static __xwlib_inline
void xwlib_bclst_replace(struct xwlib_bclst_node * newn,
                         struct xwlib_bclst_node * oldn)
{
        newn->next = oldn->next;
        newn->next->prev = newn;
        newn->prev = oldn->prev;
        newn->prev->next = newn;
}
 
static __xwlib_inline
void xwlib_bclst_replace_init(struct xwlib_bclst_node * newn,
                              struct xwlib_bclst_node * oldn)
{
        xwlib_bclst_replace(newn, oldn);
        xwlib_bclst_init_node(oldn);
}
 
static __xwlib_inline
void xwlib_bclst_splice_between(struct xwlib_bclst_head * list,
                                struct xwlib_bclst_node * prev,
                                struct xwlib_bclst_node * next)
{
        struct xwlib_bclst_node * first = list->next;
        struct xwlib_bclst_node * last = list->prev;
 
        first->prev = prev;
        prev->next = first;
        last->next = next;
        next->prev = last;
}
 
static __xwlib_inline
void xwlib_bclst_splice_head(struct xwlib_bclst_head * head,
                             struct xwlib_bclst_head * list)
{
        if (!xwlib_bclst_tst_empty(list)) {
                xwlib_bclst_splice_between(list, head, head->next);
        }
}
 
static __xwlib_inline
void xwlib_bclst_splice_tail(struct xwlib_bclst_head * head,
                             struct xwlib_bclst_head * list)
{
        if (!xwlib_bclst_tst_empty(list)) {
                xwlib_bclst_splice_between(list, head->prev, head);
        }
}
 
static __xwlib_inline
void xwlib_bclst_splice_head_init(struct xwlib_bclst_head * head,
                                  struct xwlib_bclst_head * list)
{
        if (!xwlib_bclst_tst_empty(list)) {
                xwlib_bclst_splice_between(list, head, head->next);
                xwlib_bclst_init_head(list);
        }
}
 
static __xwlib_inline
void xwlib_bclst_splice_tail_init(struct xwlib_bclst_head * head,
                                  struct xwlib_bclst_head * list)
{
        if (!xwlib_bclst_tst_empty(list)) {
                xwlib_bclst_splice_between(list, head->prev, head);
                xwlib_bclst_init_head(list);
        }
}
 
static __xwlib_inline
void xwlib_bclst_insseg_between(struct xwlib_bclst_node * seg,
                                struct xwlib_bclst_node * prev,
                                struct xwlib_bclst_node * next)
{
        struct xwlib_bclst_node * first = seg;
        struct xwlib_bclst_node * last = seg->prev;
 
        first->prev = prev;
        prev->next = first;
        last->next = next;
        next->prev = last;
}
 
static __xwlib_inline
void xwlib_bclst_insseg_head(struct xwlib_bclst_head * head,
                             struct xwlib_bclst_node * seg)
{
        xwlib_bclst_insseg_between(seg, head, head->next);
}
 
static __xwlib_inline
void xwlib_bclst_insseg_tail(struct xwlib_bclst_head * head,
                             struct xwlib_bclst_node * seg)
{
        xwlib_bclst_insseg_between(seg, head->prev, head);
}
 
#endif /* xwos/lib/bclst.h */