private_flat_priority_queue.h

 
#ifndef CCC_PRIVATE_FLAT_PRIORITY_QUEUE_H
#define CCC_PRIVATE_FLAT_PRIORITY_QUEUE_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_Comparator comparator;
};
 
/*========================    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_heap_order(
    struct CCC_Flat_priority_queue *, void *
);
void *CCC_private_flat_priority_queue_update_fixup(
    struct CCC_Flat_priority_queue *, void *, void *
);
 
/*======================    Macro Implementations    ========================*/
 
#define CCC_private_flat_priority_queue_default(                               \
    private_type_name, private_order, private_comparator...                    \
)                                                                              \
    (struct CCC_Flat_priority_queue) {                                         \
        .buffer = CCC_buffer_default(private_type_name),                       \
        .order = (private_order), .comparator = private_comparator,            \
    }
 
#define CCC_private_flat_priority_queue_for(                                   \
    private_type_name,                                                         \
    private_order,                                                             \
    private_comparator,                                                        \
    private_capacity,                                                          \
    private_data_pointer                                                       \
)                                                                              \
    (struct CCC_Flat_priority_queue) {                                         \
        .buffer = CCC_buffer_for(                                              \
            private_type_name, private_capacity, 0, private_data_pointer       \
        ),                                                                     \
        .order = (private_order), .comparator = (private_comparator),          \
    }
 
#define CCC_private_flat_priority_queue_heapify(                               \
    private_type_name,                                                         \
    private_order,                                                             \
    private_comparator,                                                        \
    private_capacity,                                                          \
    private_size,                                                              \
    private_data_pointer...                                                    \
)                                                                              \
    (struct { struct CCC_Flat_priority_queue private; }){(__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_for(                             \
                private_type_name,                                             \
                private_order,                                                 \
                private_comparator,                                            \
                private_capacity,                                              \
                private_flat_priority_queue_heapify_data                       \
            );                                                                 \
        private_flat_priority_queue_heapify_res.buffer.count = (private_size); \
        CCC_private_flat_priority_queue_heap_order(                            \
            &private_flat_priority_queue_heapify_res, &(private_type_name){}   \
        );                                                                     \
        private_flat_priority_queue_heapify_res;                               \
    }))}.private
 
#define CCC_private_flat_priority_queue_from(                                  \
    private_order,                                                             \
    private_comparator,                                                        \
    private_allocator,                                                         \
    private_optional_capacity,                                                 \
    private_compound_literal_array...                                          \
)                                                                              \
    (struct { struct CCC_Flat_priority_queue private; }){(__extension__({      \
        struct CCC_Flat_priority_queue private_flat_priority_queue = {         \
            .buffer = CCC_buffer_from(                                         \
                private_allocator,                                             \
                private_optional_capacity,                                     \
                private_compound_literal_array                                 \
            ),                                                                 \
            .order = (private_order),                                          \
            .comparator = (private_comparator),                                \
        };                                                                     \
        if (private_flat_priority_queue.buffer.count) {                        \
            CCC_private_flat_priority_queue_heap_order(                        \
                &private_flat_priority_queue,                                  \
                &(typeof(*private_compound_literal_array)){}                   \
            );                                                                 \
        }                                                                      \
        private_flat_priority_queue;                                           \
    }))}.private
 
#define CCC_private_flat_priority_queue_with_capacity(                         \
    private_type_name,                                                         \
    private_order,                                                             \
    private_comparator,                                                        \
    private_allocator,                                                         \
    private_capacity                                                           \
)                                                                              \
    (struct { struct CCC_Flat_priority_queue private; }){(__extension__({      \
        struct CCC_Flat_priority_queue private_flat_priority_queue = {         \
            .buffer = CCC_buffer_with_capacity(                                \
                private_type_name, private_allocator, private_capacity         \
            ),                                                                 \
            .order = (private_order),                                          \
            .comparator = (private_comparator),                                \
        };                                                                     \
        private_flat_priority_queue;                                           \
    }))}.private
 
#if defined(__clang__) || defined(__llvm__)
#    define CCC_private_flat_priority_queue_with_storage(                      \
        private_order, private_comparator, private_compound_literal            \
    )                                                                          \
        (struct {                                                              \
            static_assert(                                                     \
                (private_order) == CCC_ORDER_LESSER                            \
                    || (private_order) == CCC_ORDER_GREATER,                   \
                "flat priority queue must be a min or max priority queue"      \
            );                                                                 \
            struct CCC_Flat_priority_queue private;                            \
        }){{                                                                   \
               .buffer = CCC_buffer_with_storage(0, private_compound_literal), \
               .order = (private_order),                                       \
               .comparator = (private_comparator),                             \
           }}                                                                  \
            .private
#else
#    define CCC_private_flat_priority_queue_with_storage(                      \
        private_order, private_comparator, private_compound_literal            \
    )                                                                          \
        (struct CCC_Flat_priority_queue) {                                     \
            .buffer = CCC_buffer_with_storage(0, private_compound_literal),    \
            .order = (private_order), .comparator = (private_comparator),      \
        }
#endif
 
#define CCC_private_flat_priority_queue_emplace(                               \
    flat_priority_queue, private_allocator_pointer, 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,                          \
                private_allocator_pointer                                      \
            );                                                                 \
        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)){},                    \
                        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,                                               \
    closure_parameter,                                                         \
    update_closure_over_closure_parameter...                                   \
)                                                                              \
    (__extension__({                                                           \
        struct CCC_Flat_priority_queue *const private_flat_priority_queue      \
            = (flat_priority_queue_pointer);                                   \
        typeof(*closure_parameter) *                                           \
            private_flat_priority_queue_updated_element = (closure_parameter); \
        if (private_flat_priority_queue                                        \
            && !CCC_buffer_is_empty(&private_flat_priority_queue->buffer)) {   \
            {update_closure_over_closure_parameter};                           \
            private_flat_priority_queue_updated_element                        \
                = CCC_private_flat_priority_queue_update_fixup(                \
                    private_flat_priority_queue,                               \
                    private_flat_priority_queue_updated_element,               \
                    &(typeof(*closure_parameter)){}                            \
                );                                                             \
        }                                                                      \
        private_flat_priority_queue_updated_element;                           \
    }))
 
#define CCC_private_flat_priority_queue_increase_with(                         \
    flat_priority_queue_pointer,                                               \
    closure_parameter,                                                         \
    increase_closure_over_closure_parameter...                                 \
)                                                                              \
    CCC_private_flat_priority_queue_update_with(                               \
        flat_priority_queue_pointer,                                           \
        closure_parameter,                                                     \
        increase_closure_over_closure_parameter                                \
    )
 
#define CCC_private_flat_priority_queue_decrease_with(                         \
    flat_priority_queue_pointer,                                               \
    closure_parameter,                                                         \
    decrease_closure_over_closure_parameter...                                 \
)                                                                              \
    CCC_private_flat_priority_queue_update_with(                               \
        flat_priority_queue_pointer,                                           \
        closure_parameter,                                                     \
        decrease_closure_over_closure_parameter                                \
    )
 
/* NOLINTEND(readability-identifier-naming) */
 
#endif /* CCC_PRIVATE_FLAT_PRIORITY_QUEUE_H */