C Container Collection (CCC)
Loading...
Searching...
No Matches
private_flat_priority_queue.h
1
16#ifndef CCC_PRIVATE_FLAT_PRIORITY_QUEUE_H
17#define CCC_PRIVATE_FLAT_PRIORITY_QUEUE_H
18
20#include <assert.h>
21#include <stddef.h>
24#include "../buffer.h"
25#include "../types.h"
26
27/* NOLINTBEGIN(readability-identifier-naming) */
28
35struct CCC_Flat_priority_queue
36{
38 CCC_Buffer buffer;
41 CCC_Order order;
43 CCC_Type_comparator *compare;
44};
45
46/*======================== Private Interface =========================*/
47
49size_t
50CCC_private_flat_priority_queue_bubble_up(struct CCC_Flat_priority_queue *,
51 void *, size_t);
53void CCC_private_flat_priority_queue_in_place_heapify(
54 struct CCC_Flat_priority_queue *, size_t, void *);
56void *
57CCC_private_flat_priority_queue_update_fixup(struct CCC_Flat_priority_queue *,
58 void *, void *);
59
60/*====================== Macro Implementations ========================*/
61
63#define CCC_private_flat_priority_queue_initialize( \
64 private_type_name, private_order, private_compare, private_allocate, \
65 private_context_data, private_capacity, private_data_pointer) \
66 { \
67 .buffer = CCC_buffer_initialize( \
68 private_type_name, private_allocate, private_context_data, \
69 private_capacity, 0, private_data_pointer), \
70 .order = (private_order), \
71 .compare = (private_compare), \
72 }
73
75#define CCC_private_flat_priority_queue_heapify_initialize( \
76 private_type_name, private_order, private_compare, private_allocate, \
77 private_context_data, private_capacity, private_size, \
78 private_data_pointer) \
79 (__extension__({ \
80 typeof(*( \
81 private_data_pointer)) *private_flat_priority_queue_heapify_data \
82 = (private_data_pointer); \
83 struct CCC_Flat_priority_queue private_flat_priority_queue_heapify_res \
84 = CCC_private_flat_priority_queue_initialize( \
85 private_type_name, private_order, private_compare, \
86 private_allocate, private_context_data, private_capacity, \
87 private_flat_priority_queue_heapify_data); \
88 CCC_private_flat_priority_queue_in_place_heapify( \
89 &private_flat_priority_queue_heapify_res, (private_size), \
90 &(private_type_name){0}); \
91 private_flat_priority_queue_heapify_res; \
92 }))
93
95#define CCC_private_flat_priority_queue_from( \
96 private_order, private_compare, private_allocate, private_context_data, \
97 private_optional_capacity, private_compound_literal_array...) \
98 (__extension__({ \
99 struct CCC_Flat_priority_queue private_flat_priority_queue = { \
100 .buffer = CCC_buffer_from(private_allocate, private_context_data, \
101 private_optional_capacity, \
102 private_compound_literal_array), \
103 .order = private_order, \
104 .compare = private_compare, \
105 }; \
106 if (private_flat_priority_queue.buffer.count) \
107 { \
108 CCC_private_flat_priority_queue_in_place_heapify( \
109 &private_flat_priority_queue, \
110 private_flat_priority_queue.buffer.count, \
111 &(typeof(*private_compound_literal_array)){0}); \
112 } \
113 private_flat_priority_queue; \
114 }))
115
117#define CCC_private_flat_priority_queue_with_capacity( \
118 private_type_name, private_order, private_compare, private_allocate, \
119 private_context_data, private_capacity) \
120 (__extension__({ \
121 struct CCC_Flat_priority_queue private_flat_priority_queue = { \
122 .buffer = CCC_buffer_with_capacity( \
123 private_type_name, private_allocate, private_context_data, \
124 private_capacity), \
125 .order = (private_order), \
126 .compare = (private_compare), \
127 }; \
128 private_flat_priority_queue; \
129 }))
130
132#define CCC_private_flat_priority_queue_with_compound_literal( \
133 private_order, private_compare, private_compound_literal) \
134 { \
135 .buffer \
136 = CCC_buffer_with_compound_literal(0, private_compound_literal), \
137 .order = (private_order), \
138 .compare = (private_compare), \
139 }
140
142#define CCC_private_flat_priority_queue_with_context_compound_literal( \
143 private_order, private_compare, private_context, private_compound_literal) \
144 { \
145 .buffer = CCC_buffer_with_context_compound_literal( \
146 private_context, 0, private_compound_literal), \
147 .order = (private_order), \
148 .compare = (private_compare), \
149 }
150
152#define CCC_private_flat_priority_queue_with_allocator( \
153 private_type_name, private_order, private_compare, private_allocate) \
154 { \
155 .buffer \
156 = CCC_buffer_with_allocator(private_type_name, private_allocate), \
157 .order = (private_order), \
158 .compare = (private_compare), \
159 }
160
162#define CCC_private_flat_priority_queue_with_context_allocator( \
163 private_type_name, private_order, private_compare, private_allocate, \
164 private_context) \
165 { \
166 .buffer = CCC_buffer_with_context_allocator( \
167 private_type_name, private_allocate, private_context), \
168 .order = (private_order), \
169 .compare = (private_compare), \
170 }
171
175#define CCC_private_flat_priority_queue_emplace(flat_priority_queue, \
176 type_compound_literal...) \
177 (__extension__({ \
178 struct CCC_Flat_priority_queue *private_flat_priority_queue \
179 = (flat_priority_queue); \
180 typeof(type_compound_literal) *private_flat_priority_queue_res \
181 = CCC_buffer_allocate_back(&private_flat_priority_queue->buffer); \
182 if (private_flat_priority_queue_res) \
183 { \
184 *private_flat_priority_queue_res = type_compound_literal; \
185 if (private_flat_priority_queue->buffer.count > 1) \
186 { \
187 private_flat_priority_queue_res = CCC_buffer_at( \
188 &private_flat_priority_queue->buffer, \
189 CCC_private_flat_priority_queue_bubble_up( \
190 private_flat_priority_queue, \
191 &(typeof(type_compound_literal)){0}, \
192 private_flat_priority_queue->buffer.count - 1)); \
193 } \
194 else \
195 { \
196 private_flat_priority_queue_res \
197 = CCC_buffer_at(&private_flat_priority_queue->buffer, 0); \
198 } \
199 } \
200 private_flat_priority_queue_res; \
201 }))
202
205#define CCC_private_flat_priority_queue_update_with( \
206 flat_priority_queue_pointer, T_pointer, update_closure_over_T...) \
207 (__extension__({ \
208 struct CCC_Flat_priority_queue *const private_flat_priority_queue \
209 = (flat_priority_queue_pointer); \
210 typeof(*T_pointer) *T = (T_pointer); \
211 if (private_flat_priority_queue \
212 && !CCC_buffer_is_empty(&private_flat_priority_queue->buffer) \
213 && T) \
214 { \
215 {update_closure_over_T} T \
216 = CCC_private_flat_priority_queue_update_fixup( \
217 private_flat_priority_queue, T, &(typeof(*T_pointer)){0}); \
218 } \
219 T; \
220 }))
221
223#define CCC_private_flat_priority_queue_increase_with( \
224 flat_priority_queue_pointer, T_pointer, increase_closure_over_T...) \
225 CCC_private_flat_priority_queue_update_with( \
226 flat_priority_queue_pointer, T_pointer, increase_closure_over_T)
227
229#define CCC_private_flat_priority_queue_decrease_with( \
230 flat_priority_queue_pointer, T_pointer, decrease_closure_over_T...) \
231 CCC_private_flat_priority_queue_update_with( \
232 flat_priority_queue_pointer, T_pointer, decrease_closure_over_T)
233
234/* NOLINTEND(readability-identifier-naming) */
235
236#endif /* CCC_PRIVATE_FLAT_PRIORITY_QUEUE_H */
CCC_Buffer
Definition: private_buffer.h:34
CCC_Flat_priority_queue
Definition: private_flat_priority_queue.h:36
CCC_Flat_priority_queue::compare
CCC_Type_comparator * compare
Definition: private_flat_priority_queue.h:43
CCC_Flat_priority_queue::buffer
CCC_Buffer buffer
Definition: private_flat_priority_queue.h:38
CCC_Flat_priority_queue::order
CCC_Order order
Definition: private_flat_priority_queue.h:41
CCC_Order
CCC_Order
A three-way comparison for comparison functions.
Definition: types.h:171
CCC_Type_comparator
CCC_Order CCC_Type_comparator(CCC_Type_comparator_context)
A callback function for comparing two elements in a container.
Definition: types.h:348