ccc/priority__queue_8h_source.html

#ifndef CCC_PRIORITY_QUEUE_H

#define CCC_PRIORITY_QUEUE_H


#include <stdbool.h>

#include <stddef.h>

#include "impl/impl_priority_queue.h"

#include "types.h"


typedef struct ccc_pq_ ccc_priority_queue;


typedef struct ccc_pq_elem_ ccc_pq_elem;


#define ccc_pq_init(struct_name, pq_elem_field, pq_order, alloc_fn, cmp_fn,    \

                    aux_data)                                                  \

    ccc_impl_pq_init(struct_name, pq_elem_field, pq_order, alloc_fn, cmp_fn,   \

                     aux_data)


[[nodiscard]] void *ccc_pq_push(ccc_priority_queue *pq, ccc_pq_elem *elem);


#define ccc_pq_emplace(priority_queue_ptr, lazy_value...)                      \

    ccc_impl_pq_emplace(priority_queue_ptr, lazy_value)


ccc_result ccc_pq_pop(ccc_priority_queue *pq);


[[nodiscard]] void *ccc_pq_extract(ccc_priority_queue *pq, ccc_pq_elem *elem);


ccc_result ccc_pq_erase(ccc_priority_queue *pq, ccc_pq_elem *elem);


bool ccc_pq_update(ccc_priority_queue *pq, ccc_pq_elem *elem, ccc_update_fn *fn,

                   void *aux);


#define ccc_pq_update_w(pq_ptr, pq_elem_ptr, update_closure_over_T...)         \

    ccc_impl_pq_update_w(pq_ptr, pq_elem_ptr, update_closure_over_T)


bool ccc_pq_increase(ccc_priority_queue *pq, ccc_pq_elem *elem,

                     ccc_update_fn *fn, void *aux);


#define ccc_pq_increase_w(pq_ptr, pq_elem_ptr, increase_closure_over_T...)     \

    ccc_impl_pq_increase_w(pq_ptr, pq_elem_ptr, increase_closure_over_T)


bool ccc_pq_decrease(ccc_priority_queue *pq, ccc_pq_elem *elem,

                     ccc_update_fn *fn, void *aux);


#define ccc_pq_decrease_w(pq_ptr, pq_elem_ptr, decrease_closure_over_T...)     \

    ccc_impl_pq_decrease_w(pq_ptr, pq_elem_ptr, decrease_closure_over_T)


ccc_result ccc_pq_clear(ccc_priority_queue *pq, ccc_destructor_fn *fn);


[[nodiscard]] void *ccc_pq_front(ccc_priority_queue const *pq);


[[nodiscard]] bool ccc_pq_is_empty(ccc_priority_queue const *pq);


[[nodiscard]] size_t ccc_pq_size(ccc_priority_queue const *pq);


[[nodiscard]] bool ccc_pq_validate(ccc_priority_queue const *pq);


[[nodiscard]] ccc_threeway_cmp ccc_pq_order(ccc_priority_queue const *pq);


#ifdef PRIORITY_QUEUE_USING_NAMESPACE_CCC

typedef ccc_pq_elem pq_elem;

typedef ccc_priority_queue priority_queue;

#    define pq_init(args...) ccc_pq_init(args)

#    define pq_front(args...) ccc_pq_front(args)

#    define pq_push(args...) ccc_pq_push(args)

#    define pq_emplace(args...) ccc_pq_emplace(args)

#    define pq_pop(args...) ccc_pq_pop(args)

#    define pq_extract(args...) ccc_pq_extract(args)

#    define pq_is_empty(args...) ccc_pq_is_empty(args)

#    define pq_size(args...) ccc_pq_size(args)

#    define pq_update(args...) ccc_pq_update(args)

#    define pq_increase(args...) ccc_pq_increase(args)

#    define pq_decrease(args...) ccc_pq_decrease(args)

#    define pq_update_w(args...) ccc_pq_update_w(args)

#    define pq_increase_w(args...) ccc_pq_increase_w(args)

#    define pq_decrease_w(args...) ccc_pq_decrease_w(args)

#    define pq_order(args...) ccc_pq_order(args)

#    define pq_clear(args...) ccc_pq_clear(args)

#    define pq_validate(args...) ccc_pq_validate(args)

#endif /* PRIORITY_QUEUE_USING_NAMESPACE_CCC */


#endif /* CCC_PRIORITY_QUEUE_H */

ccc_pq_push
void * ccc_pq_push(ccc_priority_queue *pq, ccc_pq_elem *elem)
Adds an element to the priority queue in correct total order. O(1).

ccc_pq_extract
void * ccc_pq_extract(ccc_priority_queue *pq, ccc_pq_elem *elem)

ccc_pq_update
bool ccc_pq_update(ccc_priority_queue *pq, ccc_pq_elem *elem, ccc_update_fn *fn, void *aux)
Update the priority in the user type wrapping elem.

ccc_pq_decrease
bool ccc_pq_decrease(ccc_priority_queue *pq, ccc_pq_elem *elem, ccc_update_fn *fn, void *aux)
Decreases the value of the type wrapping elem. O(1) or O(lgN)

ccc_pq_elem
struct ccc_pq_elem_ ccc_pq_elem
The embedded struct type for operation of the priority queue.
Definition: priority_queue.h:49

ccc_pq_is_empty
bool ccc_pq_is_empty(ccc_priority_queue const *pq)
Returns true if the priority queue is empty false if not. O(1).

ccc_pq_erase
ccc_result ccc_pq_erase(ccc_priority_queue *pq, ccc_pq_elem *elem)
Erase elem from the pq. Amortized O(lgN).

ccc_pq_front
void * ccc_pq_front(ccc_priority_queue const *pq)
Obtain a reference to the front of the priority queue. O(1).

ccc_pq_validate
bool ccc_pq_validate(ccc_priority_queue const *pq)
Verifies the internal invariants of the pq hold.

ccc_pq_size
size_t ccc_pq_size(ccc_priority_queue const *pq)
Returns the size of the priority queue.

ccc_pq_clear
ccc_result ccc_pq_clear(ccc_priority_queue *pq, ccc_destructor_fn *fn)
Removes all elements from the pq, freeing if needed.

ccc_pq_order
ccc_threeway_cmp ccc_pq_order(ccc_priority_queue const *pq)
Return the order used to initialize the pq.

ccc_pq_increase
bool ccc_pq_increase(ccc_priority_queue *pq, ccc_pq_elem *elem, ccc_update_fn *fn, void *aux)
Increases the priority of the type wrapping elem. O(1) or O(lgN)

ccc_priority_queue
struct ccc_pq_ ccc_priority_queue
A container for pointer stability and an O(1) push and amortized o(lg N) increase/decrease key.
Definition: priority_queue.h:39

ccc_pq_pop
ccc_result ccc_pq_pop(ccc_priority_queue *pq)
Pops the front element from the priority queue. Amortized O(lgN).

types.h
The C Container Collection Fundamental Types.

ccc_result
ccc_result
A result of actions on containers.
Definition: types.h:65

ccc_update_fn
void ccc_update_fn(ccc_user_type)
A callback function for modifying an element in the container.
Definition: types.h:216

ccc_threeway_cmp
ccc_threeway_cmp
A three-way comparison for comparison functions.
Definition: types.h:84

ccc_destructor_fn
void ccc_destructor_fn(ccc_user_type)
A callback function for destroying an element in the container.
Definition: types.h:234