101 lines
2.2 KiB
Core
101 lines
2.2 KiB
Core
#import "LibC.core"
|
|
|
|
Array :: struct($T: Type)
|
|
data: *T
|
|
len: int
|
|
cap: int
|
|
|
|
Pop :: (a: *Array($T)): T
|
|
if a.len > 0
|
|
a.len -= 1
|
|
return a.data[a.len]
|
|
return {}
|
|
|
|
Contains :: (a: *Array($T), item: *T): bool
|
|
result := item >= a.data && item < a.data + a.len
|
|
return result
|
|
|
|
Free :: (a: *Array($T))
|
|
free(a.data)
|
|
a.cap = 0; a.len = 0; a.data = 0
|
|
|
|
Reset :: (a: *Array($T))
|
|
a.len = 0
|
|
|
|
GetLast :: (a: *Array($T)): *T
|
|
Assert(a.len > 0)
|
|
result := a.data + a.len-1
|
|
return result
|
|
|
|
Insert :: (a: *Array($T), item: T, index: int)
|
|
if index == a.len
|
|
Add(a, item)
|
|
return
|
|
|
|
Assert(index < a.len)
|
|
Assert(index >= 0)
|
|
|
|
TryGrowing(a)
|
|
right_len := (a.len - index)->size_t
|
|
memmove(a.data + index + 1, a.data + index, sizeof(T) * right_len)
|
|
a.data[index] = item
|
|
a.len += 1
|
|
|
|
GetIndex :: (a: *Array($T), item: *T): int
|
|
Assert(a.len > 0)
|
|
Assert(item >= a.data && item < a.data + a.len)
|
|
|
|
index := (item - a.data)->int
|
|
Assert(index >= 0 && index < a.len)
|
|
return index
|
|
|
|
UnorderedRemove :: (a: *Array($T), item: *T)
|
|
Assert(a.len > 0)
|
|
Assert(item >= a.data && item < a.data + a.len)
|
|
|
|
*item = a.data[--a.len]
|
|
|
|
OrderedRemove :: (a: *Array($T), item: *T)
|
|
index := GetIndex(a, item)
|
|
if index == a.len - 1
|
|
Pop(a)
|
|
return
|
|
|
|
length_right_of_item := (a.len - index - 1)->size_t
|
|
memmove(a.data + index, a.data + index + 1, length_right_of_item * sizeof(T))
|
|
a.len -= 1
|
|
|
|
TryGrowing :: (a: *Array($T))
|
|
if a.cap == 0
|
|
a.cap = 16
|
|
a.data = malloc(sizeof(T) * a.cap->size_t)
|
|
if a.len + 1 > a.cap
|
|
a.cap *= 2
|
|
a.data = realloc(a.data, sizeof(T) * a.cap->size_t)
|
|
|
|
Add :: (a: *Array($T), item: T)
|
|
TryGrowing(a)
|
|
a.data[a.len++] = item
|
|
|
|
BoundedAdd :: (a: *Array($T), item: T)
|
|
Assert(a.len + 1 <= a.cap)
|
|
Add(a, item)
|
|
|
|
InsertSortedDecreasing :: (a: *Array($T), item: T)
|
|
insert_index := -1
|
|
for i := 0, i < a.len, i += 1
|
|
it := a.data + i
|
|
if it.value_to_sort_by <= item.value_to_sort_by
|
|
insert_index = i
|
|
Insert(a, item, i)
|
|
break
|
|
|
|
if insert_index == -1
|
|
Add(a, item)
|
|
|
|
Reserve :: (a: *Array($T), size: int)
|
|
Assert(size > a.cap)
|
|
a.cap = size
|
|
p := realloc(a.data, sizeof(T) * a.cap->size_t)
|
|
Assert(p != 0)
|
|
a.data = p |