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[], 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_cmp_order, impl_cmp_fn,           \
                          impl_alloc_fn, impl_aux_data, impl_capacity)         \
    {                                                                          \
        .buf = ccc_buf_init(impl_mem_ptr, 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_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_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;                                \
        struct ccc_fpq *impl_fpq = (fpq);                                      \
        assert(sizeof(*impl_fpq_res)                                           \
               == ccc_buf_sizeof_type(&impl_fpq->buf).count);                  \
        impl_fpq_res = ccc_buf_alloc_back(&impl_fpq->buf);                     \
        if (ccc_buf_size(&impl_fpq->buf).count                                 \
            == ccc_buf_capacity(&impl_fpq->buf).count)                         \
        {                                                                      \
            impl_fpq_res = NULL;                                               \
            ccc_result const impl_extra_space = ccc_buf_alloc(                 \
                &impl_fpq->buf, ccc_buf_capacity(&impl_fpq->buf).count * 2,    \
                impl_fpq->buf.alloc);                                          \
            if (impl_extra_space == CCC_RESULT_OK)                             \
            {                                                                  \
                impl_fpq_res = ccc_buf_back(&impl_fpq->buf);                   \
            }                                                                  \
        }                                                                      \
        if (impl_fpq_res)                                                      \
        {                                                                      \
            *impl_fpq_res = type_initializer;                                  \
            if (ccc_buf_size(&impl_fpq->buf).count > 1)                        \
            {                                                                  \
                void *impl_fpq_tmp = ccc_buf_at(                               \
                    &impl_fpq->buf, ccc_buf_size(&impl_fpq->buf).count);       \
                impl_fpq_res                                                   \
                    = ccc_buf_at(&impl_fpq->buf,                               \
                                 ccc_impl_fpq_bubble_up(                       \
                                     impl_fpq, impl_fpq_tmp,                   \
                                     ccc_buf_size(&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 */