array: allow arbitrarily sized array elements

There exist two typical ways to use an array:

 1) to hold pointers to externally allocated memory regions

    Use array_init(...) for initialization, an element has the
    size of a pointer. Use the functions suffixed with `_ptr'
    to manage your pointers. The cleanup function array_release_full
    must only be used with this type of array.

 2) to hold arbitrary sized objects

    Use array_init_sized(...) to specify the size of a single
    element. Use the regular (i.e. without the `_ptr' suffix)
    functions to manage your objects. array_get will return a
    pointer to the object stored within the array.

1 files changed, 45 insertions, 7 deletions

diff --git a/array.c b/array.c
index 7689b2e..315e18c 100644
--- a/array.c
+++ b/array.c
@@ -8,7 +8,12 @@
 #define ARRAY_SIZE 16
 
 void array_init(Array *arr) {
+	array_init_sized(arr, sizeof(void*));
+}
+
+void array_init_sized(Array *arr, size_t elem_size) {
 	memset(arr, 0, sizeof *arr);
+	arr->elem_size = elem_size;
 }
 
 bool array_reserve(Array *arr, size_t count) {
@@ -16,7 +21,7 @@ bool array_reserve(Array *arr, size_t count) {
 		count = ARRAY_SIZE;
 	if (arr->count < count) {
 		count = MAX(count, arr->count*2);
-		void **items = realloc(arr->items, count * sizeof(void*));
+		char *items = realloc(arr->items, count * arr->elem_size);
 		if (!items)
 			return false;
 		arr->count = count;
@@ -29,21 +34,21 @@ void array_release(Array *arr) {
 	if (!arr)
 		return;
 	free(arr->items);
-	array_init(arr);
+	array_init_sized(arr, arr->elem_size);
 }
 
 void array_release_full(Array *arr) {
 	if (!arr)
 		return;
 	for (size_t i = 0; i < arr->len; i++)
-		free(arr->items[i]);
+		free(array_get_ptr(arr, i));
 	array_release(arr);
 }
 
 void array_clear(Array *arr) {
 	arr->len = 0;
 	if (arr->items)
-		memset(arr->items, 0, arr->count * sizeof(void*));
+		memset(arr->items, 0, arr->count * arr->elem_size);
 }
 
 void *array_get(Array *arr, size_t idx) {
@@ -51,7 +56,16 @@ void *array_get(Array *arr, size_t idx) {
 		errno = EINVAL;
 		return NULL;
 	}
-	return arr->items[idx];
+	return arr->items + (idx * arr->elem_size);
+}
+
+void *array_get_ptr(Array *arr, size_t idx) {
+	if (arr->elem_size != sizeof(void*)) {
+		errno = ENOTSUP;
+		return NULL;
+	}
+	void **ptr = array_get(arr, idx);
+	return ptr ? *ptr : NULL;
 }
 
 bool array_set(Array *arr, size_t idx, void *item) {
@@ -59,14 +73,38 @@ bool array_set(Array *arr, size_t idx, void *item) {
 		errno = EINVAL;
 		return false;
 	}
-	arr->items[idx] = item;
+	if (item)
+		memcpy(arr->items + (idx * arr->elem_size), item, arr->elem_size);
+	else
+		memset(arr->items + (idx * arr->elem_size), 0, arr->elem_size);
 	return true;
 }
 
+bool array_set_ptr(Array *arr, size_t idx, void *item) {
+	if (arr->elem_size != sizeof(void*)) {
+		errno = ENOTSUP;
+		return false;
+	}
+	return array_set(arr, idx, &item);
+}
+
 bool array_add(Array *arr, void *item) {
 	if (!array_reserve(arr, arr->len+1))
 		return false;
-	arr->items[arr->len++] = item;;
+	if (!array_set(arr, arr->len++, item)) {
+		arr->len--;
+		return false;
+	}
+	return true;
+}
+
+bool array_add_ptr(Array *arr, void *item) {
+	if (!array_reserve(arr, arr->len+1))
+		return false;
+	if (!array_set_ptr(arr, arr->len++, item)) {
+		arr->len--;
+		return false;
+	}
 	return true;
 }