121 lines
3.0 KiB
C
121 lines
3.0 KiB
C
/*
|
|
* SPDX-FileCopyrightText: 2025 William Bell
|
|
*
|
|
* SPDX-License-Identifier: GPL-3.0-or-later
|
|
*/
|
|
|
|
#include "darray.h"
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include "../memory.h"
|
|
|
|
void darray_init(DArray *arr, size_t element_size) {
|
|
arr->element_size = element_size;
|
|
arr->size = 0;
|
|
arr->capacity = CHUNK_SIZE / element_size;
|
|
arr->data = checked_malloc(CHUNK_SIZE); // fixed byte allocation
|
|
arr->resizable = true;
|
|
}
|
|
|
|
void darray_resize(DArray *arr, size_t new_size) {
|
|
if (!arr->resizable) {
|
|
fprintf(stderr, "darray_resize: unresizable darray\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
// Determine number of full chunks needed to store new_size elements
|
|
size_t required_bytes = new_size * arr->element_size;
|
|
size_t new_capacity_bytes = required_bytes*2;
|
|
size_t new_capacity = new_capacity_bytes / arr->element_size;
|
|
if (!new_capacity) {
|
|
return;
|
|
}
|
|
|
|
if (new_capacity != arr->capacity) {
|
|
void *new_data = realloc(arr->data, new_capacity_bytes);
|
|
if (!new_data) {
|
|
fprintf(stderr, "darray_resize: reallocation failed\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
arr->data = new_data;
|
|
arr->capacity = new_capacity;
|
|
}
|
|
|
|
arr->size = new_size;
|
|
}
|
|
|
|
void darray_push(DArray *arr, void *element) {
|
|
if (!arr->resizable) {
|
|
fprintf(stderr, "darray_resize: unresizable darray\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
if (arr->size >= arr->capacity) {
|
|
darray_resize(arr, arr->size + 1);
|
|
} else {
|
|
arr->size++;
|
|
}
|
|
|
|
void *target = (char *)arr->data + (arr->size - 1) * arr->element_size;
|
|
memcpy(target, element, arr->element_size);
|
|
}
|
|
|
|
void darray_pop(DArray *arr, void (*free_data)(void *)) {
|
|
if (!arr->resizable) {
|
|
fprintf(stderr, "darray_resize: unresizable darray\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
if (arr->size == 0)
|
|
return;
|
|
|
|
if (free_data) {
|
|
void *target = (char *)arr->data + (arr->size-1) * arr->element_size;
|
|
free_data(target);
|
|
}
|
|
|
|
darray_resize(arr, arr->size-1);
|
|
}
|
|
|
|
void *darray_get(DArray *arr, size_t index) {
|
|
if (index >= arr->size) {
|
|
fprintf(stderr, "darray_get: index out of bounds\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
return (char *)arr->data + index * arr->element_size;
|
|
}
|
|
|
|
DArray darray_slice(DArray *arr, size_t start, size_t end) {
|
|
if (start > end || end > arr->size) {
|
|
fprintf(stderr, "darray_slice: invalid slice range\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
DArray slice;
|
|
|
|
slice.data = (char *)arr->data + start * arr->element_size;
|
|
slice.size = (end - start);
|
|
slice.element_size = arr->element_size;
|
|
slice.capacity = ((slice.size + CHUNK_SIZE) / CHUNK_SIZE) * CHUNK_SIZE;
|
|
slice.resizable = false;
|
|
|
|
return slice;
|
|
}
|
|
|
|
void darray_free(DArray *arr, void (*free_data)(void *)) {
|
|
if (!arr->resizable) {
|
|
// It's a view/slice — don't free
|
|
return;
|
|
}
|
|
if (free_data) {
|
|
for (size_t i = 0; i < arr->size; ++i) {
|
|
void *element = (char *)arr->data + i * arr->element_size;
|
|
free_data(element);
|
|
}
|
|
}
|
|
free(arr->data);
|
|
arr->data = NULL;
|
|
arr->size = 0;
|
|
arr->capacity = 0;
|
|
arr->element_size = 0;
|
|
arr->resizable = false;
|
|
} |