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 *, char[const], size_t);
void ccc_impl_fpq_in_place_heapify(struct ccc_fpq *, size_t n);
void *ccc_impl_fpq_update_fixup(struct ccc_fpq *, void *);
 
/*======================    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_fpq_heapify_res;                                                  \
    }))
 
#define ccc_impl_fpq_emplace(fpq, type_initializer...)                         \
    (__extension__({                                                           \
        typeof(type_initializer) *impl_fpq_res = NULL;                         \
        struct ccc_fpq *impl_fpq = (fpq);                                      \
        assert(sizeof(*impl_fpq_res) == impl_fpq->buf.sizeof_type);            \
        if (impl_fpq->buf.count + 1 >= impl_fpq->buf.capacity)                 \
        {                                                                      \
            ccc_result const impl_extra_space = ccc_buf_alloc(                 \
                &impl_fpq->buf,                                                \
                impl_fpq->buf.capacity ? impl_fpq->buf.capacity * 2 : 8,       \
                impl_fpq->buf.alloc);                                          \
            if (impl_extra_space == CCC_RESULT_OK)                             \
            {                                                                  \
                impl_fpq_res = ccc_buf_alloc_back(&impl_fpq->buf);             \
            }                                                                  \
        }                                                                      \
        else                                                                   \
        {                                                                      \
            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)                                       \
            {                                                                  \
                void *impl_fpq_tmp                                             \
                    = ccc_buf_at(&impl_fpq->buf, impl_fpq->buf.count);         \
                impl_fpq_res = ccc_buf_at(                                     \
                    &impl_fpq->buf,                                            \
                    ccc_impl_fpq_bubble_up(impl_fpq, impl_fpq_tmp,             \
                                           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);                      \
        }                                                                      \
        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 */