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)
217 darray_resize(element_size, dst, dst->
num+num);
218 memcpy(darray_item(element_size, dst, old_num), array,
224 static inline size_t darray_push_back_darray(
const size_t element_size,
227 return darray_push_back_array(element_size, dst, da->
array, da->
num);
230 static inline void darray_insert(
const size_t element_size,
struct darray *dst,
231 const size_t idx,
const void *item)
236 assert(idx <= dst->num);
238 if (idx == dst->
num) {
239 darray_push_back(element_size, dst, item);
243 move_count = dst->
num - idx;
244 darray_ensure_capacity(element_size, dst, ++dst->
num);
246 new_item = darray_item(element_size, dst, idx);
248 memmove(darray_item(element_size, dst, idx+1), new_item,
249 move_count*element_size);
250 memcpy(new_item, item, element_size);
253 static inline void *darray_insert_new(
const size_t element_size,
254 struct darray *dst,
const size_t idx)
259 assert(idx <= dst->num);
261 return darray_push_back_new(element_size, dst);
263 item = darray_item(element_size, dst, idx);
265 move_count = dst->
num - idx;
266 darray_ensure_capacity(element_size, dst, ++dst->
num);
267 memmove(darray_item(element_size, dst, idx+1), item,
268 move_count*element_size);
270 memset(item, 0, element_size);
274 static inline void darray_insert_array(
const size_t element_size,
275 struct darray *dst,
const size_t idx,
276 const void *array,
const size_t num)
280 assert(array != NULL);
282 assert(idx < dst->num);
285 darray_resize(element_size, dst, dst->
num+num);
287 memmove(darray_item(element_size, dst, idx+num),
288 darray_item(element_size, dst, idx),
289 element_size*(old_num-idx));
290 memcpy(darray_item(element_size, dst, idx), array, element_size*num);
293 static inline void darray_insert_darray(
const size_t element_size,
294 struct darray *dst,
const size_t idx,
const struct darray *da)
296 darray_insert_array(element_size, dst, idx, da->
array, da->
num);
299 static inline void darray_erase(
const size_t element_size,
struct darray *dst,
302 assert(idx < dst->num);
304 if (idx >= dst->
num || !--dst->
num)
307 memmove(darray_item(element_size, dst, idx),
308 darray_item(element_size, dst, idx+1),
309 element_size*(dst->
num-idx));
312 static inline void darray_erase_item(
const size_t element_size,
313 struct darray *dst,
const void *item)
315 size_t idx = darray_find(element_size, dst, item, 0);
317 darray_erase(element_size, dst, idx);
320 static inline void darray_erase_range(
const size_t element_size,
321 struct darray *dst,
const size_t start,
const size_t end)
323 size_t count, move_count;
325 assert(start <= dst->num);
326 assert(end <= dst->num);
331 darray_erase(element_size, dst, start);
333 }
else if (count == dst->
num) {
338 move_count = dst->
num - end;
340 memmove(darray_item(element_size, dst, start),
341 darray_item(element_size, dst, end),
342 move_count * element_size);
347 static inline void darray_pop_back(
const size_t element_size,
350 assert(dst->
num != 0);
353 darray_erase(element_size, dst, dst->
num-1);
356 static inline void darray_join(
const size_t element_size,
struct darray *dst,
359 darray_push_back_darray(element_size, dst, da);
363 static inline void darray_split(
const size_t element_size,
struct darray *dst1,
364 struct darray *dst2,
const struct darray *da,
const size_t idx)
368 assert(da->
num >= idx);
369 assert(dst1 != dst2);
372 darray_copy(element_size, &temp, da);
379 darray_copy_array(element_size, dst1, temp.
array,
381 if (idx < temp.
num-1)
382 darray_copy_array(element_size, dst2,
383 darray_item(element_size, &temp, idx),
390 static inline void darray_move_item(
const size_t element_size,
391 struct darray *dst,
const size_t from,
const size_t to)
393 void *temp, *p_from, *p_to;
398 temp = malloc(element_size);
399 p_from = darray_item(element_size, dst, from);
400 p_to = darray_item(element_size, dst, to);
402 memcpy(temp, p_from, element_size);
405 memmove(darray_item(element_size, dst, to+1), p_to,
406 element_size*(from-to));
408 memmove(p_from, darray_item(element_size, dst, from+1),
409 element_size*(to-from));
411 memcpy(p_to, temp, element_size);
415 static inline void darray_swap(
const size_t element_size,
416 struct darray *dst,
const size_t a,
const size_t b)
418 void *temp, *a_ptr, *b_ptr;
420 assert(a < dst->num);
421 assert(b < dst->num);
426 temp = malloc(element_size);
427 a_ptr = darray_item(element_size, dst, a);
428 b_ptr = darray_item(element_size, dst, b);
430 memcpy(temp, a_ptr, element_size);
431 memcpy(a_ptr, b_ptr, element_size);
432 memcpy(b_ptr, temp, element_size);
446 #define DARRAY(type) \ 456 #define da_init(v) darray_init(&v.da) 458 #define da_free(v) darray_free(&v.da) 460 #define da_alloc_size(v) (sizeof(*v.array)*v.num) 462 #define da_end(v) darray_end(sizeof(*v.array), &v.da) 464 #define da_reserve(v, capacity) \ 465 darray_reserve(sizeof(*v.array), &v.da, capacity) 467 #define da_resize(v, size) darray_resize(sizeof(*v.array), &v.da, size) 469 #define da_copy(dst, src) \ 470 darray_copy(sizeof(*dst.array), &dst.da, &src.da) 472 #define da_copy_array(dst, src_array, n) \ 473 darray_copy_array(sizeof(*dst.array), &dst.da, src_array, n) 475 #define da_move(dst, src) darray_move(&dst.da, &src.da) 477 #define da_find(v, item, idx) \ 478 darray_find(sizeof(*v.array), &v.da, item, idx) 480 #define da_push_back(v, item) darray_push_back(sizeof(*v.array), &v.da, item) 482 #define da_push_back_new(v) darray_push_back_new(sizeof(*v.array), &v.da) 484 #define da_push_back_array(dst, src_array, n) \ 485 darray_push_back_array(sizeof(*dst.array), &dst.da, src_array, n) 487 #define da_push_back_da(dst, src) \ 488 darray_push_back_darray(sizeof(*dst.array), &dst.da, &src.da) 490 #define da_insert(v, idx, item) \ 491 darray_insert(sizeof(*v.array), &v.da, idx, item) 493 #define da_insert_new(v, idx) \ 494 darray_insert_new(sizeof(*v.array), &v.da, idx) 496 #define da_insert_array(dst, idx, src_array, n) \ 497 darray_insert_array(sizeof(*dst.array), &dst.da, idx, \ 500 #define da_insert_da(dst, idx, src) \ 501 darray_insert_darray(sizeof(*dst.array), &dst.da, idx, \ 504 #define da_erase(dst, idx) \ 505 darray_erase(sizeof(*dst.array), &dst.da, idx) 507 #define da_erase_item(dst, item) \ 508 darray_erase_item(sizeof(*dst.array), &dst.da, item) 510 #define da_erase_range(dst, from, to) \ 511 darray_erase_range(sizeof(*dst.array), &dst.da, from, to) 513 #define da_pop_back(dst) \ 514 darray_pop_back(sizeof(*dst.array), &dst.da); 516 #define da_join(dst, src) \ 517 darray_join(sizeof(*dst.array), &dst.da, &src.da) 519 #define da_split(dst1, dst2, src, idx) \ 520 darray_split(sizeof(*src.array), &dst1.da, &dst2.da, \ 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) \ 527 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)