Added merge

justfile

@@ -2,7 +2,7 @@
 test_all: && test_array test_symbol
 
 test_array:
-	zig cc -o test_array -std=c23 test_array.c libkeke_array.c libkeke_utils.c
+	zig cc -o test_array -std=gnu23 test_array.c libkeke_array.c libkeke_utils.c
 	./test_array
 
 test_symbol:

libkeke_array.c

@@ -6,6 +6,7 @@
 #include <stdint.h>
 #include <string.h>
 #include <stdbool.h>
+#include <stdio.h>
 #include "libkeke_utils.h"
 #include "libkeke_array.h"
 
@@ -81,8 +82,8 @@ void keke_array_insert(KekeArray *array, size_t index, const 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);
+    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);
 }
 
@@ -184,6 +185,50 @@ void *keke_array_find_start(KekeArray *array, void *start, size_t size) {
     return NULL;
 }
 
+int compar(const void *a, const void *b, void *size_v) {
+	size_t *size = size_v;
+	return memcmp(a, b, *size);
+}
+
+void keke_array_qsort(KekeArray *array) {
+	qsort_r(array->content, array->len, array->type_size, compar, &array->type_size);
+}
+
+void keke_array_qsort_header(KekeArray *array, size_t start_header_size) {
+	qsort_r(array->content, array->len, array->type_size, compar, &start_header_size);
+}
+
+// requires pre-sorted arrays
+KekeArray *keke_array_merge(KekeArray *a, KekeArray *b) {
+	if(a->len == 0) return keke_array_clone(b);
+	if(b->len == 0) return keke_array_clone(a);
+	keke_array_reverse(a);
+	keke_array_reverse(b);
+	if(a->type_size != b->type_size) return NULL;
+	KekeArray *c = keke_array_alloc(a->len + b->len, a->type_size);
+	keke_array_set_len(c, 0);
+	void *s = malloc(a->type_size);
+	while(!!(a->len) && !!(b->len)) {
+		if(memcmp(ARRAY_GET(a, a->len - 1), ARRAY_GET(b, b->len - 1), a->type_size) <= 0) {
+			keke_array_pop(a, s)	;
+			keke_array_push(c, s);
+		} else {
+			keke_array_pop(b, s);
+			keke_array_push(c, s);
+		}
+	}
+	while(a->len) {
+		keke_array_pop(a, s);
+		keke_array_push(c, s);
+	}
+	while(b->len) {
+		keke_array_pop(b, s);
+		keke_array_push(c, s);
+	}
+	free(s);
+	return c;
+}
+
 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++) {

libkeke_array.h

@@ -37,6 +37,10 @@ KekeArray *keke_array_clone(KekeArray *array);
 void keke_array_fill(KekeArray *array, const void *value);
 void keke_array_reverse(KekeArray *array);
 
+void keke_array_qsort(KekeArray *array);
+void keke_array_qsort_header(KekeArray *array, size_t start_header_size);
+KekeArray *keke_array_merge(KekeArray *a, KekeArray *b);
+
 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);

test_array.c

@@ -114,13 +114,18 @@ int main(void) {
 	keke_array_foreach(array2, output);
 	puts("\n");
 
+	keke_array_qsort(array2);
+    puts("Expected value:\n1, 2, 2, 2, 3, 3,");
+	keke_array_foreach(array2, output);
+	puts("\n");
+
 	bool h = keke_array_some(array2, heart);
 	bool g = keke_array_all(array2, heart);
     puts("Expected value:\nTrue, False");
     printf("%s, %s\n\n", BOOL_PRETTY(h), BOOL_PRETTY(g));
 
 	KekeArray *array4 = keke_array_filter(array2, heart);
-    puts("Expected value:\n2, 2, 1, 2,");
+    puts("Expected value:\n1, 2, 2, 2,");
 	keke_array_foreach(array4, output);
 	puts("\n");
 
@@ -136,8 +141,20 @@ int main(void) {
 	keke_array_reduce(array4, add, &j);
 	printf("Expected value:\n7\n%d\n\n", j);
 
+	keke_array_foreach(array, set);
+	keke_array_qsort_header(array, sizeof(int));
+	/*keke_array_foreach(array, output);
+	puts("\n");
+	keke_array_foreach(array2, output);
+	puts("\n");*/
+	KekeArray *array5 = keke_array_merge(array, array2);
+	printf("Expected value:\n0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 4, 5, 6, 7, 8, 9,\n");
+	keke_array_foreach(array5, output);
+	puts("\n");
+
     keke_array_free(array);
     keke_array_free(array2);
     keke_array_free(array4);
+    keke_array_free(array5);
 	return 0;
 }