mirrors/Odin
1
0
Fork 0
mirror of https://github.com/odin-lang/Odin.git synced 2025-12-29 01:14:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

gb_internal a lot

Browse Source
This commit is contained in:
gingerBill
2022-12-18 21:17:07 +00:00
parent ff6b76986a
commit ac5f5a33e9
25 changed files with 1078 additions and 1128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

144
src/array.cpp
View File

@@ -23,32 +23,32 @@ struct Array {
}
};
template <typename T> void array_init (Array<T> *array, gbAllocator const &a);
template <typename T> void array_init (Array<T> *array, gbAllocator const &a, isize count);
template <typename T> void array_init (Array<T> *array, gbAllocator const &a, isize count, isize capacity);
template <typename T> Array<T> array_make (gbAllocator const &a);
template <typename T> Array<T> array_make (gbAllocator const &a, isize count);
template <typename T> Array<T> array_make (gbAllocator const &a, isize count, isize capacity);
template <typename T> Array<T> array_make_from_ptr (T *data, isize count, isize capacity);
template <typename T> void array_free (Array<T> *array);
template <typename T> void array_add (Array<T> *array, T const &t);
template <typename T> T * array_add_and_get (Array<T> *array);
template <typename T> void array_add_elems (Array<T> *array, T const *elems, isize elem_count);
template <typename T> T array_pop (Array<T> *array);
template <typename T> void array_clear (Array<T> *array);
template <typename T> void array_reserve (Array<T> *array, isize capacity);
template <typename T> void array_resize (Array<T> *array, isize count);
template <typename T> void array_set_capacity (Array<T> *array, isize capacity);
template <typename T> Array<T> array_slice (Array<T> const &array, isize lo, isize hi);
template <typename T> Array<T> array_clone (gbAllocator const &a, Array<T> const &array);
template <typename T> gb_internal void array_init (Array<T> *array, gbAllocator const &a);
template <typename T> gb_internal void array_init (Array<T> *array, gbAllocator const &a, isize count);
template <typename T> gb_internal void array_init (Array<T> *array, gbAllocator const &a, isize count, isize capacity);
template <typename T> gb_internal Array<T> array_make (gbAllocator const &a);
template <typename T> gb_internal Array<T> array_make (gbAllocator const &a, isize count);
template <typename T> gb_internal Array<T> array_make (gbAllocator const &a, isize count, isize capacity);
template <typename T> gb_internal Array<T> array_make_from_ptr (T *data, isize count, isize capacity);
template <typename T> gb_internal void array_free (Array<T> *array);
template <typename T> gb_internal void array_add (Array<T> *array, T const &t);
template <typename T> gb_internal T * array_add_and_get (Array<T> *array);
template <typename T> gb_internal void array_add_elems (Array<T> *array, T const *elems, isize elem_count);
template <typename T> gb_internal T array_pop (Array<T> *array);
template <typename T> gb_internal void array_clear (Array<T> *array);
template <typename T> gb_internal void array_reserve (Array<T> *array, isize capacity);
template <typename T> gb_internal void array_resize (Array<T> *array, isize count);
template <typename T> gb_internal void array_set_capacity (Array<T> *array, isize capacity);
template <typename T> gb_internal Array<T> array_slice (Array<T> const &array, isize lo, isize hi);
template <typename T> gb_internal Array<T> array_clone (gbAllocator const &a, Array<T> const &array);
template <typename T> void array_ordered_remove (Array<T> *array, isize index);
template <typename T> void array_unordered_remove(Array<T> *array, isize index);
template <typename T> gb_internal void array_ordered_remove (Array<T> *array, isize index);
template <typename T> gb_internal void array_unordered_remove(Array<T> *array, isize index);
template <typename T> void array_copy(Array<T> *array, Array<T> const &data, isize offset);
template <typename T> void array_copy(Array<T> *array, Array<T> const &data, isize offset, isize count);
template <typename T> gb_internal void array_copy(Array<T> *array, Array<T> const &data, isize offset);
template <typename T> gb_internal void array_copy(Array<T> *array, Array<T> const &data, isize offset, isize count);
template <typename T> T *array_end_ptr(Array<T> *array);
template <typename T> gb_internal T *array_end_ptr(Array<T> *array);
template <typename T>
@@ -56,14 +56,14 @@ struct Slice {
T *data;
isize count;
T &operator[](isize index) {
gb_inline T &operator[](isize index) {
#if !defined(NO_ARRAY_BOUNDS_CHECK)
GB_ASSERT_MSG(0 <= index && index < count, "Index %td is out of bounds ranges 0..<%td", index, count);
#endif
return data[index];
}
T const &operator[](isize index) const {
gb_inline T const &operator[](isize index) const {
#if !defined(NO_ARRAY_BOUNDS_CHECK)
GB_ASSERT_MSG(0 <= index && index < count, "Index %td is out of bounds ranges 0..<%td", index, count);
#endif
@@ -71,12 +71,12 @@ struct Slice {
}
};
template <typename T> Slice<T> slice_from_array(Array<T> const &a);
template <typename T> gb_internal Slice<T> slice_from_array(Array<T> const &a);
template <typename T>
Slice<T> slice_make(gbAllocator const &allocator, isize count) {
gb_internal Slice<T> slice_make(gbAllocator const &allocator, isize count) {
GB_ASSERT(count >= 0);
Slice<T> s = {};
s.data = gb_alloc_array(allocator, T, count);
@@ -86,7 +86,7 @@ Slice<T> slice_make(gbAllocator const &allocator, isize count) {
}
template <typename T>
void slice_init(Slice<T> *s, gbAllocator const &allocator, isize count) {
gb_internal void slice_init(Slice<T> *s, gbAllocator const &allocator, isize count) {
GB_ASSERT(count >= 0);
s->data = gb_alloc_array(allocator, T, count);
if (count > 0) {
@@ -96,23 +96,23 @@ void slice_init(Slice<T> *s, gbAllocator const &allocator, isize count) {
}
template <typename T>
void slice_free(Slice<T> *s, gbAllocator const &allocator) {
gb_internal void slice_free(Slice<T> *s, gbAllocator const &allocator) {
gb_free(allocator, s->data);
}
template <typename T>
void slice_resize(Slice<T> *s, gbAllocator const &allocator, isize new_count) {
gb_internal void slice_resize(Slice<T> *s, gbAllocator const &allocator, isize new_count) {
resize_array_raw(&s->data, allocator, s->count, new_count);
s->count = new_count;
}
template <typename T>
Slice<T> slice_from_array(Array<T> const &a) {
gb_internal Slice<T> slice_from_array(Array<T> const &a) {
return {a.data, a.count};
}
template <typename T>
Slice<T> slice_array(Array<T> const &array, isize lo, isize hi) {
gb_internal Slice<T> slice_array(Array<T> const &array, isize lo, isize hi) {
GB_ASSERT(0 <= lo && lo <= hi && hi <= array.count);
Slice<T> out = {};
isize len = hi-lo;
@@ -125,30 +125,30 @@ Slice<T> slice_array(Array<T> const &array, isize lo, isize hi) {
template <typename T>
Slice<T> slice_clone(gbAllocator const &allocator, Slice<T> const &a) {
gb_internal Slice<T> slice_clone(gbAllocator const &allocator, Slice<T> const &a) {
T *data = cast(T *)gb_alloc_copy_align(allocator, a.data, a.count*gb_size_of(T), gb_align_of(T));
return {data, a.count};
}
template <typename T>
Slice<T> slice_clone_from_array(gbAllocator const &allocator, Array<T> const &a) {
gb_internal Slice<T> slice_clone_from_array(gbAllocator const &allocator, Array<T> const &a) {
auto c = array_clone(allocator, a);
return {c.data, c.count};
}
template <typename T>
void slice_copy(Slice<T> *slice, Slice<T> const &data) {
gb_internal void slice_copy(Slice<T> *slice, Slice<T> const &data) {
isize n = gb_min(slice->count, data.count);
gb_memmove(slice->data, data.data, gb_size_of(T)*n);
}
template <typename T>
void slice_copy(Slice<T> *slice, Slice<T> const &data, isize offset) {
gb_internal void slice_copy(Slice<T> *slice, Slice<T> const &data, isize offset) {
isize n = gb_clamp(slice->count-offset, 0, data.count);
gb_memmove(slice->data+offset, data.data, gb_size_of(T)*n);
}
template <typename T>
void slice_copy(Slice<T> *slice, Slice<T> const &data, isize offset, isize count) {
gb_internal void slice_copy(Slice<T> *slice, Slice<T> const &data, isize offset, isize count) {
isize n = gb_clamp(slice->count-offset, 0, gb_min(data.count, count));
gb_memmove(slice->data+offset, data.data, gb_size_of(T)*n);
}
@@ -156,7 +156,7 @@ void slice_copy(Slice<T> *slice, Slice<T> const &data, isize offset, isize count
template <typename T>
gb_inline Slice<T> slice(Slice<T> const &array, isize lo, isize hi) {
gb_internal gb_inline Slice<T> slice(Slice<T> const &array, isize lo, isize hi) {
GB_ASSERT(0 <= lo && lo <= hi && hi <= array.count);
Slice<T> out = {};
isize len = hi-lo;
@@ -169,7 +169,7 @@ gb_inline Slice<T> slice(Slice<T> const &array, isize lo, isize hi) {
template <typename T>
void slice_ordered_remove(Slice<T> *array, isize index) {
gb_internal void slice_ordered_remove(Slice<T> *array, isize index) {
GB_ASSERT(0 <= index && index < array->count);
isize bytes = gb_size_of(T) * (array->count-(index+1));
@@ -178,7 +178,7 @@ void slice_ordered_remove(Slice<T> *array, isize index) {
}
template <typename T>
void slice_unordered_remove(Slice<T> *array, isize index) {
gb_internal void slice_unordered_remove(Slice<T> *array, isize index) {
GB_ASSERT(0 <= index && index < array->count);
isize n = array->count-1;
@@ -190,18 +190,18 @@ void slice_unordered_remove(Slice<T> *array, isize index) {
template <typename T>
void array_copy(Array<T> *array, Array<T> const &data, isize offset) {
gb_internal void array_copy(Array<T> *array, Array<T> const &data, isize offset) {
gb_memmove(array->data+offset, data.data, gb_size_of(T)*data.count);
}
template <typename T>
void array_copy(Array<T> *array, Array<T> const &data, isize offset, isize count) {
gb_internal void array_copy(Array<T> *array, Array<T> const &data, isize offset, isize count) {
gb_memmove(array->data+offset, data.data, gb_size_of(T)*gb_min(data.count, count));
}
template <typename T>
T *array_end_ptr(Array<T> *array) {
gb_internal T *array_end_ptr(Array<T> *array) {
if (array->count > 0) {
return &array->data[array->count-1];
}
@@ -210,18 +210,18 @@ T *array_end_ptr(Array<T> *array) {
template <typename T>
gb_inline void array_init(Array<T> *array, gbAllocator const &a) {
gb_internal gb_inline void array_init(Array<T> *array, gbAllocator const &a) {
isize cap = ARRAY_GROW_FORMULA(0);
array_init(array, a, 0, cap);
}
template <typename T>
gb_inline void array_init(Array<T> *array, gbAllocator const &a, isize count) {
gb_internal gb_inline void array_init(Array<T> *array, gbAllocator const &a, isize count) {
array_init(array, a, count, count);
}
template <typename T>
gb_inline void array_init(Array<T> *array, gbAllocator const &a, isize count, isize capacity) {
gb_internal gb_inline void array_init(Array<T> *array, gbAllocator const &a, isize count, isize capacity) {
array->allocator = a;
array->data = nullptr;
if (capacity > 0) {
@@ -234,7 +234,7 @@ gb_inline void array_init(Array<T> *array, gbAllocator const &a, isize count, is
template <typename T>
gb_inline Array<T> array_make_from_ptr(T *data, isize count, isize capacity) {
gb_internal gb_inline Array<T> array_make_from_ptr(T *data, isize count, isize capacity) {
Array<T> a = {0};
a.data = data;
a.count = count;
@@ -244,7 +244,7 @@ gb_inline Array<T> array_make_from_ptr(T *data, isize count, isize capacity) {
template <typename T>
gb_inline Array<T> array_make(gbAllocator const &a) {
gb_internal gb_inline Array<T> array_make(gbAllocator const &a) {
isize capacity = ARRAY_GROW_FORMULA(0);
Array<T> array = {};
array.allocator = a;
@@ -254,7 +254,7 @@ gb_inline Array<T> array_make(gbAllocator const &a) {
return array;
}
template <typename T>
gb_inline Array<T> array_make(gbAllocator const &a, isize count) {
gb_internal gb_inline Array<T> array_make(gbAllocator const &a, isize count) {
Array<T> array = {};
array.allocator = a;
array.data = gb_alloc_array(a, T, count);
@@ -263,7 +263,7 @@ gb_inline Array<T> array_make(gbAllocator const &a, isize count) {
return array;
}
template <typename T>
gb_inline Array<T> array_make(gbAllocator const &a, isize count, isize capacity) {
gb_internal gb_inline Array<T> array_make(gbAllocator const &a, isize count, isize capacity) {
Array<T> array = {};
array.allocator = a;
array.data = gb_alloc_array(a, T, capacity);
@@ -275,7 +275,7 @@ gb_inline Array<T> array_make(gbAllocator const &a, isize count, isize capacity)
template <typename T>
gb_inline void array_free(Array<T> *array) {
gb_internal gb_inline void array_free(Array<T> *array) {
if (array->allocator.proc != nullptr) {
gb_free(array->allocator, array->data);
}
@@ -284,7 +284,7 @@ gb_inline void array_free(Array<T> *array) {
}
template <typename T>
void array__grow(Array<T> *array, isize min_capacity) {
gb_internal void array__grow(Array<T> *array, isize min_capacity) {
isize new_capacity = ARRAY_GROW_FORMULA(array->capacity);
if (new_capacity < min_capacity) {
new_capacity = min_capacity;
@@ -293,7 +293,7 @@ void array__grow(Array<T> *array, isize min_capacity) {
}
template <typename T>
void array_add(Array<T> *array, T const &t) {
gb_internal void array_add(Array<T> *array, T const &t) {
if (array->capacity < array->count+1) {
array__grow(array, 0);
}
@@ -302,7 +302,7 @@ void array_add(Array<T> *array, T const &t) {
}
template <typename T>
T *array_add_and_get(Array<T> *array) {
gb_internal T *array_add_and_get(Array<T> *array) {
if (array->count < array->capacity) {
return &array->data[array->count++];
}
@@ -314,7 +314,7 @@ T *array_add_and_get(Array<T> *array) {
template <typename T>
void array_add_elems(Array<T> *array, T const *elems, isize elem_count) {
gb_internal void array_add_elems(Array<T> *array, T const *elems, isize elem_count) {
GB_ASSERT(elem_count >= 0);
if (array->capacity < array->count+elem_count) {
array__grow(array, array->count+elem_count);
@@ -325,26 +325,26 @@ void array_add_elems(Array<T> *array, T const *elems, isize elem_count) {
template <typename T>
gb_inline T array_pop(Array<T> *array) {
gb_internal gb_inline T array_pop(Array<T> *array) {
GB_ASSERT(array->count > 0);
array->count--;
return array->data[array->count];
}
template <typename T>
void array_clear(Array<T> *array) {
gb_internal void array_clear(Array<T> *array) {
array->count = 0;
}
template <typename T>
void array_reserve(Array<T> *array, isize capacity) {
gb_internal void array_reserve(Array<T> *array, isize capacity) {
if (array->capacity < capacity) {
array_set_capacity(array, capacity);
}
}
template <typename T>
void array_resize(Array<T> *array, isize count) {
gb_internal void array_resize(Array<T> *array, isize count) {
if (array->capacity < count) {
array__grow(array, count);
}
@@ -352,7 +352,7 @@ void array_resize(Array<T> *array, isize count) {
}
template <typename T>
void array_set_capacity(Array<T> *array, isize capacity) {
gb_internal void array_set_capacity(Array<T> *array, isize capacity) {
if (capacity == array->capacity) {
return;
}
@@ -381,7 +381,7 @@ void array_set_capacity(Array<T> *array, isize capacity) {
template <typename T>
gb_inline Array<T> array_slice(Array<T> const &array, isize lo, isize hi) {
gb_internal gb_inline Array<T> array_slice(Array<T> const &array, isize lo, isize hi) {
GB_ASSERT(0 <= lo && lo <= hi && hi <= array.count);
Array<T> out = {};
isize len = hi-lo;
@@ -394,7 +394,7 @@ gb_inline Array<T> array_slice(Array<T> const &array, isize lo, isize hi) {
}
template <typename T>
Array<T> array_clone(gbAllocator const &allocator, Array<T> const &array) {
gb_internal Array<T> array_clone(gbAllocator const &allocator, Array<T> const &array) {
auto clone = array_make<T>(allocator, array.count, array.count);
array_copy(&clone, array, 0);
return clone;
@@ -402,7 +402,7 @@ Array<T> array_clone(gbAllocator const &allocator, Array<T> const &array) {
template <typename T>
void array_ordered_remove(Array<T> *array, isize index) {
gb_internal void array_ordered_remove(Array<T> *array, isize index) {
GB_ASSERT(0 <= index && index < array->count);
isize bytes = gb_size_of(T) * (array->count-(index+1));
@@ -411,7 +411,7 @@ void array_ordered_remove(Array<T> *array, isize index) {
}
template <typename T>
void array_unordered_remove(Array<T> *array, isize index) {
gb_internal void array_unordered_remove(Array<T> *array, isize index) {
GB_ASSERT(0 <= index && index < array->count);
isize n = array->count-1;
@@ -424,35 +424,35 @@ void array_unordered_remove(Array<T> *array, isize index) {
template <typename T>
T *begin(Array<T> &array) {
gb_internal T *begin(Array<T> &array) {
return array.data;
}
template <typename T>
T const *begin(Array<T> const &array) {
gb_internal T const *begin(Array<T> const &array) {
return array.data;
}
template <typename T>
T *end(Array<T> &array) {
gb_internal T *end(Array<T> &array) {
return array.data + array.count;
}
template <typename T>
T const *end(Array<T> const &array) {
gb_internal T const *end(Array<T> const &array) {
return array.data + array.count;
}
template <typename T>
T *begin(Slice<T> &array) {
gb_internal T *begin(Slice<T> &array) {
return array.data;
}
template <typename T>
T const *begin(Slice<T> const &array) {
gb_internal T const *begin(Slice<T> const &array) {
return array.data;
}
template <typename T>
T *end(Slice<T> &array) {
gb_internal T *end(Slice<T> &array) {
return array.data + array.count;
}
template <typename T>
T const *end(Slice<T> const &array) {
gb_internal T const *end(Slice<T> const &array) {
return array.data + array.count;
}