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_from( \
124 private_type_intruder_field, private_compare, private_allocate, \
125 private_destroy, private_context_data, private_compound_literal_array...) \
126 (__extension__({ \
127 typeof(*private_compound_literal_array) \
128 *private_doubly_linked_list_type_array \
129 = private_compound_literal_array; \
130 struct CCC_Doubly_linked_list private_doubly_linked_list \
131 = CCC_private_doubly_linked_list_initialize( \
132 typeof(*private_doubly_linked_list_type_array), \
133 private_type_intruder_field, private_compare, \
134 private_allocate, private_context_data); \
135 if (private_doubly_linked_list.allocate) \
136 { \
137 size_t const private_count \
138 = sizeof(private_compound_literal_array) \
139 / sizeof(*private_doubly_linked_list_type_array); \
140 for (size_t private_i = 0; private_i < private_count; ++private_i) \
141 { \
142 typeof(*private_doubly_linked_list_type_array) *const \
143 private_new_node \
144 = private_doubly_linked_list.allocate( \
145 (CCC_Allocator_context){ \
146 .input = NULL, \
147 .bytes = private_doubly_linked_list.sizeof_type, \
148 .context = private_doubly_linked_list.context, \
149 }); \
150 if (!private_new_node) \
151 { \
152 CCC_doubly_linked_list_clear(&private_doubly_linked_list, \
153 private_destroy); \
154 break; \
155 } \
156 *private_new_node \
157 = private_doubly_linked_list_type_array[private_i]; \
158 CCC_private_doubly_linked_list_push_back( \
159 &private_doubly_linked_list, \
160 CCC_private_doubly_linked_list_node_in( \
161 &private_doubly_linked_list, private_new_node)); \
162 } \
163 } \
164 private_doubly_linked_list; \
165 }))
166
168#define CCC_private_doubly_linked_list_emplace_back( \
169 doubly_linked_list_pointer, struct_initializer...) \
170 (__extension__({ \
171 typeof(struct_initializer) *private_doubly_linked_list_res = NULL; \
172 struct CCC_Doubly_linked_list *private_doubly_linked_list \
173 = (doubly_linked_list_pointer); \
174 if (private_doubly_linked_list) \
175 { \
176 if (private_doubly_linked_list->allocate) \
177 { \
178 private_doubly_linked_list_res \
179 = private_doubly_linked_list->allocate( \
180 (CCC_Allocator_context){ \
181 .input = NULL, \
182 .bytes = private_doubly_linked_list->sizeof_type, \
183 .context = private_doubly_linked_list->context, \
184 }); \
185 if (private_doubly_linked_list_res) \
186 { \
187 *private_doubly_linked_list_res = struct_initializer; \
188 CCC_private_doubly_linked_list_push_back( \
189 private_doubly_linked_list, \
190 CCC_private_doubly_linked_list_node_in( \
191 private_doubly_linked_list, \
192 private_doubly_linked_list_res)); \
193 } \
194 } \
195 } \
196 private_doubly_linked_list_res; \
197 }))
198
200#define CCC_private_doubly_linked_list_emplace_front( \
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->allocate) \
207 { \
208 private_doubly_linked_list_res = NULL; \
209 } \
210 else \
211 { \
212 private_doubly_linked_list_res \
213 = private_doubly_linked_list->allocate( \
214 (CCC_Allocator_context){ \
215 .input = NULL, \
216 .bytes = private_doubly_linked_list->sizeof_type, \
217 .context = private_doubly_linked_list->context, \
218 }); \
219 if (private_doubly_linked_list_res) \
220 { \
221 *private_doubly_linked_list_res = struct_initializer; \
222 CCC_private_doubly_linked_list_push_front( \
223 private_doubly_linked_list, \
224 CCC_private_doubly_linked_list_node_in( \
225 private_doubly_linked_list, \
226 private_doubly_linked_list_res)); \
227 } \
228 } \
229 private_doubly_linked_list_res; \
230 }))
231
232/* NOLINTEND(readability-identifier-naming) */
233
234#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