39 #define DARRAY_INVALID ((size_t)-1) 47 static inline void darray_init(
struct darray *dst)
54 static inline void darray_free(
struct darray *dst)
62 static inline size_t darray_alloc_size(
const size_t element_size,
65 return element_size * da->
num;
68 static inline void *darray_item(
const size_t element_size,
69 const struct darray *da,
size_t idx)
71 return (
void *)(((
uint8_t *)da->
array) + element_size * idx);
74 static inline void *darray_end(
const size_t element_size,
80 return darray_item(element_size, da, da->
num - 1);
83 static inline void darray_reserve(
const size_t element_size,
struct darray *dst,
84 const size_t capacity)
87 if (capacity == 0 || capacity <= dst->num)
90 ptr =
bmalloc(element_size * capacity);
92 memcpy(ptr, dst->
array, element_size * dst->
num);
99 static inline void darray_ensure_capacity(
const size_t element_size,
101 const size_t new_size)
105 if (new_size <= dst->capacity)
109 if (new_size > new_cap)
111 ptr =
bmalloc(element_size * new_cap);
120 static inline void darray_resize(
const size_t element_size,
struct darray *dst,
126 if (size == dst->
num) {
128 }
else if (size == 0) {
133 b_clear = size > dst->
num;
136 darray_ensure_capacity(element_size, dst, size);
140 memset(darray_item(element_size, dst, old_num), 0,
141 element_size * (dst->
num - old_num));
144 static inline void darray_copy(
const size_t element_size,
struct darray *dst,
150 darray_resize(element_size, dst, da->
num);
155 static inline void darray_copy_array(
const size_t element_size,
156 struct darray *dst,
const void *array,
159 darray_resize(element_size, dst, num);
160 memcpy(dst->
array, array, element_size * dst->
num);
163 static inline void darray_move(
struct darray *dst,
struct darray *src)
166 memcpy(dst, src,
sizeof(
struct darray));
172 static inline size_t darray_find(
const size_t element_size,
173 const struct darray *da,
const void *item,
178 assert(idx <= da->num);
180 for (i = idx; i < da->
num; i++) {
181 void *compare = darray_item(element_size, da, i);
182 if (memcmp(compare, item, element_size) == 0)
189 static inline size_t darray_push_back(
const size_t element_size,
190 struct darray *dst,
const void *item)
192 darray_ensure_capacity(element_size, dst, ++dst->
num);
193 memcpy(darray_end(element_size, dst), item, element_size);
198 static inline void *darray_push_back_new(
const size_t element_size,
203 darray_ensure_capacity(element_size, dst, ++dst->
num);
205 last = darray_end(element_size, dst);
206 memset(last, 0, element_size);
210 static inline size_t darray_push_back_array(
const size_t element_size,
212 const void *array,
const size_t num)
221 darray_resize(element_size, dst, dst->
num + num);
222 memcpy(darray_item(element_size, dst, old_num), array,
228 static inline size_t darray_push_back_darray(
const size_t element_size,
232 return darray_push_back_array(element_size, dst, da->
array, da->
num);
235 static inline void darray_insert(
const size_t element_size,
struct darray *dst,
236 const size_t idx,
const void *item)
241 assert(idx <= dst->num);
243 if (idx == dst->
num) {
244 darray_push_back(element_size, dst, item);
248 move_count = dst->
num - idx;
249 darray_ensure_capacity(element_size, dst, ++dst->
num);
251 new_item = darray_item(element_size, dst, idx);
253 memmove(darray_item(element_size, dst, idx + 1), new_item,
254 move_count * element_size);
255 memcpy(new_item, item, element_size);
258 static inline void *darray_insert_new(
const size_t element_size,
259 struct darray *dst,
const size_t idx)
264 assert(idx <= dst->num);
266 return darray_push_back_new(element_size, dst);
268 item = darray_item(element_size, dst, idx);
270 move_count = dst->
num - idx;
271 darray_ensure_capacity(element_size, dst, ++dst->
num);
272 memmove(darray_item(element_size, dst, idx + 1), item,
273 move_count * element_size);
275 memset(item, 0, element_size);
279 static inline void darray_insert_array(
const size_t element_size,
280 struct darray *dst,
const size_t idx,
281 const void *array,
const size_t num)
285 assert(array != NULL);
287 assert(idx < dst->num);
290 darray_resize(element_size, dst, dst->
num + num);
292 memmove(darray_item(element_size, dst, idx + num),
293 darray_item(element_size, dst, idx),
294 element_size * (old_num - idx));
295 memcpy(darray_item(element_size, dst, idx), array, element_size * num);
298 static inline void darray_insert_darray(
const size_t element_size,
299 struct darray *dst,
const size_t idx,
302 darray_insert_array(element_size, dst, idx, da->
array, da->
num);
305 static inline void darray_erase(
const size_t element_size,
struct darray *dst,
308 assert(idx < dst->num);
310 if (idx >= dst->
num || !--dst->
num)
313 memmove(darray_item(element_size, dst, idx),
314 darray_item(element_size, dst, idx + 1),
315 element_size * (dst->
num - idx));
318 static inline void darray_erase_item(
const size_t element_size,
319 struct darray *dst,
const void *item)
321 size_t idx = darray_find(element_size, dst, item, 0);
323 darray_erase(element_size, dst, idx);
326 static inline void darray_erase_range(
const size_t element_size,
327 struct darray *dst,
const size_t start,
330 size_t count, move_count;
332 assert(start <= dst->num);
333 assert(end <= dst->num);
338 darray_erase(element_size, dst, start);
340 }
else if (count == dst->
num) {
345 move_count = dst->
num - end;
347 memmove(darray_item(element_size, dst, start),
348 darray_item(element_size, dst, end),
349 move_count * element_size);
354 static inline void darray_pop_back(
const size_t element_size,
357 assert(dst->
num != 0);
360 darray_erase(element_size, dst, dst->
num - 1);
363 static inline void darray_join(
const size_t element_size,
struct darray *dst,
366 darray_push_back_darray(element_size, dst, da);
370 static inline void darray_split(
const size_t element_size,
struct darray *dst1,
376 assert(da->
num >= idx);
377 assert(dst1 != dst2);
380 darray_copy(element_size, &temp, da);
387 darray_copy_array(element_size, dst1, temp.array,
389 if (idx < temp.num - 1)
390 darray_copy_array(element_size, dst2,
391 darray_item(element_size, &temp, idx),
398 static inline void darray_move_item(
const size_t element_size,
399 struct darray *dst,
const size_t from,
402 void *temp, *p_from, *p_to;
407 temp = malloc(element_size);
408 p_from = darray_item(element_size, dst, from);
409 p_to = darray_item(element_size, dst, to);
411 memcpy(temp, p_from, element_size);
414 memmove(darray_item(element_size, dst, to + 1), p_to,
415 element_size * (from - to));
417 memmove(p_from, darray_item(element_size, dst, from + 1),
418 element_size * (to - from));
420 memcpy(p_to, temp, element_size);
424 static inline void darray_swap(
const size_t element_size,
struct darray *dst,
425 const size_t a,
const size_t b)
427 void *temp, *a_ptr, *b_ptr;
429 assert(a < dst->
num);
430 assert(b < dst->
num);
435 temp = malloc(element_size);
436 a_ptr = darray_item(element_size, dst, a);
437 b_ptr = darray_item(element_size, dst, b);
439 memcpy(temp, a_ptr, element_size);
440 memcpy(a_ptr, b_ptr, element_size);
441 memcpy(b_ptr, temp, element_size);
455 #define DARRAY(type) \ 465 #define da_init(v) darray_init(&v.da) 467 #define da_free(v) darray_free(&v.da) 469 #define da_alloc_size(v) (sizeof(*v.array) * v.num) 471 #define da_end(v) darray_end(sizeof(*v.array), &v.da) 473 #define da_reserve(v, capacity) \ 474 darray_reserve(sizeof(*v.array), &v.da, capacity) 476 #define da_resize(v, size) darray_resize(sizeof(*v.array), &v.da, size) 478 #define da_copy(dst, src) darray_copy(sizeof(*dst.array), &dst.da, &src.da) 480 #define da_copy_array(dst, src_array, n) \ 481 darray_copy_array(sizeof(*dst.array), &dst.da, src_array, n) 483 #define da_move(dst, src) darray_move(&dst.da, &src.da) 485 #define da_find(v, item, idx) darray_find(sizeof(*v.array), &v.da, item, idx) 487 #define da_push_back(v, item) darray_push_back(sizeof(*v.array), &v.da, item) 489 #define da_push_back_new(v) darray_push_back_new(sizeof(*v.array), &v.da) 491 #define da_push_back_array(dst, src_array, n) \ 492 darray_push_back_array(sizeof(*dst.array), &dst.da, src_array, n) 494 #define da_push_back_da(dst, src) \ 495 darray_push_back_darray(sizeof(*dst.array), &dst.da, &src.da) 497 #define da_insert(v, idx, item) \ 498 darray_insert(sizeof(*v.array), &v.da, idx, item) 500 #define da_insert_new(v, idx) darray_insert_new(sizeof(*v.array), &v.da, idx) 502 #define da_insert_array(dst, idx, src_array, n) \ 503 darray_insert_array(sizeof(*dst.array), &dst.da, idx, src_array, n) 505 #define da_insert_da(dst, idx, src) \ 506 darray_insert_darray(sizeof(*dst.array), &dst.da, idx, &src.da) 508 #define da_erase(dst, idx) darray_erase(sizeof(*dst.array), &dst.da, idx) 510 #define da_erase_item(dst, item) \ 511 darray_erase_item(sizeof(*dst.array), &dst.da, item) 513 #define da_erase_range(dst, from, to) \ 514 darray_erase_range(sizeof(*dst.array), &dst.da, from, to) 516 #define da_pop_back(dst) darray_pop_back(sizeof(*dst.array), &dst.da); 518 #define da_join(dst, src) darray_join(sizeof(*dst.array), &dst.da, &src.da) 520 #define da_split(dst1, dst2, src, idx) \ 521 darray_split(sizeof(*src.array), &dst1.da, &dst2.da, &src.da, idx) 523 #define da_move_item(v, from, to) \ 524 darray_move_item(sizeof(*v.array), &v.da, from, to) 526 #define da_swap(v, idx1, idx2) darray_swap(sizeof(*v.array), &v.da, idx1, idx2)
size_t capacity
Definition: darray.h:44
#define DARRAY_INVALID
Definition: darray.h:39
unsigned char uint8_t
Definition: vc_stdint.h:27
EXPORT void * bmalloc(size_t size)
void * array
Definition: darray.h:42
size_t num
Definition: darray.h:43
EXPORT void bfree(void *ptr)