0a36ea0177d55f0fa3056a87bd00fd78f7cd2f12
[cgds.git] / src / List.h
1 /**
2 * @file List.h
3 */
4
5 #ifndef CGDS_LIST_H
6 #define CGDS_LIST_H
7
8 #include <stdlib.h>
9 #include <string.h>
10 #include "cgds/safe_alloc.h"
11 #include "cgds/types.h"
12
13 ////////////////
14 // List logic //
15 ////////////////
16
17 /**
18 * @brief Cell of a double-linked list.
19 */
20 typedef struct ListCell {
21 void* data; ///< Generic data contained in this cell.
22 struct ListCell* prev; ///< Pointer to previous cell in the list.
23 struct ListCell* next; ///< Pointer to next cell in the list.
24 } ListCell;
25
26 /**
27 * @brief Double-linked list data structure.
28 */
29 typedef struct List {
30 UInt size; ///< Count elements in the list.
31 size_t dataSize; ///< Size of a list cell element in bytes.
32 ListCell* head; ///< Pointer to the first cell in the list.
33 ListCell* tail; ///< Pointer to the last cell in the list.
34 } List;
35
36 /**
37 * @brief Initialize an empty list.
38 */
39 void _list_init(
40 List* list, ///< "this" pointer.
41 size_t dataSize ///< Size of a list cell elements in bytes.
42 );
43
44 /**
45 * @brief Return an allocated and initialized list.
46 * @param dataSize Size in bytes of a list element.
47 */
48 List* _list_new(
49 size_t dataSize ///< Size of a list cell elements in bytes.
50 );
51
52 /**
53 * @brief Return an allocated and initialized list.
54 * @param type Type of a list element (int, char*, ...).
55 *
56 * Usage: List* list_new(<Type> type)
57 */
58 #define list_new(type) \
59 _list_new(sizeof(type))
60
61 /**
62 * @brief Copy constructor (shallow copy, ok for basic types).
63 */
64 List* list_copy(
65 List* list ///< "this" pointer.
66 );
67
68 /**
69 * @brief Check if the list is empty.
70 */
71 bool list_empty(
72 List* list ///< "this" pointer.
73 );
74
75 /**
76 * @brief return the size of current list.
77 */
78 UInt list_size(
79 List* list ///< "this" pointer.
80 );
81
82 /**
83 * @brief Get data at the given list cell argument.
84 */
85 void* _list_get(
86 ListCell* listCell ///< Pointer to a cell inside "this" list.
87 );
88
89 /**
90 * @brief Get data at the given list cell argument.
91 * @param listCell Pointer to a cell inside "this" list.
92 * @param data Data to be assigned.
93 *
94 * Usage: void list_get(ListCell* listCell, void data)
95 */
96 #define list_get(listCell, data) \
97 { \
98 void* pData = _list_get(listCell); \
99 data = *((typeof(&data))pData); \
100 }
101
102 /**
103 * @brief Set data at the given list cell argument.
104 */
105 void _list_set(
106 List* list, ///< "this" pointer.
107 ListCell* listCell, ///< Pointer to a cell inside "this" list.
108 void* data ///< Pointer to data to be set.
109 );
110
111 /**
112 * @brief Set data at the given list cell argument.
113 * @param list "this" pointer.
114 * @param listCell Pointer to a cell inside "this" list.
115 * @param data Data to be set.
116 *
117 * Usage: void list_set(List* list, ListCell* listCell, void data);
118 */
119 #define list_set(list, listCell, data) \
120 { \
121 typeof((data)) tmp = data; \
122 _list_set(list, listCell, &tmp); \
123 }
124
125 /**
126 * @brief Add data to the list when list is empty.
127 */
128 void _list_insert_first_element(
129 List* list, ///< "this" pointer.
130 void* data ///< Pointer to data to be added
131 );
132
133 /**
134 * @brief Add data before list cell argument.
135 */
136 void _list_insert_before(
137 List* list, ///< "this" pointer.
138 ListCell* listCell, ///< Pointer to a cell inside "this" list.
139 void* data ///< Pointer to data to be added.
140 );
141
142 /**
143 * @brief Add data before list cell argument.
144 * @param list "this" pointer.
145 * @param listCell Pointer to a cell inside "this" list.
146 * @param data Data to be inserted.
147 *
148 * Usage: void list_insert_before(List* list, ListCell* listCell, void data)
149 */
150 #define list_insert_before(list, listCell, data) \
151 { \
152 typeof((data)) tmp = data; \
153 _list_insert_before(list, listCell, &tmp); \
154 }
155
156 /**
157 * @brief Add data after list cell argument.
158 */
159 void _list_insert_after(
160 List* list, ///< "this" pointer.
161 ListCell* listCell, ///< Pointer to a cell inside "this" list.
162 void* data ///< Pointer to data to be inserted.
163 );
164
165 /**
166 * @brief Add data after list cell argument.
167 * @param list "this" pointer.
168 * @param listCell Pointer to a cell inside "this" list.
169 * @param data Data to be inserted.
170 *
171 * Usage: void list_insert_after(List* list, ListCell* listCell, void data)
172 */
173 #define list_insert_after(list, listCell, data) \
174 { \
175 typeof((data)) tmp = data; \
176 _list_insert_after(list, listCell, &tmp); \
177 }
178
179 /**
180 * @brief Add data at the beginning of the list.
181 */
182 void _list_insert_front(
183 List* list, ///< "this" pointer.
184 void* data ///< Pointer to data to be inserted.
185 );
186
187 /**
188 * @brief Add data at the beginning of the list.
189 * @param list "this" pointer.
190 * @param data Data to be inserted.
191 *
192 * Usage: void list_insert_front(List* list, void data)
193 */
194 #define list_insert_front(list, data) \
195 { \
196 typeof((data)) tmp = data; \
197 _list_insert_front(list, &tmp); \
198 }
199
200 /**
201 * @brief Add data at the end of the list.
202 */
203 void _list_insert_back(
204 List* list, ///< "this" pointer.
205 void* data ///< Pointer to data to be inserted.
206 );
207
208 /**
209 * @brief Add data at the end of the list.
210 * @param list "this" pointer.
211 * @param data Data to be inserted.
212 *
213 * Usage: void list_insert_back(List* list, void data)
214 */
215 #define list_insert_back(list, data) \
216 { \
217 typeof((data)) tmp = data; \
218 _list_insert_back(list, &tmp); \
219 }
220
221 /**
222 * @brief Remove data at position given by 'listCell'.
223 */
224 void list_remove(
225 List* list, ///< "this" pointer.
226 ListCell* listCell ///< Pointer to a cell inside "this" list.
227 );
228
229 /**
230 * @brief Remove data at the beginning of the list.
231 */
232 void list_remove_front(
233 List* list ///< "this" pointer.
234 );
235
236 /**
237 * @brief Remove data at the end of the list.
238 */
239 void list_remove_back(
240 List* list ///< "this" pointer.
241 );
242
243 /**
244 * @brief Clear the entire list.
245 */
246 void list_clear(
247 List* list ///< "this" pointer.
248 );
249
250 /**
251 * @brief Destroy the list: clear it, and free 'list' pointer.
252 */
253 void list_destroy(
254 List* list ///< "this" pointer.
255 );
256
257 ////////////////////
258 // Iterator logic //
259 ////////////////////
260
261 /**
262 * @brief Iterator on a double-linked list.
263 */
264 typedef struct ListIterator {
265 List* list; ///< The list to be iterate.
266 ListCell* current; ///< The current iterated list cell.
267 } ListIterator;
268
269 /**
270 * @brief Obtain an iterator object, starting at list beginning.
271 */
272 ListIterator* list_get_iterator(
273 List* list ///< Pointer to the list to be iterated over.
274 );
275
276 /**
277 * @brief (Re)set current position inside list to head.
278 */
279 void listI_reset_head(
280 ListIterator* listI ///< "this" pointer.
281 );
282
283 /**
284 * @brief (Re)set current position inside list to tail.
285 */
286 void listI_reset_tail(
287 ListIterator* listI ///< "this" pointer.
288 );
289
290 /**
291 * @brief Tell if there is some data at the current index.
292 */
293 bool listI_has_data(
294 ListIterator* listI ///< "this" pointer.
295 );
296
297 /**
298 * @brief Return data contained in the current list cell.
299 * @param listI "this" pointer.
300 * @param data Data to be assigned.
301 *
302 * Usage: void listI_get(ListIterator* listI, void data)
303 */
304 #define listI_get(listI, data) \
305 list_get(listI->current, data)
306
307 /**
308 * @brief Set data at the current iterator position.
309 * @param listI "this" pointer
310 * @param data Data to assign.
311 *
312 * Usage: void listI_set(ListIterator* listI, void data);
313 */
314 #define listI_set(listI, data) \
315 list_set(listI->list, listI->current, data)
316
317 /**
318 * @brief Add data before current list cell.
319 * @param listI "this" pointer
320 * @param data Data to be inserted.
321 *
322 * Usage: void listI_insert_before(ListIteratorI* listI, void data)
323 */
324 #define listI_insert_before(listI, data) \
325 list_insert_before(listI->list, listI->current, data)
326
327 /**
328 * @brief Add data after current list cell.
329 * @param listI "this" pointer
330 * @param data Data to be inserted.
331 *
332 * Usage: void listI_insert_after(ListIteratorI* listI, void data)
333 */
334 #define listI_insert_after(listI, data) \
335 list_insert_after(listI->list, listI->current, data)
336
337 /**
338 * @brief Type to encode a direction (forward / backward).
339 */
340 typedef enum {
341 BACKWARD = -1, ///< Move toward head.
342 FORWARD = 1 ///< Move toward tail.
343 } Direction;
344
345 /**
346 * @brief Remove data at the current iterator position.
347 */
348 void listI_remove(
349 ListIterator* listI, ///< "this" pointer.
350 Direction direction ///< Indicate the position of iterator after removal.
351 );
352
353 /**
354 * @brief Move current iterator position forward (toward tail).
355 */
356 void listI_move_next(
357 ListIterator* listI ///< "this" pointer.
358 );
359
360 /**
361 * @brief Move current iterator position backward (toward head).
362 */
363 void listI_move_prev(
364 ListIterator* listI ///< "this" pointer.
365 );
366
367 /**
368 * @brief Free memory allocated for the iterator.
369 */
370 void listI_destroy(
371 ListIterator* listI ///< "this" pointer.
372 );
373
374 #endif