list.h

Go to the documentation of this file.

 
#ifndef LIBA_LIST_H
#define LIBA_LIST_H
 
#include "a.h"
 
// clang-format off
#define A_LIST_INIT(node) {&(node), &(node)}
// clang-format on
 
typedef struct a_list
{
    struct a_list *next, *prev;
} a_list;
 
#define a_list_(_, x) a_cast_s(a_list _, a_cast_s(void _, x))
 
#define a_list_entry(ptr, type, member) a_container_of(ptr, type, member)
#define a_list_entry_next(ptr, type, member) a_list_entry((ptr)->next, type, member)
#define a_list_entry_prev(ptr, type, member) a_list_entry((ptr)->prev, type, member)
 
#define a_list_foreach_(it, ctx, next) \
    for (a_list *it = (ctx)->next; it != (ctx); it = it->next)
#define a_list_foreach_next(it, ctx) a_list_foreach_(it, ctx, next)
#define a_list_foreach_prev(it, ctx) a_list_foreach_(it, ctx, prev)
 
#define a_list_forsafe_(it, at, ctx, next) \
    for (a_list *it = (ctx)->next, *at = it->next; it != (ctx); it = at, at = it->next)
#define a_list_forsafe_next(it, at, ctx) a_list_forsafe_(it, at, ctx, next)
#define a_list_forsafe_prev(it, at, ctx) a_list_forsafe_(it, at, ctx, prev)
 
A_INTERN void a_list_ctor(a_list *ctx) { ctx->prev = ctx->next = ctx; }
 
A_INTERN void a_list_init(a_list *ctx) { ctx->prev = ctx->next = ctx; }
 
A_INTERN void a_list_dtor(a_list *ctx) { ctx->prev = ctx->next = ctx; }
 
A_INTERN void a_list_link(a_list *head, a_list *tail)
{
    head->next = tail;
    tail->prev = head;
}
 
A_INTERN void a_list_loop(a_list *head, a_list *tail)
{
    head->prev = tail;
    tail->next = head;
}
 
A_INTERN void a_list_add_(a_list *head1, a_list *tail1, a_list *head2, a_list *tail2)
{
    a_list_link(tail1, head2);
    a_list_link(tail2, head1);
}
 
A_INTERN void a_list_add_node(a_list *head, a_list *tail, a_list *node)
{
    a_list_add_(head, tail, node, node);
}
 
A_INTERN void a_list_add_next(a_list *ctx, a_list *node)
{
    a_list_add_(ctx->next, ctx, node, node);
}
 
A_INTERN void a_list_add_prev(a_list *ctx, a_list *node)
{
    a_list_add_(ctx, ctx->prev, node, node);
}
 
A_INTERN void a_list_del_(a_list const *head, a_list const *tail)
{
    a_list_link(head->prev, tail->next);
}
 
A_INTERN void a_list_del_node(a_list const *node) { a_list_del_(node, node); }
 
A_INTERN void a_list_del_next(a_list const *node) { a_list_del_(node->next, node->next); }
 
A_INTERN void a_list_del_prev(a_list const *node) { a_list_del_(node->prev, node->prev); }
 
A_INTERN void a_list_set_(a_list const *head1, a_list const *tail1, a_list *head2, a_list *tail2)
{
    a_list_add_(tail1->next, head1->prev, head2, tail2);
}
 
A_INTERN void a_list_set_node(a_list const *ctx, a_list *rhs)
{
    a_list_add_(ctx->next, ctx->prev, rhs, rhs);
}
 
A_INTERN void a_list_mov_next(a_list *ctx, a_list const *rhs)
{
    a_list_add_(ctx->next, ctx, rhs->next, rhs->prev);
}
 
A_INTERN void a_list_mov_prev(a_list *ctx, a_list const *rhs)
{
    a_list_add_(ctx, ctx->prev, rhs->next, rhs->prev);
}
 
A_INTERN void a_list_rot_next(a_list *ctx)
{
    a_list *const node = ctx->prev;
    a_list_del_(node, node);
    a_list_add_(ctx->next, ctx, node, node);
}
 
A_INTERN void a_list_rot_prev(a_list *ctx)
{
    a_list *const node = ctx->next;
    a_list_del_(node, node);
    a_list_add_(ctx, ctx->prev, node, node);
}
 
A_INTERN void a_list_swap_(a_list *head1, a_list *tail1, a_list *head2, a_list *tail2)
{
    a_list *const head = tail2->next, *const tail = head2->prev;
    a_list_add_(tail1->next, head1->prev, head2, tail2);
    a_list_add_(head, tail, head1, tail1);
}
 
A_INTERN void a_list_swap_node(a_list *lhs, a_list *rhs)
{
    a_list_swap_(lhs, lhs, rhs, rhs);
}
 
#endif /* a/list.h */