private_priority_queue.h

Go to the documentation of this file.

 
#ifndef CCC_PRIVATE_PRIORITY_QUEUE_H
#define CCC_PRIVATE_PRIORITY_QUEUE_H
 
#include <stddef.h>
#include "../../types.h" /* IWYU pragma: keep */
 
/* NOLINTBEGIN(readability-identifier-naming) */
 
struct CCC_Priority_queue_node {
    struct CCC_Priority_queue_node *child;
    struct CCC_Priority_queue_node *next;
    struct CCC_Priority_queue_node *prev;
    struct CCC_Priority_queue_node *parent;
};
 
struct CCC_Priority_queue {
    struct CCC_Priority_queue_node *root;
    size_t count;
    size_t type_intruder_offset;
    size_t sizeof_type;
    size_t alignof_type;
    CCC_Order order;
    CCC_Comparator comparator;
};
 
/*=========================  Private Interface     ==========================*/
 
void CCC_private_priority_queue_push(
    struct CCC_Priority_queue *, struct CCC_Priority_queue_node *
);
struct CCC_Priority_queue_node *CCC_private_priority_queue_node_in(
    struct CCC_Priority_queue const *, void const *
);
void CCC_private_priority_queue_update_fixup(
    struct CCC_Priority_queue *, struct CCC_Priority_queue_node *
);
void CCC_private_priority_queue_increase_fixup(
    struct CCC_Priority_queue *, struct CCC_Priority_queue_node *
);
void CCC_private_priority_queue_decrease_fixup(
    struct CCC_Priority_queue *, struct CCC_Priority_queue_node *
);
 
/*=========================  Macro Implementations     ======================*/
 
#define CCC_private_priority_queue_for(                                        \
    private_struct_name,                                                       \
    private_type_intruder_field,                                               \
    private_priority_queue_order,                                              \
    private_comparator...                                                      \
)                                                                              \
    (struct CCC_Priority_queue) {                                              \
        .root = NULL, .count = 0,                                              \
        .type_intruder_offset                                                  \
            = offsetof(private_struct_name, private_type_intruder_field),      \
        .sizeof_type = sizeof(private_struct_name),                            \
        .alignof_type = alignof(private_struct_name),                          \
        .order = (private_priority_queue_order),                               \
        .comparator = (private_comparator),                                    \
    }
 
#define CCC_private_priority_queue_default(                                    \
    private_struct_name,                                                       \
    private_type_intruder_field,                                               \
    private_priority_queue_order,                                              \
    private_comparator                                                         \
)                                                                              \
    CCC_private_priority_queue_for(                                            \
        private_struct_name,                                                   \
        private_type_intruder_field,                                           \
        private_priority_queue_order,                                          \
        private_comparator                                                     \
    )
 
#define CCC_private_priority_queue_from(                                       \
    private_type_intruder_field,                                               \
    private_priority_queue_order,                                              \
    private_comparator,                                                        \
    private_allocator,                                                         \
    private_destructor,                                                        \
    private_compound_literal_array...                                          \
)                                                                              \
    (struct { struct CCC_Priority_queue private; }){(__extension__({           \
        typeof(*private_compound_literal_array)                                \
            *private_priority_queue_type_array                                 \
            = private_compound_literal_array;                                  \
        struct CCC_Priority_queue private_priority_queue                       \
            = CCC_private_priority_queue_for(                                  \
                typeof(*private_priority_queue_type_array),                    \
                private_type_intruder_field,                                   \
                private_priority_queue_order,                                  \
                private_comparator                                             \
            );                                                                 \
        CCC_Allocator const *const private_priority_queue_allocator            \
            = &(private_allocator);                                            \
        if (private_priority_queue_allocator->allocate) {                      \
            size_t const private_count                                         \
                = sizeof(private_compound_literal_array)                       \
                / sizeof(*private_priority_queue_type_array);                  \
            for (size_t private_i = 0; private_i < private_count;              \
                 ++private_i) {                                                \
                typeof(*private_priority_queue_type_array) *const              \
                    private_new_node                                           \
                    = private_priority_queue_allocator->allocate((             \
                        CCC_Allocator_arguments                                \
                    ){                                                         \
                        .input = NULL,                                         \
                        .bytes = private_priority_queue.sizeof_type,           \
                        .alignment = private_priority_queue.alignof_type,      \
                        .context = private_priority_queue_allocator->context,  \
                    });                                                        \
                if (!private_new_node) {                                       \
                    CCC_priority_queue_clear(                                  \
                        &private_priority_queue,                               \
                        &private_destructor,                                   \
                        private_priority_queue_allocator                       \
                    );                                                         \
                    break;                                                     \
                }                                                              \
                *private_new_node                                              \
                    = private_priority_queue_type_array[private_i];            \
                CCC_private_priority_queue_push(                               \
                    &private_priority_queue,                                   \
                    CCC_private_priority_queue_node_in(                        \
                        &private_priority_queue, private_new_node              \
                    )                                                          \
                );                                                             \
            }                                                                  \
        }                                                                      \
        private_priority_queue;                                                \
    }))}.private
 
#define CCC_private_priority_queue_emplace(                                    \
    priority_queue_pointer,                                                    \
    private_allocator_pointer,                                                 \
    type_compound_literal...                                                   \
)                                                                              \
    (__extension__({                                                           \
        typeof(type_compound_literal) *private_priority_queue_res = NULL;      \
        struct CCC_Priority_queue *private_priority_queue                      \
            = (priority_queue_pointer);                                        \
        if (private_priority_queue) {                                          \
            CCC_Allocator const *const private_priority_queue_allocator        \
                = (private_allocator_pointer);                                 \
            if (!private_priority_queue_allocator                              \
                || private_priority_queue_allocator->allocate) {               \
                private_priority_queue_res = NULL;                             \
            } else {                                                           \
                private_priority_queue_res                                     \
                    = private_priority_queue_allocator->allocate((             \
                        CCC_Allocator_arguments                                \
                    ){                                                         \
                        .input = NULL,                                         \
                        .bytes = private_priority_queue->sizeof_type,          \
                        .alignment = private_priority_queue->alignof_type,     \
                        .context = private_priority_queue_allocator->context,  \
                    });                                                        \
                if (private_priority_queue_res) {                              \
                    *private_priority_queue_res = type_compound_literal;       \
                    CCC_private_priority_queue_push(                           \
                        private_priority_queue,                                \
                        CCC_private_priority_queue_node_in(                    \
                            private_priority_queue, private_priority_queue_res \
                        )                                                      \
                    );                                                         \
                }                                                              \
            }                                                                  \
        }                                                                      \
        private_priority_queue_res;                                            \
    }))
 
#define CCC_private_priority_queue_update_with(                                \
    priority_queue_pointer,                                                    \
    private_closure_parameter,                                                 \
    private_update_closure_over_closure_parameter...                           \
)                                                                              \
    (__extension__({                                                           \
        struct CCC_Priority_queue *const private_priority_queue                \
            = (priority_queue_pointer);                                        \
        typeof(*private_closure_parameter)                                     \
            *private_priority_queue_updated_element                            \
            = (private_closure_parameter);                                     \
        if (private_priority_queue                                             \
            && private_priority_queue_updated_element) {                       \
            struct CCC_Priority_queue_node *const                              \
                private_priority_queue_node_pointer                            \
                = CCC_private_priority_queue_node_in(                          \
                    private_priority_queue,                                    \
                    private_priority_queue_updated_element                     \
                );                                                             \
            {private_update_closure_over_closure_parameter};                   \
            CCC_private_priority_queue_update_fixup(                           \
                private_priority_queue, private_priority_queue_node_pointer    \
            );                                                                 \
        }                                                                      \
        private_priority_queue_updated_element;                                \
    }))
 
#define CCC_private_priority_queue_increase_with(                              \
    priority_queue_pointer,                                                    \
    private_closure_parameter,                                                 \
    private_increase_closure_over_closure_parameter...                         \
)                                                                              \
    (__extension__({                                                           \
        struct CCC_Priority_queue *const private_priority_queue                \
            = (priority_queue_pointer);                                        \
        typeof(*private_closure_parameter)                                     \
            *private_priority_queue_updated_element                            \
            = (private_closure_parameter);                                     \
        if (private_priority_queue                                             \
            && private_priority_queue_updated_element) {                       \
            struct CCC_Priority_queue_node *const                              \
                private_priority_queue_node_pointer                            \
                = CCC_private_priority_queue_node_in(                          \
                    private_priority_queue,                                    \
                    private_priority_queue_updated_element                     \
                );                                                             \
            {private_increase_closure_over_closure_parameter};                 \
            CCC_private_priority_queue_increase_fixup(                         \
                private_priority_queue, private_priority_queue_node_pointer    \
            );                                                                 \
        }                                                                      \
        private_priority_queue_updated_element;                                \
    }))
 
#define CCC_private_priority_queue_decrease_with(                              \
    priority_queue_pointer,                                                    \
    private_closure_parameter,                                                 \
    private_decrease_closure_over_closure_parameter...                         \
)                                                                              \
    (__extension__({                                                           \
        struct CCC_Priority_queue *const private_priority_queue                \
            = (priority_queue_pointer);                                        \
        typeof(*private_closure_parameter)                                     \
            *private_priority_queue_updated_element                            \
            = (private_closure_parameter);                                     \
        if (private_priority_queue                                             \
            && private_priority_queue_updated_element) {                       \
            struct CCC_Priority_queue_node *const                              \
                private_priority_queue_node_pointer                            \
                = CCC_private_priority_queue_node_in(                          \
                    private_priority_queue,                                    \
                    private_priority_queue_updated_element                     \
                );                                                             \
            {private_decrease_closure_over_closure_parameter};                 \
            CCC_private_priority_queue_decrease_fixup(                         \
                private_priority_queue, private_priority_queue_node_pointer    \
            );                                                                 \
        }                                                                      \
        private_priority_queue_updated_element;                                \
    }))
 
/* NOLINTEND(readability-identifier-naming) */
 
#endif /* CCC_PRIVATE_PRIORITY_QUEUE_H */