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 <stddef.h>
23#include "../flat_buffer.h"
24#include "../types.h"
25
26/* NOLINTBEGIN(readability-identifier-naming) */
27
34struct CCC_Flat_priority_queue {
37 CCC_Flat_buffer buffer;
40 CCC_Order order;
42 CCC_Comparator comparator;
43};
44
45/*======================== Private Interface =========================*/
46
48size_t CCC_private_flat_priority_queue_bubble_up(
49 struct CCC_Flat_priority_queue const *, void *, size_t
50);
52void CCC_private_flat_priority_queue_heap_order(
53 struct CCC_Flat_priority_queue const *, void *
54);
56void *CCC_private_flat_priority_queue_update_fixup(
57 struct CCC_Flat_priority_queue const *, void *, void *
58);
59
60/*====================== Macro Implementations ========================*/
61
63#define CCC_private_flat_priority_queue_default( \
64 private_type_name, private_order, private_comparator... \
65) \
66 (struct CCC_Flat_priority_queue) { \
67 .buffer = CCC_flat_buffer_default(private_type_name), \
68 .order = (private_order), .comparator = private_comparator, \
69 }
70
72#define CCC_private_flat_priority_queue_for( \
73 private_type_name, \
74 private_order, \
75 private_comparator, \
76 private_capacity, \
77 private_data_pointer \
78) \
79 (struct CCC_Flat_priority_queue) { \
80 .buffer = CCC_flat_buffer_for( \
81 private_type_name, private_capacity, 0, private_data_pointer \
82 ), \
83 .order = (private_order), .comparator = (private_comparator), \
84 }
85
87#define CCC_private_flat_priority_queue_heapify( \
88 private_type_name, \
89 private_order, \
90 private_comparator, \
91 private_capacity, \
92 private_size, \
93 private_data_pointer... \
94) \
95 (struct { struct CCC_Flat_priority_queue private; }){(__extension__({ \
96 typeof(*( \
97 private_data_pointer \
98 )) *private_flat_priority_queue_heapify_data = private_data_pointer; \
99 struct CCC_Flat_priority_queue private_flat_priority_queue_heapify_res \
100 = CCC_private_flat_priority_queue_for( \
101 private_type_name, \
102 private_order, \
103 private_comparator, \
104 private_capacity, \
105 private_flat_priority_queue_heapify_data \
106 ); \
107 private_flat_priority_queue_heapify_res.buffer.count = (private_size); \
108 CCC_private_flat_priority_queue_heap_order( \
109 &private_flat_priority_queue_heapify_res, &(private_type_name){} \
110 ); \
111 private_flat_priority_queue_heapify_res; \
112 }))}.private
113
115#define CCC_private_flat_priority_queue_from( \
116 private_order, \
117 private_comparator, \
118 private_allocator, \
119 private_optional_capacity, \
120 private_compound_literal_array... \
121) \
122 (struct { struct CCC_Flat_priority_queue private; }){(__extension__({ \
123 struct CCC_Flat_priority_queue private_flat_priority_queue = { \
124 .buffer = CCC_flat_buffer_from( \
125 private_allocator, \
126 private_optional_capacity, \
127 private_compound_literal_array \
128 ), \
129 .order = (private_order), \
130 .comparator = (private_comparator), \
131 }; \
132 if (private_flat_priority_queue.buffer.count) { \
133 CCC_private_flat_priority_queue_heap_order( \
134 &private_flat_priority_queue, \
135 &(typeof(*private_compound_literal_array)){} \
136 ); \
137 } \
138 private_flat_priority_queue; \
139 }))}.private
140
142#define CCC_private_flat_priority_queue_with_capacity( \
143 private_type_name, \
144 private_order, \
145 private_comparator, \
146 private_allocator, \
147 private_capacity \
148) \
149 (struct { struct CCC_Flat_priority_queue private; }){(__extension__({ \
150 struct CCC_Flat_priority_queue private_flat_priority_queue = { \
151 .buffer = CCC_flat_buffer_with_capacity( \
152 private_type_name, private_allocator, private_capacity \
153 ), \
154 .order = (private_order), \
155 .comparator = (private_comparator), \
156 }; \
157 private_flat_priority_queue; \
158 }))}.private
159
164#if defined(__clang__) || defined(__llvm__)
165# define CCC_private_flat_priority_queue_with_storage( \
166 private_order, private_comparator, private_compound_literal \
167 ) \
168 (struct { \
169 static_assert( \
170 (private_order) == CCC_ORDER_LESSER \
171 || (private_order) == CCC_ORDER_GREATER, \
172 "flat priority queue must be a min or max priority queue" \
173 ); \
174 struct CCC_Flat_priority_queue private; \
175 }){{ \
176 .buffer \
177 = CCC_flat_buffer_with_storage(0, private_compound_literal), \
178 .order = (private_order), \
179 .comparator = (private_comparator), \
180 }} \
181 .private
182#else
184# define CCC_private_flat_priority_queue_with_storage( \
185 private_order, private_comparator, private_compound_literal \
186 ) \
187 (struct CCC_Flat_priority_queue) { \
188 .buffer \
189 = CCC_flat_buffer_with_storage(0, private_compound_literal), \
190 .order = (private_order), .comparator = (private_comparator), \
191 }
192#endif
193
197#define CCC_private_flat_priority_queue_emplace( \
198 flat_priority_queue, private_allocator_pointer, type_compound_literal... \
199) \
200 (__extension__({ \
201 struct CCC_Flat_priority_queue *private_flat_priority_queue \
202 = (flat_priority_queue); \
203 typeof(type_compound_literal) *private_flat_priority_queue_res \
204 = CCC_flat_buffer_allocate_back( \
205 &private_flat_priority_queue->buffer, \
206 private_allocator_pointer \
207 ); \
208 if (private_flat_priority_queue_res) { \
209 *private_flat_priority_queue_res = type_compound_literal; \
210 if (private_flat_priority_queue->buffer.count > 1) { \
211 private_flat_priority_queue_res = CCC_flat_buffer_at( \
212 &private_flat_priority_queue->buffer, \
213 CCC_private_flat_priority_queue_bubble_up( \
214 private_flat_priority_queue, \
215 &(typeof(type_compound_literal)){}, \
216 private_flat_priority_queue->buffer.count - 1 \
217 ) \
218 ); \
219 } else { \
220 private_flat_priority_queue_res = CCC_flat_buffer_at( \
221 &private_flat_priority_queue->buffer, 0 \
222 ); \
223 } \
224 } \
225 private_flat_priority_queue_res; \
226 }))
227
230#define CCC_private_flat_priority_queue_update_with( \
231 flat_priority_queue_pointer, \
232 closure_parameter, \
233 update_closure_over_closure_parameter... \
234) \
235 (__extension__({ \
236 struct CCC_Flat_priority_queue const *const \
237 private_flat_priority_queue = (flat_priority_queue_pointer); \
238 typeof(*closure_parameter) * \
239 private_flat_priority_queue_updated_element = (closure_parameter); \
240 if (private_flat_priority_queue \
241 && !CCC_flat_buffer_is_empty( \
242 &private_flat_priority_queue->buffer \
243 )) { \
244 {update_closure_over_closure_parameter}; \
245 private_flat_priority_queue_updated_element \
246 = CCC_private_flat_priority_queue_update_fixup( \
247 private_flat_priority_queue, \
248 private_flat_priority_queue_updated_element, \
249 &(typeof(*closure_parameter)){} \
250 ); \
251 } \
252 private_flat_priority_queue_updated_element; \
253 }))
254
256#define CCC_private_flat_priority_queue_increase_with( \
257 flat_priority_queue_pointer, \
258 closure_parameter, \
259 increase_closure_over_closure_parameter... \
260) \
261 CCC_private_flat_priority_queue_update_with( \
262 flat_priority_queue_pointer, \
263 closure_parameter, \
264 increase_closure_over_closure_parameter \
265 )
266
268#define CCC_private_flat_priority_queue_decrease_with( \
269 flat_priority_queue_pointer, \
270 closure_parameter, \
271 decrease_closure_over_closure_parameter... \
272) \
273 CCC_private_flat_priority_queue_update_with( \
274 flat_priority_queue_pointer, \
275 closure_parameter, \
276 decrease_closure_over_closure_parameter \
277 )
278
279/* NOLINTEND(readability-identifier-naming) */
280
281#endif /* CCC_PRIVATE_FLAT_PRIORITY_QUEUE_H */
CCC_Comparator
The type passed by reference to any container function that may need to compare elements....
Definition: types.h:409
CCC_Flat_buffer
Definition: private_flat_buffer.h:32
CCC_Flat_priority_queue
Definition: private_flat_priority_queue.h:34
CCC_Flat_priority_queue::comparator
CCC_Comparator comparator
Definition: private_flat_priority_queue.h:42
CCC_Flat_priority_queue::buffer
CCC_Flat_buffer buffer
Definition: private_flat_priority_queue.h:37
CCC_Flat_priority_queue::order
CCC_Order order
Definition: private_flat_priority_queue.h:40
CCC_Order
CCC_Order
A three-way comparison for comparison functions.
Definition: types.h:213