array.c

#include <kiba/containers/array.h>
 
#include <kiba/core/memory.h>
 
static inline void *_array_pointer_at_offset(void *arr, usize offset) {
    array_header *header = _array_get_header(arr);
    return (u8 *) (arr) + (offset * header->element_size);
}
 
void *_array_create(usize initial_capacity, usize element_size, usize element_alignment, allocator *alloc) {
    KB_ASSERT(alloc != KB_NULL, "allocator to use must be a valid pointer");
    KB_ASSERT(initial_capacity != 0, "initial capacity must not be 0");
    array_header *res = allocator_allocate_aligned(alloc,
                                                   initial_capacity * element_size + sizeof(array_header),
                                                   KB_MAX(element_alignment, 8));
    if (res != KB_NULL) {
        res->size     = 0;
        res->capacity = initial_capacity;
        res->element_size = element_size;
        res->alloc    = alloc;
        ++res;
    }
    return res;
}
 
void array_destroy(void *arr_ptr) {
    void **arr = arr_ptr;
    KB_ASSERT(arr != KB_NULL, "array must have initialized state");
    if (*arr != KB_NULL) {
        array_header *header = _array_get_header(*arr);
        allocator_free(header->alloc, header);
        *arr = KB_NULL;
    }
}
 
b8 array_reserve(void *arr_ptr, usize new_capacity) {
    void        **arr    = arr_ptr;
    array_header *header = _array_get_header(*arr);
    if (new_capacity > header->capacity) {
        array_header *new_arr =
            allocator_reallocate(header->alloc, header, new_capacity * header->element_size + sizeof(array_header));
        if (new_arr == KB_NULL) {
            return false;
        }
        new_arr->capacity = new_capacity;
        ++new_arr;
        *arr = new_arr;
    }
    return true;
}
 
b8 array_resize(void *arr_ptr, usize new_size) {
    void        **arr    = arr_ptr;
    array_header *header = _array_get_header(*arr);
    if (new_size > header->capacity) {
        if (!array_reserve(arr, new_size)) {
            return false;
        }
        header = _array_get_header(*arr);
    }
    if (new_size > header->size) {
        memory_zero((u8 *) *arr + header->size * header->element_size,
                    (new_size - header->size) * header->element_size);
    }
    header->size = new_size;
    return true;
}
 
void *array_clone(const void *arr, allocator *alloc) {
    // TODO shoud the new array have the same capacity or just the necessary space
    void *new_arr = _array_create(array_size(arr), array_element_size(arr), 1, alloc);
    if (new_arr != KB_NULL) {
        memory_copy(new_arr, arr, array_size(arr) * array_element_size(arr));
    }
    return new_arr;
}
 
b8 array_push_checked(void *arr_ptr, void *element) {
    void **arr = arr_ptr;
    KB_ASSERT(arr != KB_NULL && *arr != KB_NULL, "array must have initialized state");
    KB_ASSERT(element != KB_NULL, "pointer to element must be valid");
    array_header *header = _array_get_header(*arr);
    KB_ASSERT(header->size <= header->capacity,
              "array capacity must not have been exceeded beforehand size: {usize} vs capacity: {usize}",
              header->size,
              header->capacity);
    if (header->size == header->capacity) {
        if (!array_reserve(arr, header->capacity * 2)) {
            return false;
        }
        header = _array_get_header(*arr);
    }
    memory_copy(_array_pointer_at_offset(*arr, header->size++), element, header->element_size);
    return true;
}
 
b8 array_pop_checked(void *arr_ptr, void *element) {
    void **arr = arr_ptr;
    KB_ASSERT(arr != KB_NULL && *arr != KB_NULL, "array must have initialized state");
    array_header *header = _array_get_header(*arr);
    if (header->size == 0) {
        return false;
    }
    --header->size;
    if (element != KB_NULL) {
        memory_copy(element, _array_pointer_at_offset(*arr, header->size), header->element_size);
    }
    return true;
}
 
b8 array_insert(void *arr_ptr, usize index, void *element) {
    void **arr = arr_ptr;
    KB_ASSERT(arr != KB_NULL && *arr != KB_NULL, "array must have initialized state");
    KB_ASSERT(element != KB_NULL, "pointer to read data from must not be nullptr");
    array_header *header = _array_get_header(*arr);
    if (index > header->size) {
        KB_WARN("index out of range: index {usize} requested but array size only {usize}", index, header->size);
        return false;
    }
    if (!array_push_checked(arr, element)) {
        return false;
    }
    // move elements one index further starting from the back
    usize move_count = header->size - index;
    for (usize i = 0; i < move_count; ++i) {
        memory_copy(_array_pointer_at_offset(*arr, header->size - 1 - i),
                    _array_pointer_at_offset(*arr, header->size - 2 - i),
                    header->element_size);
    }
    memory_copy(_array_pointer_at_offset(*arr, index), element, header->element_size);
    return true;
}
 
b8 array_remove(void *arr_ptr, usize index, void *element) {
    void **arr = arr_ptr;
    KB_ASSERT(arr != KB_NULL && *arr != KB_NULL, "array must have initialized state");
    array_header *header = _array_get_header(*arr);
    if (index >= header->size) {
        KB_WARN("index out of range in array: index {usize} requested but array size only {usize}",
                index,
                header->size);
        return false;
    }
    usize move_count = header->size - index;
    if (element != KB_NULL) {
        memory_copy(element, _array_pointer_at_offset(*arr, index), header->element_size);
    }
    if (move_count > 0) {
        memory_copy(_array_pointer_at_offset(*arr, index),
                    _array_pointer_at_offset(*arr, index + 1),
                    move_count * header->element_size);
    }
    --header->size;
    return true;
}