Finished implementation (for now)

.gitignore

@@ -1 +1 @@
-hehe_array_test
+test

hehe_array_test.c

@@ -1,29 +0,0 @@
-#include <stdio.h>
-#include <stddef.h>
-#include <stdlib.h>
-#include <string.h>
-#include "libhehe_array.h"
-
-#define ARRAY_LEN 10
-#define ARRAY2_START_INDEX 2
-#define ARRAY2_LEN 4
-
-int main(void) {
-	struct HeheArray *array = hehe_alloc_array(ARRAY_LEN, sizeof(int));
-	int i;
-	for(i = 0; i < ARRAY_LEN; i++) hehe_array_set(array, ARRAY_LEN - i - 1, &i);
-	for(i = 0; i < ARRAY_LEN; i++) {
-		printf("%d\n", *(int *)hehe_array_get(array, i));
-	}
-	puts("\n\n");
-	struct HeheArray *array2 = hehe_array_yoink(array, ARRAY2_START_INDEX, ARRAY2_LEN);
-	if(array2 == NULL) return 69;
-	for(i = 0; i < ARRAY2_LEN; i++) {
-		printf("%d\n", *(int *)hehe_array_get(array2, i));
-	}
-	puts("\n\n");
-	for(i = 0; i < ARRAY_LEN - ARRAY2_LEN; i++) {
-		printf("%d\n", *(int *)hehe_array_get(array, i));
-	}
-	return 0;
-}

libhehe_array.h

@@ -1,5 +1,3 @@
-
-
 #ifndef HEHE_ARRAYLIB
 #define HEHE_ARRAYLIB
 
@@ -14,7 +12,7 @@ struct HeheArray {
 	void *content;
 };
 
-static void *hehe_alloc_array(size_t initial_len, size_t type_size) {
+static void *hehe_array_alloc(size_t initial_len, size_t type_size) {
 	if(initial_len == 0) initial_len = 1;
 	struct HeheArray *array = malloc(sizeof(*array));
 	array->len = initial_len;
@@ -28,6 +26,12 @@ static void *hehe_alloc_array(size_t initial_len, size_t type_size) {
 	return array;
 }
 
+static void hehe_array_free(struct HeheArray *array) {
+	free(array->content);
+	free(array);
+}
+
+
 static void hehe_array_set(struct HeheArray *array, size_t index, const void *value) {
 	if(index >= array->max_len) {
 		array->content = realloc(array->content, (array->max_len << 1) * array->type_size);
@@ -57,30 +61,74 @@ static void hehe_array_set_len(struct HeheArray *array, size_t new_len) {
 		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;
 }
 
+static void hehe_array_insert(struct HeheArray *array, size_t index, const void *value) {
+    hehe_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);
+}
+
+static void hehe_array_remove(struct HeheArray *array, size_t index, void *value) {
+    hehe_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);
+}
+
 static void hehe_array_push(struct HeheArray *array, const void *value) {
 	hehe_array_set(array, array->len, value);
 }
 
-static int hehe_array_pop(struct HeheArray *array, void *value) {
+static void hehe_array_pop(struct HeheArray *array, void *value) {
-	return hehe_array_copy(array, array->len, value) || ((array->len -= 1) && 0);
+	hehe_array_remove(array, array->len - 1, value);
+}
+
+static void hehe_array_delete(struct HeheArray *array, size_t index) {
+    hehe_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);
 }
 
 static struct HeheArray *hehe_array_yoink(struct HeheArray *array, size_t start_index, size_t len) {
 	if(start_index + len >= array->len) return NULL;
-	struct HeheArray *ret = hehe_alloc_array(len, array->type_size);
+	struct HeheArray *ret = hehe_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);
 	hehe_array_set_len(array, array->len - len);
 	return ret;
 }
 
-static void hehe_array_free(struct HeheArray *array) {
+static int hehe_array_insert_data(struct HeheArray *array, size_t index, void *data, size_t len) {
-	free(array->content);
+    if(index >= array->len) return -1;
-	free(array);
+    size_t current_len = array->len;
+    hehe_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;
+}
+
+static int hehe_array_plop(struct HeheArray *array, size_t index, struct HeheArray *array2) {
+    int ret = hehe_array_insert_data(array, index, array2->content, array2->len);
+    if(ret) return ret;
+    hehe_array_free(array2);
+    return 0;
+}
+
+typedef void (*Callback_func)(void *, size_t, struct HeheArray *);
+
+static void hehe_array_foreach(struct HeheArray *array, Callback_func callback) {
+    for(size_t i = 0; i < array->len; i++) callback(hehe_array_get(array, i), i, array);
+}
+
+static struct HeheArray *hehe_array_clone(struct HeheArray *array) {
+    struct HeheArray *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;
 }
 
 #endif

test.c

@@ -0,0 +1,85 @@
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include "libhehe_array.h"
+
+#define ARRAY_LEN 10
+
+void set(void *, size_t index, struct HeheArray *array) {
+    hehe_array_set(array, ARRAY_LEN - index - 1, &index);
+}
+
+void output(void *i, size_t, struct HeheArray *) {
+    printf("%d, ", *(int *)i);
+}
+
+
+int main(void) {
+	struct HeheArray *array = hehe_array_alloc(ARRAY_LEN, sizeof(int));
+
+    hehe_array_foreach(array, set);
+    puts("Expected value:\n9, 8, 7, 6, 5, 4, 3, 2, 1, 0,");
+    hehe_array_foreach(array, output);
+	puts("\n");
+
+	struct HeheArray *array2 = hehe_array_yoink(array, 2, 4);
+    puts("Expected value:\n7, 6, 5, 4,");
+    hehe_array_foreach(array2, output);
+	puts("\n");
+    puts("Expected value:\n9, 8, 3, 2, 1, 0,");
+    hehe_array_foreach(array, output);
+	puts("\n");
+    
+    const int k = 100;
+    hehe_array_insert(array2, 2, &k);
+    puts("Expected value:\n7, 6, 100, 5, 4,");
+    hehe_array_foreach(array2, output);
+	puts("\n");
+
+    int j;
+    hehe_array_remove(array2, 2, &j);
+    puts("Expected value:\n7, 6, 5, 0,\t100");
+    hehe_array_foreach(array2, output);
+    printf("\t%d", j);
+	puts("\n");
+
+    hehe_array_delete(array2, 3);
+    puts("Expected value:\n7, 6, 5");
+    hehe_array_foreach(array2, output);
+	puts("\n");
+
+    struct HeheArray *array3 = hehe_array_clone(array2);
+    hehe_array_plop(array2, 1, array3); //array3 is freed
+    puts("Expected value:\n7, 7, 6, 5, 6, 5,");
+    hehe_array_foreach(array2, output);
+	puts("\n");
+
+    hehe_array_pop(array2, &j);
+    puts("Expected value:\n7, 7, 6, 5, 6,\t0");
+    hehe_array_foreach(array2, output);
+    printf("\t%d", j);
+	puts("\n");
+
+    hehe_array_copy(array2, 2, &j);
+    hehe_array_push(array2, &j);
+    puts("Expected value:\n7, 7, 6, 5, 6, 6,");
+    hehe_array_foreach(array2, output);
+	puts("\n");
+
+    hehe_array_set_len(array, 2);
+    puts("Expected value:\n9, 8,");
+    hehe_array_foreach(array, output);
+	puts("\n");
+
+    hehe_array_set(array, 4, &j);
+    puts("Expected value:\n9, 8, 0, 0, 6,");
+    hehe_array_foreach(array, output);
+	puts("\n");
+    
+
+    hehe_array_free(array);
+    hehe_array_free(array2);
+	puts("\n");
+	return 0;
+}

test.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+rm test
+cc=clang
+test "" = "$(which clang 2>&1)" && cc=gcc
+$cc -Ofast -Wall -Wextra -o test test.c
+./test