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,
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,
100 struct darray *dst,
const size_t new_size)
104 if (new_size <= dst->capacity)
108 if (new_size > new_cap)
110 ptr =
bmalloc(element_size*new_cap);
119 static inline void darray_resize(
const size_t element_size,
120 struct darray *dst,
const size_t size)
125 if (size == dst->
num) {
127 }
else if (size == 0) {
132 b_clear = size > dst->
num;
135 darray_ensure_capacity(element_size, dst, size);
139 memset(darray_item(element_size, dst, old_num), 0,
140 element_size * (dst->
num-old_num));
143 static inline void darray_copy(
const size_t element_size,
struct darray *dst,
149 darray_resize(element_size, dst, da->
num);
154 static inline void darray_copy_array(
const size_t element_size,
157 darray_resize(element_size, dst, num);
158 memcpy(dst->
array, array, element_size*dst->
num);
161 static inline void darray_move(
struct darray *dst,
struct darray *src)
164 memcpy(dst, src,
sizeof(
struct darray));
170 static inline size_t darray_find(
const size_t element_size,
171 const struct darray *da,
const void *item,
const size_t idx)
175 assert(idx <= da->num);
177 for (i = idx; i < da->
num; i++) {
178 void *compare = darray_item(element_size, da, i);
179 if (memcmp(compare, item, element_size) == 0)
186 static inline size_t darray_push_back(
const size_t element_size,
187 struct darray *dst,
const void *item)
189 darray_ensure_capacity(element_size, dst, ++dst->
num);
190 memcpy(darray_end(element_size, dst), item, element_size);
195 static inline void *darray_push_back_new(
const size_t element_size,
200 darray_ensure_capacity(element_size, dst, ++dst->
num);
202 last = darray_end(element_size, dst);
203 memset(last, 0, element_size);
207 static inline size_t darray_push_back_array(
const size_t element_size,
208 struct darray *dst,
const void *array,
const size_t num)
210 size_t old_num = dst->
num;
212 assert(array != NULL);
215 darray_resize(element_size, dst, dst->
num+num);
216 memcpy(darray_item(element_size, dst, old_num), array,
222 static inline size_t darray_push_back_darray(
const size_t element_size,
225 return darray_push_back_array(element_size, dst, da->
array, da->
num);
228 static inline void darray_insert(
const size_t element_size,
struct darray *dst,
229 const size_t idx,
const void *item)
234 assert(idx <= dst->num);
236 if (idx == dst->
num) {
237 darray_push_back(element_size, dst, item);
241 move_count = dst->
num - idx;
242 darray_ensure_capacity(element_size, dst, ++dst->
num);
244 new_item = darray_item(element_size, dst, idx);
246 memmove(darray_item(element_size, dst, idx+1), new_item,
247 move_count*element_size);
248 memcpy(new_item, item, element_size);
251 static inline void *darray_insert_new(
const size_t element_size,
252 struct darray *dst,
const size_t idx)
257 assert(idx <= dst->num);
259 return darray_push_back_new(element_size, dst);
261 item = darray_item(element_size, dst, idx);
263 move_count = dst->
num - idx;
264 darray_ensure_capacity(element_size, dst, ++dst->
num);
265 memmove(darray_item(element_size, dst, idx+1), item,
266 move_count*element_size);
268 memset(item, 0, element_size);
272 static inline void darray_insert_array(
const size_t element_size,
273 struct darray *dst,
const size_t idx,
274 const void *array,
const size_t num)
278 assert(array != NULL);
280 assert(idx < dst->num);
283 darray_resize(element_size, dst, dst->
num+num);
285 memmove(darray_item(element_size, dst, idx+num),
286 darray_item(element_size, dst, idx),
287 element_size*(old_num-idx));
288 memcpy(darray_item(element_size, dst, idx), array, element_size*num);
291 static inline void darray_insert_darray(
const size_t element_size,
292 struct darray *dst,
const size_t idx,
const struct darray *da)
294 darray_insert_array(element_size, dst, idx, da->
array, da->
num);
297 static inline void darray_erase(
const size_t element_size,
struct darray *dst,
300 assert(idx < dst->num);
302 if (idx >= dst->
num || !--dst->
num)
305 memmove(darray_item(element_size, dst, idx),
306 darray_item(element_size, dst, idx+1),
307 element_size*(dst->
num-idx));
310 static inline void darray_erase_item(
const size_t element_size,
311 struct darray *dst,
const void *item)
313 size_t idx = darray_find(element_size, dst, item, 0);
315 darray_erase(element_size, dst, idx);
318 static inline void darray_erase_range(
const size_t element_size,
319 struct darray *dst,
const size_t start,
const size_t end)
321 size_t count, move_count;
323 assert(start <= dst->num);
324 assert(end <= dst->num);
329 darray_erase(element_size, dst, start);
331 }
else if (count == dst->
num) {
336 move_count = dst->
num - end;
338 memmove(darray_item(element_size, dst, start),
339 darray_item(element_size, dst, end),
340 move_count * element_size);
345 static inline void darray_pop_back(
const size_t element_size,
348 assert(dst->
num != 0);
351 darray_erase(element_size, dst, dst->
num-1);
354 static inline void darray_join(
const size_t element_size,
struct darray *dst,
357 darray_push_back_darray(element_size, dst, da);
361 static inline void darray_split(
const size_t element_size,
struct darray *dst1,
362 struct darray *dst2,
const struct darray *da,
const size_t idx)
366 assert(da->
num >= idx);
367 assert(dst1 != dst2);
370 darray_copy(element_size, &temp, da);
377 darray_copy_array(element_size, dst1, temp.
array,
379 if (idx < temp.
num-1)
380 darray_copy_array(element_size, dst2,
381 darray_item(element_size, &temp, idx),
388 static inline void darray_move_item(
const size_t element_size,
389 struct darray *dst,
const size_t from,
const size_t to)
391 void *temp, *p_from, *p_to;
396 temp = malloc(element_size);
397 p_from = darray_item(element_size, dst, from);
398 p_to = darray_item(element_size, dst, to);
400 memcpy(temp, p_from, element_size);
403 memmove(darray_item(element_size, dst, to+1), p_to,
404 element_size*(from-to));
406 memmove(p_from, darray_item(element_size, dst, from+1),
407 element_size*(to-from));
409 memcpy(p_to, temp, element_size);
413 static inline void darray_swap(
const size_t element_size,
414 struct darray *dst,
const size_t a,
const size_t b)
416 void *temp, *a_ptr, *b_ptr;
418 assert(a < dst->num);
419 assert(b < dst->num);
424 temp = malloc(element_size);
425 a_ptr = darray_item(element_size, dst, a);
426 b_ptr = darray_item(element_size, dst, b);
428 memcpy(temp, a_ptr, element_size);
429 memcpy(a_ptr, b_ptr, element_size);
430 memcpy(b_ptr, temp, element_size);
444 #define DARRAY(type) \ 454 #define da_init(v) darray_init(&v.da) 456 #define da_free(v) darray_free(&v.da) 458 #define da_alloc_size(v) (sizeof(*v.array)*v.num) 460 #define da_end(v) darray_end(sizeof(*v.array), &v.da) 462 #define da_reserve(v, capacity) \ 463 darray_reserve(sizeof(*v.array), &v.da, capacity) 465 #define da_resize(v, size) darray_resize(sizeof(*v.array), &v.da, size) 467 #define da_copy(dst, src) \ 468 darray_copy(sizeof(*dst.array), &dst.da, &src.da) 470 #define da_copy_array(dst, src_array, n) \ 471 darray_copy_array(sizeof(*dst.array), &dst.da, src_array, n) 473 #define da_move(dst, src) darray_move(&dst.da, &src.da) 475 #define da_find(v, item, idx) \ 476 darray_find(sizeof(*v.array), &v.da, item, idx) 478 #define da_push_back(v, item) darray_push_back(sizeof(*v.array), &v.da, item) 480 #define da_push_back_new(v) darray_push_back_new(sizeof(*v.array), &v.da) 482 #define da_push_back_array(dst, src_array, n) \ 483 darray_push_back_array(sizeof(*dst.array), &dst.da, src_array, n) 485 #define da_push_back_da(dst, src) \ 486 darray_push_back_darray(sizeof(*dst.array), &dst.da, &src.da) 488 #define da_insert(v, idx, item) \ 489 darray_insert(sizeof(*v.array), &v.da, idx, item) 491 #define da_insert_new(v, idx) \ 492 darray_insert_new(sizeof(*v.array), &v.da, idx) 494 #define da_insert_array(dst, idx, src_array, n) \ 495 darray_insert_array(sizeof(*dst.array), &dst.da, idx, \ 498 #define da_insert_da(dst, idx, src) \ 499 darray_insert_darray(sizeof(*dst.array), &dst.da, idx, \ 502 #define da_erase(dst, idx) \ 503 darray_erase(sizeof(*dst.array), &dst.da, idx) 505 #define da_erase_item(dst, item) \ 506 darray_erase_item(sizeof(*dst.array), &dst.da, item) 508 #define da_erase_range(dst, from, to) \ 509 darray_erase_range(sizeof(*dst.array), &dst.da, from, to) 511 #define da_pop_back(dst) \ 512 darray_pop_back(sizeof(*dst.array), &dst.da); 514 #define da_join(dst, src) \ 515 darray_join(sizeof(*dst.array), &dst.da, &src.da) 517 #define da_split(dst1, dst2, src, idx) \ 518 darray_split(sizeof(*src.array), &dst1.da, &dst2.da, \ 521 #define da_move_item(v, from, to) \ 522 darray_move_item(sizeof(*v.array), &v.da, from, to) 524 #define da_swap(v, idx1, idx2) \ 525 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)