`package container` with `Queue` and `Array`

1 files changed, 160 insertions, 0 deletions

diff --git a/core/container/array.odin b/core/container/array.odin
new file mode 100644
index 000000000..273657eb6
--- /dev/null
+++ b/core/container/array.odin
@@ -0,0 +1,160 @@
+package container
+
+import "core:mem"
+
+Array :: struct(T: typeid) {
+	data:      ^T,
+	len:       int,
+	cap:       int,
+	allocator: mem.Allocator,
+}
+
+array_init_none :: proc(a: ^$A/Array, allocator := context.allocator) {
+	array_init_len(a, 0, allocator);
+}
+array_init_len :: proc(a: ^$A/Array, len: int, allocator := context.allocator) {
+	array_init_len_cap(a, 0, 16, allocator);
+}
+array_init_len_cap :: proc(a: ^$A/Array($T), len: int, cap: int, allocator := context.allocator) {
+	a.data = (^T)(mem.alloc(size_of(T)*cap, align_of(T), allocator));
+	a.len = len;
+	a.cap = cap;
+	a.allocator = allocator;
+}
+
+array_init :: proc{array_init_none, array_init_len, array_init_len_cap};
+
+array_delete :: proc(a: $A/Array) {
+	mem.free(a.data, a.allocator);
+}
+
+array_len :: proc(a: $A/Array) -> int {
+	return a.len;
+}
+
+array_cap :: proc(a: $A/Array) -> int {
+	return a.cap;
+}
+
+array_space :: proc(a: $A/Array) -> int {
+	return a.cap - a.len;
+}
+
+array_slice :: proc(a: $A/Array($T)) -> []T {
+	s := mem.Raw_Slice{a.data, a.len};
+	return transmute([]T)s;
+}
+
+
+array_get :: proc(a: $A/Array($T), index: int) -> T {
+	return (^T)(uintptr(a.data) + size_of(T)*uintptr(index))^;
+}
+
+array_set :: proc(a: ^$A/Array($T), index: int, item: T)  {
+	(^T)(uintptr(a.data) + size_of(T)*uintptr(index))^ = item;
+}
+
+
+array_reserve :: proc(a: ^$A/Array, capacity: int) {
+	if capacity > a.size {
+		array_set_capacity(a, capacity);
+	}
+}
+
+array_resize :: proc(a: ^$A/Array, length: int) {
+	if length > a.len {
+		array_set_capacity(a, length);
+	}
+	a.len = length;
+}
+
+
+
+array_push_back :: proc(a: ^$A/Array($T), item: T) {
+	if array_space(a^) == 0 {
+		array_grow(a);
+	}
+
+	a.size += 1;
+	array_set(a, a.size, item);
+}
+
+array_push_front :: proc(a: ^$A/Array($T), item: T) {
+	if array_space(a^) == 0 {
+		array_grow(a);
+	}
+
+	a.len += 1;
+	data := array_slice(a^);
+	copy(data[1:], data[:]);
+	data[0] = item;
+}
+
+array_pop_back :: proc(a: ^$A/Array($T)) -> T {
+	assert(a.len > 0);
+	item := array_get(a^, a.len-1);
+	a.len -= 1;
+	return item;
+}
+
+array_pop_font :: proc(a: ^$A/Array($T)) -> T {
+	assert(a.len > 0);
+	item := array_get(a^, 0);
+	s := array_slice(a^);
+	copy(s[:], s[1:]);
+	a.len -= 1;
+	return item;
+}
+
+
+array_consume :: proc(a: ^$A/Array($T), count: int) {
+	assert(a.size >= count);
+	a.size -= count;
+}
+
+
+array_trim :: proc(a: ^$A/Array($T)) {
+	array_set_capacity(a, a.len);
+}
+
+array_clear :: proc(q: ^$Q/Queue($T)) {
+	array_resize(q, 0);
+}
+
+
+array_push :: proc(a: ^$A/Array($T), items: ..T) {
+	if array_space(a^) < len(items) {
+		array_grow(a, a.size + len(items));
+	}
+	offset := a.len;
+	a.len += len(items);
+	data := array_slice(a^);
+	n := copy(data[offset:], items);
+	a.len = offset + n;
+}
+
+
+array_set_capacity :: proc(a: ^$A/Array($T), new_capacity: int) {
+	if new_capacity == a.cap {
+		return;
+	}
+
+	if new_capacity < a.len {
+		array_resize(a, new_capacity);
+	}
+
+	new_data: ^T;
+	if new_capacity > 0 {
+		new_data = (^T)(mem.alloc(size_of(T)*new_capacity, align_of(T), a.allocator));
+		if new_data != nil {
+			mem.copy(new_data, a.data, size_of(T)*a.len);
+		}
+	}
+	mem.free(a.data);
+	a.data = new_data;
+	a.cap = new_capacity;
+}
+array_grow :: proc(a: ^$A/Array, min_capacity: int = 0) {
+	new_capacity := max(len(a.data)*2 + 8, min_capacity);
+	array_set_capacity(a, new_capacity);
+}