flat_priority_queue.h

Go to the documentation of this file.

 
#ifndef CCC_FLAT_PRIORITY_QUEUE_H
#define CCC_FLAT_PRIORITY_QUEUE_H
 
#include <stddef.h>
#include "flat_buffer.h"
#include "private/private_flat_priority_queue.h"
#include "types.h"
 
typedef struct CCC_Flat_priority_queue CCC_Flat_priority_queue;
 
#define CCC_flat_priority_queue_default(type_name, order, comparator...)       \
    CCC_private_flat_priority_queue_default(type_name, order, comparator)
 
#define CCC_flat_priority_queue_for(                                           \
    type_name, order, comparator, capacity, data_pointer                       \
)                                                                              \
    CCC_private_flat_priority_queue_for(                                       \
        type_name, order, comparator, capacity, data_pointer                   \
    )
 
#define CCC_flat_priority_queue_heapify(                                       \
    type_name, order, comparator, capacity, count, data_pointer...             \
)                                                                              \
    CCC_private_flat_priority_queue_heapify(                                   \
        type_name, order, comparator, capacity, count, data_pointer            \
    )
 
#define CCC_flat_priority_queue_from(                                          \
    order, comparator, allocator, optional_capacity, compound_literal_array... \
)                                                                              \
    CCC_private_flat_priority_queue_from(                                      \
        order,                                                                 \
        comparator,                                                            \
        allocator,                                                             \
        optional_capacity,                                                     \
        compound_literal_array                                                 \
    )
 
#define CCC_flat_priority_queue_with_capacity(                                 \
    type_name, order, comparator, allocator, capacity                          \
)                                                                              \
    CCC_private_flat_priority_queue_with_capacity(                             \
        type_name, order, comparator, allocator, capacity                      \
    )
 
#define CCC_flat_priority_queue_with_storage(                                  \
    order, comparator, compound_literal_array                                  \
)                                                                              \
    CCC_private_flat_priority_queue_with_storage(                              \
        order, comparator, compound_literal_array                              \
    )
 
CCC_Result CCC_flat_priority_queue_copy(
    CCC_Flat_priority_queue *destination,
    CCC_Flat_priority_queue const *source,
    CCC_Allocator const *allocator
);
 
CCC_Result CCC_flat_priority_queue_reserve(
    CCC_Flat_priority_queue *priority_queue,
    size_t to_add,
    CCC_Allocator const *allocator
);
 
#define CCC_flat_priority_queue_emplace(                                       \
    priority_queue_pointer, allocator_pointer, type_compound_literal...        \
)                                                                              \
    CCC_private_flat_priority_queue_emplace(                                   \
        priority_queue_pointer, allocator_pointer, type_compound_literal       \
    )
 
CCC_Result CCC_flat_priority_queue_copy_heapify(
    CCC_Flat_priority_queue *priority_queue,
    CCC_Flat_buffer const *buffer,
    void *temp,
    CCC_Allocator const *allocator
);
 
CCC_Flat_priority_queue CCC_flat_priority_queue_in_place_heapify(
    CCC_Flat_buffer *buffer,
    void *temp,
    CCC_Order order,
    CCC_Comparator const *comparator
);
 
[[nodiscard]] void *CCC_flat_priority_queue_push(
    CCC_Flat_priority_queue *priority_queue,
    void const *type,
    void *temp,
    CCC_Allocator const *allocator
);
 
CCC_Result CCC_flat_priority_queue_pop(
    CCC_Flat_priority_queue *priority_queue, void *temp
);
 
CCC_Result CCC_flat_priority_queue_erase(
    CCC_Flat_priority_queue *priority_queue, void *type, void *temp
);
 
void *CCC_flat_priority_queue_update(
    CCC_Flat_priority_queue const *priority_queue,
    void *type,
    void *temp,
    CCC_Modifier const *modifier
);
 
#define CCC_flat_priority_queue_update_with(                                   \
    priority_queue_pointer,                                                    \
    closure_parameter,                                                         \
    update_closure_over_closure_parameter...                                   \
)                                                                              \
    CCC_private_flat_priority_queue_update_with(                               \
        priority_queue_pointer,                                                \
        closure_parameter,                                                     \
        update_closure_over_closure_parameter                                  \
    )
 
void *CCC_flat_priority_queue_increase(
    CCC_Flat_priority_queue const *priority_queue,
    void *type,
    void *temp,
    CCC_Modifier const *modifier
);
 
#define CCC_flat_priority_queue_increase_with(                                 \
    priority_queue_pointer,                                                    \
    closure_parameter,                                                         \
    increase_closure_over_closure_parameter...                                 \
)                                                                              \
    CCC_private_flat_priority_queue_increase_with(                             \
        priority_queue_pointer,                                                \
        closure_parameter,                                                     \
        increase_closure_over_closure_parameter                                \
    )
 
void *CCC_flat_priority_queue_decrease(
    CCC_Flat_priority_queue const *priority_queue,
    void *type,
    void *temp,
    CCC_Modifier const *modifier
);
 
#define CCC_flat_priority_queue_decrease_with(                                 \
    priority_queue_pointer,                                                    \
    closure_parameter,                                                         \
    decrease_closure_over_closure_parameter...                                 \
)                                                                              \
    CCC_private_flat_priority_queue_decrease_with(                             \
        priority_queue_pointer,                                                \
        closure_parameter,                                                     \
        decrease_closure_over_closure_parameter                                \
    )
 
CCC_Result CCC_flat_priority_queue_clear(
    CCC_Flat_priority_queue *priority_queue, CCC_Destructor const *destructor
);
 
CCC_Result CCC_flat_priority_queue_clear_and_free(
    CCC_Flat_priority_queue *priority_queue,
    CCC_Destructor const *destructor,
    CCC_Allocator const *allocator
);
 
[[nodiscard]] void *
CCC_flat_priority_queue_front(CCC_Flat_priority_queue const *priority_queue);
 
[[nodiscard]] CCC_Tribool
CCC_flat_priority_queue_is_empty(CCC_Flat_priority_queue const *priority_queue);
 
[[nodiscard]] CCC_Count
CCC_flat_priority_queue_count(CCC_Flat_priority_queue const *priority_queue);
 
[[nodiscard]] CCC_Count
CCC_flat_priority_queue_capacity(CCC_Flat_priority_queue const *priority_queue);
 
[[nodiscard]] void *
CCC_flat_priority_queue_data(CCC_Flat_priority_queue const *priority_queue);
 
[[nodiscard]] CCC_Tribool
CCC_flat_priority_queue_validate(CCC_Flat_priority_queue const *priority_queue);
 
[[nodiscard]] CCC_Order
CCC_flat_priority_queue_order(CCC_Flat_priority_queue const *priority_queue);
 
#ifdef FLAT_PRIORITY_QUEUE_USING_NAMESPACE_CCC
/* NOLINTBEGIN(readability-identifier-naming) */
typedef CCC_Flat_priority_queue Flat_priority_queue;
#    define flat_priority_queue_default(arguments...)                          \
        CCC_flat_priority_queue_default(arguments)
#    define flat_priority_queue_for(arguments...)                              \
        CCC_flat_priority_queue_for(arguments)
#    define flat_priority_queue_from(arguments...)                             \
        CCC_flat_priority_queue_from(arguments)
#    define flat_priority_queue_with_capacity(arguments...)                    \
        CCC_flat_priority_queue_with_capacity(arguments)
#    define flat_priority_queue_with_storage(arguments...)                     \
        CCC_flat_priority_queue_with_storage(arguments)
#    define flat_priority_queue_heapify(arguments...)                          \
        CCC_flat_priority_queue_heapify(arguments)
#    define flat_priority_queue_copy(arguments...)                             \
        CCC_flat_priority_queue_copy(arguments)
#    define flat_priority_queue_reserve(arguments...)                          \
        CCC_flat_priority_queue_reserve(arguments)
#    define flat_priority_queue_copy_heapify(arguments...)                     \
        CCC_flat_priority_queue_copy_heapify(arguments)
#    define flat_priority_queue_in_place_heapify(arguments...)                 \
        CCC_flat_priority_queue_in_place_heapify(arguments)
#    define flat_priority_queue_emplace(arguments...)                          \
        CCC_flat_priority_queue_emplace(arguments)
#    define flat_priority_queue_push(arguments...)                             \
        CCC_flat_priority_queue_push(arguments)
#    define flat_priority_queue_front(arguments...)                            \
        CCC_flat_priority_queue_front(arguments)
#    define flat_priority_queue_pop(arguments...)                              \
        CCC_flat_priority_queue_pop(arguments)
#    define flat_priority_queue_extract(arguments...)                          \
        CCC_flat_priority_queue_extract(arguments)
#    define flat_priority_queue_update(arguments...)                           \
        CCC_flat_priority_queue_update(arguments)
#    define flat_priority_queue_increase(arguments...)                         \
        CCC_flat_priority_queue_increase(arguments)
#    define flat_priority_queue_decrease(arguments...)                         \
        CCC_flat_priority_queue_decrease(arguments)
#    define flat_priority_queue_update_with(arguments...)                      \
        CCC_flat_priority_queue_update_with(arguments)
#    define flat_priority_queue_increase_with(arguments...)                    \
        CCC_flat_priority_queue_increase_with(arguments)
#    define flat_priority_queue_decrease_with(arguments...)                    \
        CCC_flat_priority_queue_decrease_with(arguments)
#    define flat_priority_queue_clear(arguments...)                            \
        CCC_flat_priority_queue_clear(arguments)
#    define flat_priority_queue_clear_and_free(arguments...)                   \
        CCC_flat_priority_queue_clear_and_free(arguments)
#    define flat_priority_queue_is_empty(arguments...)                         \
        CCC_flat_priority_queue_is_empty(arguments)
#    define flat_priority_queue_count(arguments...)                            \
        CCC_flat_priority_queue_count(arguments)
#    define flat_priority_queue_capacity(arguments...)                         \
        CCC_flat_priority_queue_capacity(arguments)
#    define flat_priority_queue_data(arguments...)                             \
        CCC_flat_priority_queue_data(arguments)
#    define flat_priority_queue_validate(arguments...)                         \
        CCC_flat_priority_queue_validate(arguments)
#    define flat_priority_queue_order(arguments...)                            \
        CCC_flat_priority_queue_order(arguments)
/* NOLINTEND(readability-identifier-naming) */
#endif /* FLAT_PRIORITY_QUEUE_USING_NAMESPACE_CCC */
 
#endif /* CCC_FLAT_PRIORITY_QUEUE_H */