que.h

Go to the documentation of this file.

 
#ifndef LIBA_QUE_H
#define LIBA_QUE_H
 
#include "list.h"


typedef struct a_que
{
    a_list head_; 
    a_list **ptr_; 
    a_size siz_; 
    a_size num_; 
    a_size cur_; 
    a_size mem_; 
} a_que;
typedef struct a_que {…};

A_INTERN a_size a_que_siz(a_que const *ctx) { return ctx->siz_; }

A_INTERN a_size a_que_num(a_que const *ctx) { return ctx->num_; }

A_INTERN void *a_que_fore_(a_que const *ctx)
{
    return a_cast_s(void *, ctx->head_.next + 1);
}
A_INTERN void *a_que_fore_(a_que const *ctx) {…}
#define A_QUE_FORE_(T, ctx) a_cast_s(T *, a_que_fore_(ctx))

A_INTERN void *a_que_back_(a_que const *ctx)
{
    return a_cast_s(void *, ctx->head_.prev + 1);
}
A_INTERN void *a_que_back_(a_que const *ctx) {…}
#define A_QUE_BACK_(T, ctx) a_cast_s(T *, a_que_back_(ctx))

A_INTERN void *a_que_fore(a_que const *ctx)
{
    return ctx->head_.next != &ctx->head_ ? a_que_fore_(ctx) : A_NULL;
}
A_INTERN void *a_que_fore(a_que const *ctx) {…}
#define A_QUE_FORE(T, ctx) a_cast_s(T *, a_que_fore(ctx))

A_INTERN void *a_que_back(a_que const *ctx)
{
    return ctx->head_.prev != &ctx->head_ ? a_que_back_(ctx) : A_NULL;
}
A_INTERN void *a_que_back(a_que const *ctx) {…}
#define A_QUE_BACK(T, ctx) a_cast_s(T *, a_que_back(ctx))

A_INTERN void a_que_swap_(void *lhs, void *rhs)
{
    a_list_swap_node(a_cast_s(a_list *, lhs) - 1, a_cast_s(a_list *, rhs) - 1);
}
A_INTERN void a_que_swap_(void *lhs, void *rhs) {…}
 
#if defined(__cplusplus)
extern "C" {
#endif /* __cplusplus */

A_EXTERN a_que *a_que_new(a_size size);

A_EXTERN void a_que_die(a_que *ctx, void (*dtor)(void *));

A_EXTERN void a_que_ctor(a_que *ctx, a_size size);

A_EXTERN void a_que_dtor(a_que *ctx, void (*dtor)(void *));

A_EXTERN void a_que_swap(a_que *lhs, a_que *rhs);

A_EXTERN int a_que_drop(a_que *ctx, void (*dtor)(void *));

A_EXTERN int a_que_setz(a_que *ctx, a_size siz, void (*dtor)(void *));

A_EXTERN void *a_que_at(a_que const *ctx, a_diff idx);
#define A_QUE_AT(T, ctx, idx) a_cast_s(T *, a_que_at(ctx, idx))

A_EXTERN void a_que_sort_fore(a_que const *ctx, int (*cmp)(void const *, void const *));

A_EXTERN void a_que_sort_back(a_que const *ctx, int (*cmp)(void const *, void const *));

A_EXTERN void *a_que_push_sort(a_que *ctx, void const *key, int (*cmp)(void const *, void const *));
#define A_QUE_PUSH_SORT(T, ctx, key, cmp) a_cast_s(T *, a_que_push_sort(ctx, key, cmp))

A_EXTERN void *a_que_push_fore(a_que *ctx);
#define A_QUE_PUSH_FORE(T, ctx) a_cast_s(T *, a_que_push_fore(ctx))

A_EXTERN void *a_que_push_back(a_que *ctx);
#define A_QUE_PUSH_BACK(T, ctx) a_cast_s(T *, a_que_push_back(ctx))

A_EXTERN void *a_que_pull_fore(a_que *ctx);
#define A_QUE_PULL_FORE(T, ctx) a_cast_s(T *, a_que_pull_fore(ctx))

A_EXTERN void *a_que_pull_back(a_que *ctx);
#define A_QUE_PULL_BACK(T, ctx) a_cast_s(T *, a_que_pull_back(ctx))

A_EXTERN void *a_que_insert(a_que *ctx, a_size idx);
#define A_QUE_INSERT(T, ctx, idx) a_cast_s(T *, a_que_insert(ctx, idx))

A_EXTERN void *a_que_remove(a_que *ctx, a_size idx);
#define A_QUE_REMOVE(T, ctx, idx) a_cast_s(T *, a_que_remove(ctx, idx))
 
#if defined(__cplusplus)
} /* extern "C" */
#endif /* __cplusplus */

#define a_que_foreach(T, S, it, ctx)                               \
    for (T S it = a_cast_r(T S, (ctx)->head_.next),                \
             S it##_ = a_cast_r(T S, a_list_(*, it)->next);        \
         a_list_(*, it) != &(ctx)->head_                           \
             ? ((void)(it = a_cast_r(T S, a_list_(*, it) + 1)), 1) \
             : (0);                                                \
         it = it##_, it##_ = a_cast_r(T S, a_list_(*, it)->next))
#define a_que_foreach(T, S, it, ctx)                               \ …
#define A_QUE_FOREACH(T, it, at, ctx)                            \
    for ((void)(it = a_cast_r(T, (ctx)->head_.next)),            \
         at = a_cast_r(T, a_list_(*, it)->next);                 \
         a_list_(*, it) != &(ctx)->head_                         \
             ? ((void)(it = a_cast_r(T, a_list_(*, it) + 1)), 1) \
             : (0);                                              \
         it = at, at = a_cast_r(T, a_list_(*, it)->next))

#define a_que_foreach_reverse(T, S, it, ctx)                       \
    for (T S it = a_cast_r(T S, (ctx)->head_.prev),                \
             S it##_ = a_cast_r(T S, a_list_(*, it)->prev);        \
         a_list_(*, it) != &(ctx)->head_                           \
             ? ((void)(it = a_cast_r(T S, a_list_(*, it) + 1)), 1) \
             : (0);                                                \
         it = it##_, it##_ = a_cast_r(T S, a_list_(*, it)->prev))
#define a_que_foreach_reverse(T, S, it, ctx)                       \ …
#define A_QUE_FOREACH_REVERSE(T, it, at, ctx)                    \
    for ((void)(it = a_cast_r(T, (ctx)->head_.prev)),            \
         at = a_cast_r(T, a_list_(*, it)->prev);                 \
         a_list_(*, it) != &(ctx)->head_                         \
             ? ((void)(it = a_cast_r(T, a_list_(*, it) + 1)), 1) \
             : (0);                                              \
         it = at, at = a_cast_r(T, a_list_(*, it)->prev))

 
#endif /* a/que.h */