private_flat_priority_queue.h

 
#ifndef CCC_PRIVATE_FLAT_PRIORITY_QUEUE_H
#define CCC_PRIVATE_FLAT_PRIORITY_QUEUE_H
 
#include <assert.h>
#include <stddef.h>
#include "../buffer.h"
#include "../types.h"
 
/* NOLINTBEGIN(readability-identifier-naming) */
 
struct CCC_Flat_priority_queue
{
    CCC_Buffer buffer;
    CCC_Order order;
    CCC_Type_comparator *compare;
};
 
/*========================    Private Interface     =========================*/
 
size_t
CCC_private_flat_priority_queue_bubble_up(struct CCC_Flat_priority_queue *,
                                          void *, size_t);
void CCC_private_flat_priority_queue_in_place_heapify(
    struct CCC_Flat_priority_queue *, size_t, void *);
void *
CCC_private_flat_priority_queue_update_fixup(struct CCC_Flat_priority_queue *,
                                             void *, void *);
 
/*======================    Macro Implementations    ========================*/
 
#define CCC_private_flat_priority_queue_initialize(                            \
    private_data_pointer, private_type_name, private_order, private_compare,   \
    private_allocate, private_context_data, private_capacity)                  \
    {                                                                          \
        .buffer = CCC_buffer_initialize(                                       \
            private_data_pointer, private_type_name, private_allocate,         \
            private_context_data, private_capacity),                           \
        .order = (private_order),                                              \
        .compare = (private_compare),                                          \
    }
 
#define CCC_private_flat_priority_queue_heapify_initialize(                    \
    private_data_pointer, private_type_name, private_order, private_compare,   \
    private_allocate, private_context_data, private_capacity, private_size)    \
    (__extension__({                                                           \
        typeof(*(                                                              \
            private_data_pointer)) *private_flat_priority_queue_heapify_data   \
            = (private_data_pointer);                                          \
        struct CCC_Flat_priority_queue private_flat_priority_queue_heapify_res \
            = CCC_private_flat_priority_queue_initialize(                      \
                private_flat_priority_queue_heapify_data, private_type_name,   \
                private_order, private_compare, private_allocate,              \
                private_context_data, private_capacity);                       \
        CCC_private_flat_priority_queue_in_place_heapify(                      \
            &private_flat_priority_queue_heapify_res, (private_size),          \
            &(private_type_name){0});                                          \
        private_flat_priority_queue_heapify_res;                               \
    }))
 
#define CCC_private_flat_priority_queue_from(                                  \
    private_order, private_compare, private_allocate, private_context_data,    \
    private_optional_capacity, private_compound_literal_array...)              \
    (__extension__({                                                           \
        struct CCC_Flat_priority_queue private_flat_priority_queue = {         \
            .buffer = CCC_buffer_from(private_allocate, private_context_data,  \
                                      private_optional_capacity,               \
                                      private_compound_literal_array),         \
            .order = private_order,                                            \
            .compare = private_compare,                                        \
        };                                                                     \
        if (private_flat_priority_queue.buffer.count)                          \
        {                                                                      \
            CCC_private_flat_priority_queue_in_place_heapify(                  \
                &private_flat_priority_queue,                                  \
                private_flat_priority_queue.buffer.count,                      \
                &(typeof(*private_compound_literal_array)){0});                \
        }                                                                      \
        private_flat_priority_queue;                                           \
    }))
 
#define CCC_private_flat_priority_queue_with_capacity(                         \
    private_type_name, private_order, private_compare, private_allocate,       \
    private_context_data, private_capacity)                                    \
    (__extension__({                                                           \
        struct CCC_Flat_priority_queue private_flat_priority_queue = {         \
            .buffer = CCC_buffer_with_capacity(                                \
                private_type_name, private_allocate, private_context_data,     \
                private_capacity),                                             \
            .order = (private_order),                                          \
            .compare = (private_compare),                                      \
        };                                                                     \
        private_flat_priority_queue;                                           \
    }))
 
#define CCC_private_flat_priority_queue_with_compound_literal(                 \
    private_order, private_compare, private_compound_literal)                  \
    {                                                                          \
        .buffer                                                                \
        = CCC_buffer_with_compound_literal(0, private_compound_literal),       \
        .order = (private_order),                                              \
        .compare = (private_compare),                                          \
    }
 
#define CCC_private_flat_priority_queue_with_context_compound_literal(         \
    private_order, private_compare, private_context, private_compound_literal) \
    {                                                                          \
        .buffer = CCC_buffer_with_context_compound_literal(                    \
            private_context, 0, private_compound_literal),                     \
        .order = (private_order),                                              \
        .compare = (private_compare),                                          \
    }
 
#define CCC_private_flat_priority_queue_emplace(flat_priority_queue,           \
                                                type_compound_literal...)      \
    (__extension__({                                                           \
        struct CCC_Flat_priority_queue *private_flat_priority_queue            \
            = (flat_priority_queue);                                           \
        typeof(type_compound_literal) *private_flat_priority_queue_res         \
            = CCC_buffer_allocate_back(&private_flat_priority_queue->buffer);  \
        if (private_flat_priority_queue_res)                                   \
        {                                                                      \
            *private_flat_priority_queue_res = type_compound_literal;          \
            if (private_flat_priority_queue->buffer.count > 1)                 \
            {                                                                  \
                private_flat_priority_queue_res = CCC_buffer_at(               \
                    &private_flat_priority_queue->buffer,                      \
                    CCC_private_flat_priority_queue_bubble_up(                 \
                        private_flat_priority_queue,                           \
                        &(typeof(type_compound_literal)){0},                   \
                        private_flat_priority_queue->buffer.count - 1));       \
            }                                                                  \
            else                                                               \
            {                                                                  \
                private_flat_priority_queue_res                                \
                    = CCC_buffer_at(&private_flat_priority_queue->buffer, 0);  \
            }                                                                  \
        }                                                                      \
        private_flat_priority_queue_res;                                       \
    }))
 
#define CCC_private_flat_priority_queue_update_with(                           \
    flat_priority_queue_pointer, T_pointer, update_closure_over_T...)          \
    (__extension__({                                                           \
        struct CCC_Flat_priority_queue *const private_flat_priority_queue      \
            = (flat_priority_queue_pointer);                                   \
        typeof(*T_pointer) *T = (T_pointer);                                   \
        if (private_flat_priority_queue                                        \
            && !CCC_buffer_is_empty(&private_flat_priority_queue->buffer)      \
            && T)                                                              \
        {                                                                      \
            {update_closure_over_T} T                                          \
                = CCC_private_flat_priority_queue_update_fixup(                \
                    private_flat_priority_queue, T, &(typeof(*T_pointer)){0}); \
        }                                                                      \
        T;                                                                     \
    }))
 
#define CCC_private_flat_priority_queue_increase_with(                         \
    flat_priority_queue_pointer, T_pointer, increase_closure_over_T...)        \
    CCC_private_flat_priority_queue_update_with(                               \
        flat_priority_queue_pointer, T_pointer, increase_closure_over_T)
 
#define CCC_private_flat_priority_queue_decrease_with(                         \
    flat_priority_queue_pointer, T_pointer, decrease_closure_over_T...)        \
    CCC_private_flat_priority_queue_update_with(                               \
        flat_priority_queue_pointer, T_pointer, decrease_closure_over_T)
 
/* NOLINTEND(readability-identifier-naming) */
 
#endif /* CCC_PRIVATE_FLAT_PRIORITY_QUEUE_H */