C Container Collection (CCC)
Loading...
Searching...
No Matches
private_doubly_linked_list.h
1
16#ifndef CCC_PRIVATE_DOUBLY_LINKED_LIST_H
17#define CCC_PRIVATE_DOUBLY_LINKED_LIST_H
18
20#include <assert.h>
21#include <stddef.h>
24#include "../types.h"
25
26/* NOLINTBEGIN(readability-identifier-naming) */
27
33struct CCC_Doubly_linked_list_node
34{
36 struct CCC_Doubly_linked_list_node *next;
38 struct CCC_Doubly_linked_list_node *previous;
39};
40
68struct CCC_Doubly_linked_list
69{
71 struct CCC_Doubly_linked_list_node *head;
73 struct CCC_Doubly_linked_list_node *tail;
75 size_t count;
77 size_t sizeof_type;
79 size_t type_intruder_offset;
81 CCC_Type_comparator *compare;
83 CCC_Allocator *allocate;
85 void *context;
86};
87
88/*======================= Private Interface ===========================*/
89
91void
92CCC_private_doubly_linked_list_push_back(struct CCC_Doubly_linked_list *,
93 struct CCC_Doubly_linked_list_node *);
95void
96CCC_private_doubly_linked_list_push_front(struct CCC_Doubly_linked_list *,
97 struct CCC_Doubly_linked_list_node *);
99struct CCC_Doubly_linked_list_node *
100CCC_private_doubly_linked_list_node_in(struct CCC_Doubly_linked_list const *,
101 void const *any_struct);
102
103/*======================= Macro Implementations =======================*/
104
107#define CCC_private_doubly_linked_list_initialize( \
108 private_struct_name, private_type_intruder_field, private_compare, \
109 private_allocate, private_context_data) \
110 { \
111 .head = NULL, \
112 .tail = NULL, \
113 .sizeof_type = sizeof(private_struct_name), \
114 .type_intruder_offset \
115 = offsetof(private_struct_name, private_type_intruder_field), \
116 .count = 0, \
117 .allocate = (private_allocate), \
118 .compare = (private_compare), \
119 .context = (private_context_data), \
120 }
121
123#define CCC_private_doubly_linked_list_with_allocator( \
124 private_struct_name, private_type_intruder_field, private_compare, \
125 private_allocate) \
126 { \
127 .head = NULL, \
128 .tail = NULL, \
129 .sizeof_type = sizeof(private_struct_name), \
130 .type_intruder_offset \
131 = offsetof(private_struct_name, private_type_intruder_field), \
132 .count = 0, \
133 .allocate = (private_allocate), \
134 .compare = (private_compare), \
135 .context = NULL, \
136 }
137
139#define CCC_private_doubly_linked_list_with_context_allocator( \
140 private_struct_name, private_type_intruder_field, private_compare, \
141 private_allocate, private_context) \
142 { \
143 .head = NULL, \
144 .tail = NULL, \
145 .sizeof_type = sizeof(private_struct_name), \
146 .type_intruder_offset \
147 = offsetof(private_struct_name, private_type_intruder_field), \
148 .count = 0, \
149 .allocate = (private_allocate), \
150 .compare = (private_compare), \
151 .context = (private_context), \
152 }
153
155#define CCC_private_doubly_linked_list_from( \
156 private_type_intruder_field, private_compare, private_allocate, \
157 private_destroy, private_context_data, private_compound_literal_array...) \
158 (__extension__({ \
159 typeof(*private_compound_literal_array) \
160 *private_doubly_linked_list_type_array \
161 = private_compound_literal_array; \
162 struct CCC_Doubly_linked_list private_doubly_linked_list \
163 = CCC_private_doubly_linked_list_initialize( \
164 typeof(*private_doubly_linked_list_type_array), \
165 private_type_intruder_field, private_compare, \
166 private_allocate, private_context_data); \
167 if (private_doubly_linked_list.allocate) \
168 { \
169 size_t const private_count \
170 = sizeof(private_compound_literal_array) \
171 / sizeof(*private_doubly_linked_list_type_array); \
172 for (size_t private_i = 0; private_i < private_count; ++private_i) \
173 { \
174 typeof(*private_doubly_linked_list_type_array) *const \
175 private_new_node \
176 = private_doubly_linked_list.allocate( \
177 (CCC_Allocator_context){ \
178 .input = NULL, \
179 .bytes = private_doubly_linked_list.sizeof_type, \
180 .context = private_doubly_linked_list.context, \
181 }); \
182 if (!private_new_node) \
183 { \
184 CCC_doubly_linked_list_clear(&private_doubly_linked_list, \
185 private_destroy); \
186 break; \
187 } \
188 *private_new_node \
189 = private_doubly_linked_list_type_array[private_i]; \
190 CCC_private_doubly_linked_list_push_back( \
191 &private_doubly_linked_list, \
192 CCC_private_doubly_linked_list_node_in( \
193 &private_doubly_linked_list, private_new_node)); \
194 } \
195 } \
196 private_doubly_linked_list; \
197 }))
198
200#define CCC_private_doubly_linked_list_emplace_back( \
201 doubly_linked_list_pointer, struct_initializer...) \
202 (__extension__({ \
203 typeof(struct_initializer) *private_doubly_linked_list_res = NULL; \
204 struct CCC_Doubly_linked_list *private_doubly_linked_list \
205 = (doubly_linked_list_pointer); \
206 if (private_doubly_linked_list) \
207 { \
208 if (private_doubly_linked_list->allocate) \
209 { \
210 private_doubly_linked_list_res \
211 = private_doubly_linked_list->allocate( \
212 (CCC_Allocator_context){ \
213 .input = NULL, \
214 .bytes = private_doubly_linked_list->sizeof_type, \
215 .context = private_doubly_linked_list->context, \
216 }); \
217 if (private_doubly_linked_list_res) \
218 { \
219 *private_doubly_linked_list_res = struct_initializer; \
220 CCC_private_doubly_linked_list_push_back( \
221 private_doubly_linked_list, \
222 CCC_private_doubly_linked_list_node_in( \
223 private_doubly_linked_list, \
224 private_doubly_linked_list_res)); \
225 } \
226 } \
227 } \
228 private_doubly_linked_list_res; \
229 }))
230
232#define CCC_private_doubly_linked_list_emplace_front( \
233 doubly_linked_list_pointer, struct_initializer...) \
234 (__extension__({ \
235 typeof(struct_initializer) *private_doubly_linked_list_res = NULL; \
236 struct CCC_Doubly_linked_list *private_doubly_linked_list \
237 = (doubly_linked_list_pointer); \
238 if (!private_doubly_linked_list->allocate) \
239 { \
240 private_doubly_linked_list_res = NULL; \
241 } \
242 else \
243 { \
244 private_doubly_linked_list_res \
245 = private_doubly_linked_list->allocate( \
246 (CCC_Allocator_context){ \
247 .input = NULL, \
248 .bytes = private_doubly_linked_list->sizeof_type, \
249 .context = private_doubly_linked_list->context, \
250 }); \
251 if (private_doubly_linked_list_res) \
252 { \
253 *private_doubly_linked_list_res = struct_initializer; \
254 CCC_private_doubly_linked_list_push_front( \
255 private_doubly_linked_list, \
256 CCC_private_doubly_linked_list_node_in( \
257 private_doubly_linked_list, \
258 private_doubly_linked_list_res)); \
259 } \
260 } \
261 private_doubly_linked_list_res; \
262 }))
263
264/* NOLINTEND(readability-identifier-naming) */
265
266#endif /* CCC_PRIVATE_DOUBLY_LINKED_LIST_H */
CCC_Doubly_linked_list_node
Definition: private_doubly_linked_list.h:34
CCC_Doubly_linked_list_node::previous
struct CCC_Doubly_linked_list_node * previous
Definition: private_doubly_linked_list.h:38
CCC_Doubly_linked_list_node::next
struct CCC_Doubly_linked_list_node * next
Definition: private_doubly_linked_list.h:36
CCC_Doubly_linked_list
Definition: private_doubly_linked_list.h:69
CCC_Doubly_linked_list::sizeof_type
size_t sizeof_type
Definition: private_doubly_linked_list.h:77
CCC_Doubly_linked_list::compare
CCC_Type_comparator * compare
Definition: private_doubly_linked_list.h:81
CCC_Doubly_linked_list::type_intruder_offset
size_t type_intruder_offset
Definition: private_doubly_linked_list.h:79
CCC_Doubly_linked_list::head
struct CCC_Doubly_linked_list_node * head
Definition: private_doubly_linked_list.h:71
CCC_Doubly_linked_list::allocate
CCC_Allocator * allocate
Definition: private_doubly_linked_list.h:83
CCC_Doubly_linked_list::count
size_t count
Definition: private_doubly_linked_list.h:75
CCC_Doubly_linked_list::context
void * context
Definition: private_doubly_linked_list.h:85
CCC_Doubly_linked_list::tail
struct CCC_Doubly_linked_list_node * tail
Definition: private_doubly_linked_list.h:73
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
CCC_Allocator
void * CCC_Allocator(CCC_Allocator_context)
An allocation function at the core of all containers.
Definition: types.h:340