impl_flat_priority_queue.h

 
#ifndef CCC_IMPL_FLAT_PRIORITY_QUEUE_H
#define CCC_IMPL_FLAT_PRIORITY_QUEUE_H
 
#include <assert.h>
#include <stddef.h>
#include "../buffer.h"
#include "../types.h"
 
/* NOLINTBEGIN(readability-identifier-naming) */
 
struct ccc_fpq
{
    ccc_buffer buf;
    ccc_threeway_cmp order;
    ccc_any_type_cmp_fn *cmp;
};
 
/*========================    Private Interface     =========================*/
 
size_t ccc_impl_fpq_bubble_up(struct ccc_fpq *, void *, size_t);
void ccc_impl_fpq_in_place_heapify(struct ccc_fpq *, size_t n, void *tmp);
void *ccc_impl_fpq_update_fixup(struct ccc_fpq *, void *, void *tmp);
 
/*======================    Macro Implementations    ========================*/
 
#define ccc_impl_fpq_init(impl_mem_ptr, impl_any_type_name, impl_cmp_order,    \
                          impl_cmp_fn, impl_alloc_fn, impl_aux_data,           \
                          impl_capacity)                                       \
    {                                                                          \
        .buf = ccc_buf_init(impl_mem_ptr, impl_any_type_name, impl_alloc_fn,   \
                            impl_aux_data, impl_capacity),                     \
        .cmp = (impl_cmp_fn),                                                  \
        .order = (impl_cmp_order),                                             \
    }
 
#define ccc_impl_fpq_heapify_init(impl_mem_ptr, impl_any_type_name,            \
                                  impl_cmp_order, impl_cmp_fn, impl_alloc_fn,  \
                                  impl_aux_data, impl_capacity, impl_size)     \
    (__extension__({                                                           \
        __auto_type impl_fpq_heapify_mem = (impl_mem_ptr);                     \
        struct ccc_fpq impl_fpq_heapify_res = ccc_impl_fpq_init(               \
            impl_fpq_heapify_mem, impl_any_type_name, impl_cmp_order,          \
            impl_cmp_fn, impl_alloc_fn, impl_aux_data, impl_capacity);         \
        ccc_impl_fpq_in_place_heapify(&impl_fpq_heapify_res, (impl_size),      \
                                      &(impl_any_type_name){0});               \
        impl_fpq_heapify_res;                                                  \
    }))
 
#define ccc_impl_fpq_emplace(fpq, type_initializer...)                         \
    (__extension__({                                                           \
        struct ccc_fpq *impl_fpq = (fpq);                                      \
        typeof(type_initializer) *impl_fpq_res                                 \
            = ccc_buf_alloc_back(&impl_fpq->buf);                              \
        if (impl_fpq_res)                                                      \
        {                                                                      \
            *impl_fpq_res = type_initializer;                                  \
            if (impl_fpq->buf.count > 1)                                       \
            {                                                                  \
                impl_fpq_res                                                   \
                    = ccc_buf_at(&impl_fpq->buf,                               \
                                 ccc_impl_fpq_bubble_up(                       \
                                     impl_fpq, &(typeof(type_initializer)){0}, \
                                     impl_fpq->buf.count - 1));                \
            }                                                                  \
            else                                                               \
            {                                                                  \
                impl_fpq_res = ccc_buf_at(&impl_fpq->buf, 0);                  \
            }                                                                  \
        }                                                                      \
        impl_fpq_res;                                                          \
    }))
 
#define ccc_impl_fpq_update_w(fpq_ptr, T_ptr, update_closure_over_T...)        \
    (__extension__({                                                           \
        struct ccc_fpq *const impl_fpq = (fpq_ptr);                            \
        typeof(*T_ptr) *T = (T_ptr);                                           \
        if (impl_fpq && !ccc_buf_is_empty(&impl_fpq->buf) && T)                \
        {                                                                      \
            {update_closure_over_T} T = ccc_impl_fpq_update_fixup(             \
                impl_fpq, T, &(typeof(*T_ptr)){0});                            \
        }                                                                      \
        T;                                                                     \
    }))
 
#define ccc_impl_fpq_increase_w(fpq_ptr, T_ptr, increase_closure_over_T...)    \
    ccc_impl_fpq_update_w(fpq_ptr, T_ptr, increase_closure_over_T)
 
#define ccc_impl_fpq_decrease_w(fpq_ptr, T_ptr, decrease_closure_over_T...)    \
    ccc_impl_fpq_update_w(fpq_ptr, T_ptr, decrease_closure_over_T)
 
/* NOLINTEND(readability-identifier-naming) */
 
#endif /* CCC_IMPL_FLAT_PRIORITY_QUEUE_H */