refactor: ArrayList and ArraySlice uses Allocator

include/lae_arraylist.h

@@ -1,6 +1,7 @@
 #ifndef LAE_ARRAYLIST_H
 #define LAE_ARRAYLIST_H
 
+#include "lae_allocator.h"
 #include <inttypes.h>
 #include <stdbool.h>
 #include <stddef.h>
@@ -25,7 +26,11 @@ typedef enum {
     ARRLIST_BORROW_UNDERFLOW,
 } ArrayListErr;
 
-ArrayListErr arraylist_init(ArrayList **arr, size_t capacity, size_t elem_size);
+ArrayListErr arraylist_init(
+    ArrayList **arr,
+    Allocator allocator,
+    size_t capacity,
+    size_t elem_size);
 ArrayListErr arraylist_destroy(ArrayList **arr);
 ArrayListErr arraylist_clear(ArrayList *arr);
 ArrayList *arraylist_clone(const ArrayList *arr);
@@ -50,11 +55,19 @@ ArrayListErr arraylist_resize(ArrayList *arr, size_t new_capacity);
 ArrayListErr arraylist_reserve(ArrayList *arr, size_t size_to_reserve);
 
 // Slice stuff
-ArrayListErr
+ArrayListErr arraylist_slice(
-arraylist_slice(ArraySlice **slice, ArrayList *arr, size_t start, size_t len);
+    ArraySlice **slice,
+    Allocator allocator,
+    ArrayList *arr,
+    size_t start,
+    size_t len);
 
 ArrayListErr arraylist_slice_unsafe(
-    ArraySlice **slice, ArrayList *arr, size_t start, size_t len);
+    ArraySlice **slice,
+    Allocator allocator,
+    ArrayList *arr,
+    size_t start,
+    size_t len);
 
 ArrayListErr arrayslice_destroy(ArraySlice **slice);
 
@@ -69,6 +82,9 @@ ArrayListErr arrayslice_next(ArraySlice *slice, void *out);
 ArrayListErr arrayslice_reset(ArraySlice *slice);
 ArrayListErr arrayslice_advance(ArraySlice *slice, size_t n);
 
-ArrayListErr arrayslice_to_arraylist(ArrayList **arr, const ArraySlice *slice);
+ArrayListErr arrayslice_to_arraylist(
+    ArrayList **arr,
+    Allocator allocator,
+    const ArraySlice *slice);
 
 #endif

src/lae_arraylist.c

@@ -1,4 +1,6 @@
 #include "lae_arraylist.h"
+#include "lae_allocator.h"
+#include <stdalign.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ -10,6 +12,8 @@ struct ArrayList {
     size_t len;
     size_t elem_size;
     size_t borrows;
+
+    Allocator allocator;
 };
 
 struct ArraySlice {
@@ -18,6 +22,8 @@ struct ArraySlice {
     size_t end;
     size_t current;
     bool is_safe;
+
+    Allocator allocator;
 };
 
 // Grow and shrink factor is 2, 1.5 might give different results i guess
@@ -26,8 +32,11 @@ struct ArraySlice {
 static ArrayListErr arraylist_grow(ArrayList *arr);
 static ArrayListErr arraylist_shrink(ArrayList *arr);
 
-ArrayListErr
+ArrayListErr arraylist_init(
-arraylist_init(ArrayList **arr, size_t capacity, size_t elem_size) {
+    ArrayList **arr,
+    Allocator allocator,
+    size_t capacity,
+    size_t elem_size) {
     if (arr == NULL) {
         return ARRLIST_NULL_ARG;
     }
@@ -46,7 +55,8 @@ arraylist_init(ArrayList **arr, size_t capacity, size_t elem_size) {
         return ARRLIST_INVALID_CAPACITY;
     }
 
-    ArrayList *new_arr = malloc(sizeof(ArrayList));
+    ArrayList *new_arr =
+        allocator.alloc(allocator.ctx, sizeof(ArrayList), alignof(ArrayList));
     if (new_arr == NULL) {
         return ARRLIST_BAD_ALLOC;
     }
@@ -55,9 +65,14 @@ arraylist_init(ArrayList **arr, size_t capacity, size_t elem_size) {
     new_arr->elem_size = elem_size;
     new_arr->len = 0;
     new_arr->borrows = 0;
-    new_arr->buffer = malloc(capacity * elem_size);
+    new_arr->buffer = allocator.alloc(allocator.ctx, capacity * elem_size, 0);
+    new_arr->allocator = allocator;
     if (new_arr->buffer == NULL) {
-        free(new_arr);
+        allocator.free(
+            allocator.ctx,
+            new_arr,
+            sizeof(ArrayList),
+            alignof(ArrayList));
         return ARRLIST_BAD_ALLOC;
     }
 
@@ -74,9 +89,12 @@ ArrayListErr arraylist_destroy(ArrayList **arr) {
         return ARRLIST_IS_BORROWED;
     }
 
+    ArrayList *tmp = *arr;
+
     // No problem on using free on NULL :)
-    free((*arr)->buffer);
+    tmp->allocator.free(tmp->allocator.ctx, tmp->buffer, tmp->capacity, 0);
-    free(*arr);
+    tmp->allocator
+        .free(tmp->allocator.ctx, tmp, sizeof(ArrayList), alignof(ArrayList));
     *arr = NULL;
 
     return ARRLIST_OK;
@@ -417,8 +435,12 @@ ArrayListErr arraylist_reserve(ArrayList *arr, size_t size_to_reserve) {
     return ARRLIST_OK;
 }
 
-ArrayListErr
+ArrayListErr arraylist_slice(
-arraylist_slice(ArraySlice **slice, ArrayList *arr, size_t start, size_t len) {
+    ArraySlice **slice,
+    Allocator allocator,
+    ArrayList *arr,
+    size_t start,
+    size_t len) {
     if (arr == NULL || slice == NULL) {
         return ARRLIST_NULL_ARG;
     }
@@ -435,7 +457,8 @@ arraylist_slice(ArraySlice **slice, ArrayList *arr, size_t start, size_t len) {
         return ARRLIST_INVALID_START;
     }
 
-    ArraySlice *new_slice = malloc(sizeof(ArraySlice));
+    ArraySlice *new_slice =
+        allocator.alloc(allocator.ctx, sizeof(ArraySlice), alignof(ArraySlice));
     if (new_slice == NULL) {
         return ARRLIST_BAD_ALLOC;
     }
@@ -445,6 +468,7 @@ arraylist_slice(ArraySlice **slice, ArrayList *arr, size_t start, size_t len) {
     new_slice->end = start + len;
     new_slice->current = start;
     new_slice->is_safe = true;
+    new_slice->allocator = allocator;
 
     arr->borrows++;
     *slice = new_slice;
@@ -452,7 +476,11 @@ arraylist_slice(ArraySlice **slice, ArrayList *arr, size_t start, size_t len) {
 }
 
 ArrayListErr arraylist_slice_unsafe(
-    ArraySlice **slice, ArrayList *arr, size_t start, size_t len) {
+    ArraySlice **slice,
+    Allocator allocator,
+    ArrayList *arr,
+    size_t start,
+    size_t len) {
     if (arr == NULL || slice == NULL) {
         return ARRLIST_NULL_ARG;
     }
@@ -469,7 +497,8 @@ ArrayListErr arraylist_slice_unsafe(
         return ARRLIST_INVALID_START;
     }
 
-    ArraySlice *new_slice = malloc(sizeof(ArraySlice));
+    ArraySlice *new_slice =
+        allocator.alloc(allocator.ctx, sizeof(ArraySlice), alignof(ArraySlice));
     if (new_slice == NULL) {
         return ARRLIST_BAD_ALLOC;
     }
@@ -493,7 +522,11 @@ ArrayListErr arrayslice_destroy(ArraySlice **slice) {
         (*slice)->arr->borrows--;
     }
 
-    free(*slice);
+    (*slice)->allocator.free(
+        (*slice)->allocator.ctx,
+        *slice,
+        sizeof(ArraySlice),
+        alignof(ArraySlice));
     *slice = NULL;
 
     return ARRLIST_OK;
@@ -570,7 +603,10 @@ ArrayListErr arrayslice_advance(ArraySlice *slice, size_t n) {
     return ARRLIST_OK;
 }
 
-ArrayListErr arrayslice_to_arraylist(ArrayList **arr, const ArraySlice *slice) {
+ArrayListErr arrayslice_to_arraylist(
+    ArrayList **arr,
+    Allocator allocator,
+    const ArraySlice *slice) {
     if (slice == NULL || slice->arr == NULL) {
         return ARRLIST_NULL_ARG;
     }
@@ -588,6 +624,7 @@ ArrayListErr arrayslice_to_arraylist(ArrayList **arr, const ArraySlice *slice) {
     ArrayList *new_arr;
     ArrayListErr init_err = arraylist_init(
         &new_arr,
+        allocator,
         arraylist_capacity(slice->arr),
         slice->arr->elem_size);