libkeke/libkeke_array.c

#ifndef LIBKEKE_ARRAY
#define LIBKEKE_ARRAY

#include <stddef.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <stdbool.h>
#include "libkeke_utils.h"
#include "libkeke_array.h"

#define ARRAY_GET(array, i) ((array)->content + (array)->type_size * (i))

KekeArray *keke_array_alloc(size_t initial_len, size_t type_size) {
	//if(initial_len == 0) initial_len = 1;
	KekeArray *array = malloc(sizeof(*array));
	array->len = initial_len;
	size_t max_len = 1;
	while(initial_len >>= 1) max_len <<= 1;

	array->type_size = type_size;
	array->max_len = max_len;
	array->content = malloc(max_len * type_size);
	memset(array->content, 0, max_len * type_size);
	return array;
}

void keke_array_free(KekeArray *array) {
	free(array->content);
	free(array);
}


void keke_array_set(KekeArray *array, size_t index, const void *value) {
	if(index >= array->max_len) {
		array->content = realloc(array->content, (array->max_len << 1) * array->type_size);
		memset(array->content + array->max_len * array->type_size, 0, array->max_len * array->type_size);
		array->max_len <<= 1;
	}
	if(index >= array->len) array->len = index + 1;
	memcpy(array->content + index * array->type_size, value, array->type_size);
}

void *keke_array_get(KekeArray *array, size_t index) {
	if(index >= array->len) return NULL; // is ur fault
	return ARRAY_GET(array, index);
}

int keke_array_copy(KekeArray *array, size_t index, void *value) {
	if(index >= array->len) return -1; // is ur fault
	memcpy(value, ARRAY_GET(array, index), array->type_size);
	return 0;
}

void keke_array_set_len(KekeArray *array, size_t new_len) {
	if(new_len >= array->max_len) {
		size_t new_max_len = 1;
		size_t len = new_len;
		while(len >>= 1) new_max_len <<= 1;
		array->content = realloc(array->content, new_max_len * array->type_size);
		memset(array->content + array->max_len * array->type_size, 0, (new_max_len - array->max_len) * array->type_size);
		array->max_len <<= 1;
	} else if(new_len < array->len) {
        memset(array->content + new_len * array->type_size, 0, (array->len - new_len) * array->type_size);
    }
	array->len = new_len;
}

void keke_array_insert(KekeArray *array, size_t index, const void *value) {
    keke_array_set_len(array, array->len + 1);
    memmove(array->content + ((index + 1) * array->type_size), array->content + (index * array->type_size), (array->len - index - 1) * array->type_size);
    memcpy(array->content + index * array->type_size, value, array->type_size);
}

void keke_array_remove(KekeArray *array, size_t index, void *value) {
    keke_array_set_len(array, array->len - 1);
    memcpy(value, array->content + index * array->type_size, array->type_size);
    memmove(array->content + (index * array->type_size), array->content + ((index + 1) * array->type_size), (array->len - index + 1) * array->type_size);
}

void keke_array_push(KekeArray *array, const void *value) {
	keke_array_set(array, array->len, value);
}

void keke_array_pop(KekeArray *array, void *value) {
	keke_array_remove(array, array->len - 1, value);
}

void keke_array_delete(KekeArray *array, size_t index) {
    keke_array_set_len(array, array->len - 1);
    memmove(array->content + (index * array->type_size), array->content + ((index + 1) * array->type_size), (array->len - index + 1) * array->type_size);
}

KekeArray *keke_array_yoink(KekeArray *array, size_t start_index, size_t len) {
	if(start_index + len >= array->len) return NULL;
	KekeArray *ret = keke_array_alloc(len, array->type_size);
	memcpy(ret->content, array->content + start_index * array->type_size, len * array->type_size);
	memmove(array->content + start_index * array->type_size, array->content + (start_index + len) * array->type_size, (array->len - len - start_index) * array->type_size);
	keke_array_set_len(array, array->len - len);
	return ret;
}

int keke_array_insert_data(KekeArray *array, size_t index, void *data, size_t len) {
    if(index >= array->len) return -1;
    size_t current_len = array->len;
    keke_array_set_len(array, current_len + len);
    memmove(array->content + (index + len) * array->type_size, array->content + index * array->type_size, (current_len - index) * array->type_size);
    memcpy(array->content + index * array->type_size, data, len * array->type_size);
    return 0;
}

int keke_array_plop(KekeArray *array, size_t index, KekeArray *array2) {
    int ret = keke_array_insert_data(array, index, array2->content, array2->len);
    if(ret) return ret;
    keke_array_free(array2);
    return 0;
}

typedef void (*Foreach_func)(void *, size_t, KekeArray *);

void keke_array_foreach(KekeArray *array, Foreach_func callback) {
    for(size_t i = 0; i < array->len; i++) callback(ARRAY_GET(array, i), i, array);
}

KekeArray *keke_array_clone(KekeArray *array) {
    KekeArray *ret = malloc(sizeof(*array));
    memcpy(ret, array, sizeof(*array));
    ret->content = malloc(array->max_len * array->type_size);
    memcpy(ret->content, array->content, array->max_len * array->type_size);
    return ret;
}

void keke_array_fill(KekeArray *array, const void *value) {
    for(size_t i = 0; i < array->len; i++) memcpy(ARRAY_GET(array, i), value, array->type_size);
}

void keke_array_reverse(KekeArray *array) {
    for(size_t i = 0; i < array->len / 2; i++) {
    	keke_swap(ARRAY_GET(array, i), array->content + array->type_size * (array->len - i - 1), array->type_size);
    }
}

typedef bool (*Test_func)(void *, size_t, KekeArray *);

bool keke_array_some(KekeArray *array, Test_func test) {
	bool ret = false;
    for(size_t i = 0; i < array->len; i++) ret = ret || test(ARRAY_GET(array, i), i, array);	
    return ret;
}

bool keke_array_all(KekeArray *array, Test_func test) {
	bool ret = true;
    for(size_t i = 0; i < array->len; i++) ret = ret && test(ARRAY_GET(array, i), i, array);	
    return ret;
}

KekeArray *keke_array_filter(KekeArray *array, Test_func test) {
	KekeArray *ret = keke_array_alloc(0, array->type_size);
    for(size_t i = 0; i < array->len; i++) {
    	if(test(ARRAY_GET(array, i), i, array)) {
    		keke_array_push(ret, ARRAY_GET(array, i));
    	}
    }
    return ret;
}

typedef void (*B_func)(void *, void *);

void keke_array_reduce(KekeArray *array, B_func op, void *acc) {
	for(size_t i = 0; i < array->len; i++) op(ARRAY_GET(array, i), acc);
}

#undef ARRAY_GET

#endif