seoxi/libkeke
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Used typedef

Browse Source
This commit is contained in:
Seoxi Ryouko
2025-06-06 10:02:35 -05:00
parent 8fb4ca0749
commit 35f0d4cc10
2 changed files with 54 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
libkeke_array.c
View File

@ -11,16 +11,9 @@
#define ARRAY_GET(array, i) ((array)->content + (array)->type_size * (i))
struct KekeArray {
size_t type_size;
size_t len;
size_t max_len;
void *content;
};
void *keke_array_alloc(size_t initial_len, size_t type_size) {
KekeArray *keke_array_alloc(size_t initial_len, size_t type_size) {
//if(initial_len == 0) initial_len = 1;
struct KekeArray *array = malloc(sizeof(*array));
KekeArray *array = malloc(sizeof(*array));
array->len = initial_len;
size_t max_len = 1;
while(initial_len >>= 1) max_len <<= 1;
@ -32,13 +25,13 @@ void *keke_array_alloc(size_t initial_len, size_t type_size) {
return array;
}
void keke_array_free(struct KekeArray *array) {
void keke_array_free(KekeArray *array) {
free(array->content);
free(array);
}
void keke_array_set(struct KekeArray *array, size_t index, const void *value) {
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);
@ -48,18 +41,18 @@ void keke_array_set(struct KekeArray *array, size_t index, const void *value) {
memcpy(array->content + index * array->type_size, value, array->type_size);
}
void *keke_array_get(struct KekeArray *array, size_t index) {
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(struct KekeArray *array, size_t index, void *value) {
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(struct KekeArray *array, size_t new_len) {
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;
@ -73,41 +66,41 @@ void keke_array_set_len(struct KekeArray *array, size_t new_len) {
array->len = new_len;
}
void keke_array_insert(struct KekeArray *array, size_t index, const void *value) {
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(struct KekeArray *array, size_t index, void *value) {
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(struct KekeArray *array, const void *value) {
void keke_array_push(KekeArray *array, const void *value) {
keke_array_set(array, array->len, value);
}
void keke_array_pop(struct KekeArray *array, void *value) {
void keke_array_pop(KekeArray *array, void *value) {
keke_array_remove(array, array->len - 1, value);
}
void keke_array_delete(struct KekeArray *array, size_t index) {
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);
}
struct KekeArray *keke_array_yoink(struct KekeArray *array, size_t start_index, size_t len) {
KekeArray *keke_array_yoink(KekeArray *array, size_t start_index, size_t len) {
if(start_index + len >= array->len) return NULL;
struct KekeArray *ret = keke_array_alloc(len, array->type_size);
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(struct KekeArray *array, size_t index, void *data, size_t len) {
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);
@ -116,53 +109,53 @@ int keke_array_insert_data(struct KekeArray *array, size_t index, void *data, si
return 0;
}
int keke_array_plop(struct KekeArray *array, size_t index, struct KekeArray *array2) {
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, struct KekeArray *);
typedef void (*Foreach_func)(void *, size_t, KekeArray *);
void keke_array_foreach(struct KekeArray *array, Foreach_func callback) {
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);
}
struct KekeArray *keke_array_clone(struct KekeArray *array) {
struct KekeArray *ret = malloc(sizeof(*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(struct KekeArray *array, const void *value) {
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(struct KekeArray *array) {
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, struct KekeArray *);
typedef bool (*Test_func)(void *, size_t, KekeArray *);
bool keke_array_some(struct KekeArray *array, Test_func test) {
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(struct KekeArray *array, Test_func test) {
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;
}
struct KekeArray *keke_array_filter(struct KekeArray *array, Test_func test) {
struct KekeArray *ret = keke_array_alloc(0, array->type_size);
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));
@ -173,7 +166,7 @@ struct KekeArray *keke_array_filter(struct KekeArray *array, Test_func test) {
typedef void (*B_func)(void *, void *);
void keke_array_reduce(struct KekeArray *array, B_func op, void *acc) {
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);
}

52
libkeke_array.h
View File

@ -5,45 +5,45 @@
#include <stdint.h>
#include <stdbool.h>
struct KekeArray {
typedef struct {
size_t type_size;
size_t len;
size_t max_len;
void *content;
};
} KekeArray;
void *keke_array_alloc(size_t initial_len, size_t type_size);
void keke_array_free(struct KekeArray *array);
KekeArray *keke_array_alloc(size_t initial_len, size_t type_size);
void keke_array_free(KekeArray *array);
void keke_array_set(struct KekeArray *array, size_t index, const void *value);
void *keke_array_get(struct KekeArray *array, size_t index);
void keke_array_set(KekeArray *array, size_t index, const void *value);
void *keke_array_get(KekeArray *array, size_t index);
int keke_array_copy(struct KekeArray *array, size_t index, void *value);
void keke_array_set_len(struct KekeArray *array, size_t new_len);
void keke_array_insert(struct KekeArray *array, size_t index, const void *value);
void keke_array_remove(struct KekeArray *array, size_t index, void *value);
void keke_array_push(struct KekeArray *array, const void *value);
void keke_array_pop(struct KekeArray *array, void *value);
void keke_array_delete(struct KekeArray *array, size_t index);
int keke_array_copy(KekeArray *array, size_t index, void *value);
void keke_array_set_len(KekeArray *array, size_t new_len);
void keke_array_insert(KekeArray *array, size_t index, const void *value);
void keke_array_remove(KekeArray *array, size_t index, void *value);
void keke_array_push(KekeArray *array, const void *value);
void keke_array_pop(KekeArray *array, void *value);
void keke_array_delete(KekeArray *array, size_t index);
struct KekeArray *keke_array_yoink(struct KekeArray *array, size_t start_index, size_t len);
int keke_array_insert_data(struct KekeArray *array, size_t index, void *data, size_t len);
int keke_array_plop(struct KekeArray *array, size_t index, struct KekeArray *array2);
KekeArray *keke_array_yoink(KekeArray *array, size_t start_index, size_t len);
int keke_array_insert_data(KekeArray *array, size_t index, void *data, size_t len);
int keke_array_plop(KekeArray *array, size_t index, KekeArray *array2);
typedef void (*Foreach_func)(void *, size_t, struct KekeArray *);
void keke_array_foreach(struct KekeArray *array, Foreach_func callback);
struct KekeArray *keke_array_clone(struct KekeArray *array);
typedef void (*Foreach_func)(void *, size_t, KekeArray *);
void keke_array_foreach(KekeArray *array, Foreach_func callback);
KekeArray *keke_array_clone(KekeArray *array);
void keke_array_fill(struct KekeArray *array, const void *value);
void keke_array_reverse(struct KekeArray *array);
void keke_array_fill(KekeArray *array, const void *value);
void keke_array_reverse(KekeArray *array);
typedef bool (*Test_func)(void *, size_t, struct KekeArray *);
bool keke_array_some(struct KekeArray *array, Test_func test);
bool keke_array_all(struct KekeArray *array, Test_func test);
typedef bool (*Test_func)(void *, size_t, KekeArray *);
bool keke_array_some(KekeArray *array, Test_func test);
bool keke_array_all(KekeArray *array, Test_func test);
struct KekeArray *keke_array_filter(struct KekeArray *array, Test_func test);
KekeArray *keke_array_filter(KekeArray *array, Test_func test);
typedef void (*B_func)(void *, void *);
void keke_array_reduce(struct KekeArray *array, B_func op, void *acc);
void keke_array_reduce(KekeArray *array, B_func op, void *acc);
#endif