doylet/Dqn
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update array api

Browse Source
This commit is contained in:
Doyle Thai 2018-01-26 14:54:03 +11:00
parent 47bf005dbf
commit 86d2db397c
2 changed files with 169 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

276
dqn.h
View File

@ -181,6 +181,7 @@ using f32 = float;
} while (0) } while (0)
#define DQN_LOGE(msg, ...) DqnLog(__FILE__, __func__, __LINE__, msg, ##__VA_ARGS__); #define DQN_LOGE(msg, ...) DqnLog(__FILE__, __func__, __LINE__, msg, ##__VA_ARGS__);
#define DQN_LOGD(msg, ...) DqnLog(__FILE__, __func__, __LINE__, msg, ##__VA_ARGS__);
// Use macro above. // Use macro above.
DQN_FILE_SCOPE void DqnLog(char *file, char const *const functionName, i32 const lineNum, char const *const msg, ...); DQN_FILE_SCOPE void DqnLog(char *file, char const *const functionName, i32 const lineNum, char const *const msg, ...);
@ -518,20 +519,26 @@ public:
// API // API
// ============================================================================================= // =============================================================================================
bool Init (i64 const size, DqnMemStack *const stack); void Init (T *const data_, isize max_, isize count_ = 0);
bool Init (i64 const size, DqnMemAPI *const api = &DQN_DEFAULT_HEAP_ALLOCATOR); void Init (DqnMemAPI *const memAPI_ = &DQN_DEFAULT_HEAP_ALLOCATOR);
bool Free (); void Init (DqnMemStack *const stack);
bool Resize (i64 const newMax); bool InitSize (isize size_, DqnMemAPI *const memAPI_ = &DQN_DEFAULT_HEAP_ALLOCATOR);
bool Grow (); bool InitSize (isize size_, DqnMemStack *const stack);
T *Push (T const *item, i64 const num);
void Free ();
bool Resize (isize newMax);
bool Grow (isize multiplier = 2);
T *Push (T const *item, isize num);
T *Push (T const item); T *Push (T const item);
T *Insert (T const item, i64 index); T *Insert (T const item, isize index);
void Pop (); void Pop ();
T *Get (i64 const index); T *Get (isize index);
void Clear (bool const zeroClear = false); void Clear (bool zeroClear = false);
bool Remove (i64 const index); bool Remove (isize index);
bool RemoveStable(i64 const index); bool RemoveStable(isize index);
void RemoveStable(i64 *indexList, const i64 numIndexes);
// indexList: Array of indexes to remove. This list gets sorted.
void RemoveStable(isize *indexList, isize numIndexes);
// C++ Iterator // C++ Iterator
// ============================================================================================= // =============================================================================================
@ -551,98 +558,106 @@ public:
}; };
template <typename T> template <typename T>
DQN_FILE_SCOPE DqnArray<T> DqnArray_(i64 const size, class DqnSmartArray : public DqnArray<T>
DqnMemAPI *const api = &DQN_DEFAULT_HEAP_ALLOCATOR)
{ {
DqnArray<T> result; ~DqnSmartArray() { if (data && memAPI) memAPI->Free(data); }
bool init = result.Init(size, api); };
DQN_ASSERT(init);
template <typename T>
void DqnArray<T>::Init(DqnMemAPI *const memAPI_)
{
memAPI = memAPI_;
count = max = 0;
data = nullptr;
}
template <typename T>
void DqnArray<T>::Init(T *data_, isize max_, isize count_)
{
DQN_ASSERT(data_);
memAPI = nullptr;
count = count_;
max = max_;
data = data_;
}
template <typename T>
void DqnArray<T>::Init(DqnMemStack *const stack)
{
this->Init(stack->myAPI);
}
template <typename T>
bool DqnArray<T>::InitSize(isize size_, DqnMemAPI *const memAPI_)
{
this->Init(memAPI_);
bool result = this->Resize(size_);
return result; return result;
} }
template <typename T> template <typename T>
DQN_FILE_SCOPE DqnArray<T> DqnArray_(i64 const size, DqnMemStack *const stack) bool DqnArray<T>::InitSize(isize size_, DqnMemStack *const stack)
{ {
DqnArray<T> result = DqnArray_<T>(size, &stack->myAPI); bool result = this->InitSize(size_, &stack->myAPI);
return result; return result;
} }
template <typename T>
DQN_FILE_SCOPE DqnArray<T> DqnArray_(DqnMemAPI *const api = &DQN_DEFAULT_HEAP_ALLOCATOR)
{
DqnArray<T> result = DqnArray_<T>(0, api);
return result;
}
template <typename T>
DQN_FILE_SCOPE DqnArray<T> DqnArray_(DqnMemStack *const stack)
{
DqnArray<T> result = DqnArray_<T>(0, stack);
return result;
}
template <typename T>
bool DqnArray<T>::Init(i64 const size, DqnMemStack *const stack)
{
bool result = false;
if (stack)
{
result = this->Init(size, &stack->myAPI);
}
return result;
}
template <typename T>
bool DqnArray<T>::Init(i64 const size, DqnMemAPI *const api)
{
DQN_ASSERT(size >= 0);
if (size > 0)
{
i64 allocateSize = size * sizeof(T);
this->data = (T *)api->Alloc(allocateSize, /*zeroClear*/ false);
if (!this->data) return false;
}
this->memAPI = api;
this->count = 0;
this->max = size;
return true;
}
// Implementation taken from Milton, developed by Serge at // Implementation taken from Milton, developed by Serge at
// https://github.com/serge-rgb/milton#license // https://github.com/serge-rgb/milton#license
template <typename T> template <typename T>
bool DqnArray<T>::Free() void DqnArray<T>::Free()
{ {
if (this->data) if (this->data)
{ {
// TODO(doyle): Right now we assume free always works, and it probably should? if (this->memAPI)
i64 sizeToFree = this->max * sizeof(T); {
this->memAPI->Free(this->data, sizeToFree); auto sizeToFree = this->max * sizeof(T);
this->data = nullptr; this->memAPI->Free(this->data, sizeToFree);
}
this->data = nullptr;
this->count = 0; this->count = 0;
this->max = 0; this->max = 0;
return true;
} }
return false;
} }
template <typename T> template <typename T>
bool DqnArray<T>::Resize(i64 newMax) bool DqnArray<T>::Resize(isize newMax)
{ {
if (!this->data) return false; if (!this->memAPI)
if (!this->memAPI->IsValid()) return false; {
DQN_LOGE("DqnArray has no memory api assigned. Resize to %d items failed.", newMax);
return false;
}
i64 oldSize = this->max * sizeof(T); if (newMax == 0)
i64 newSize = newMax * sizeof(T); {
DQN_LOGD(
"DqnArray tried to resize to 0 items. Not allowed? TODO(doyle): Maybe just free the "
"array then?");
return false;
}
if (newMax < this->count)
{
DQN_LOGE(
"DqnArray has %d items but requested a resize to: %d and will destroy the remaining "
"items in the array!", this->count, newMax);
}
auto oldSize = this->max * sizeof(T);
auto newSize = newMax * sizeof(T);
T *result = nullptr; T *result = nullptr;
if (oldSize == 0) result = (T *)this->memAPI->Alloc (newSize, /*zeroClear*/ false); if (this->data)
else result = (T *)this->memAPI->Realloc(this->data, oldSize, newSize); {
result = (T *)this->memAPI->Realloc(this->data, oldSize, newSize);
}
else
{
result = (T *)this->memAPI->Alloc(newSize, /*zeroClear*/ false);
}
if (result) if (result)
{ {
@ -652,36 +667,34 @@ bool DqnArray<T>::Resize(i64 newMax)
} }
else else
{ {
DQN_LOGE("DqnArray out of memory error. Failed to request: %d bytes.", newSize);
return false; return false;
} }
} }
template <typename T> template <typename T>
bool DqnArray<T>::Grow() bool DqnArray<T>::Grow(isize multiplier)
{ {
if (!this->data) return false; isize newMax = this->max * multiplier;
newMax = (newMax == 0) ? 8 : newMax;
const f32 GROWTH_FACTOR = 2.0f;
i64 newMax = (i64)(this->max * GROWTH_FACTOR);
if (newMax == this->max) newMax++;
bool result = this->Resize(newMax); bool result = this->Resize(newMax);
return result; return result;
} }
template <typename T> template <typename T>
T *DqnArray<T>::Push(const T *item, const i64 num) T *DqnArray<T>::Push(T const *item, isize num)
{ {
i64 newSize = this->count + num; if (!this->data || (this->count + num) >= this->max)
if (!this->data || newSize > this->max)
{ {
if (!this->Grow()) return nullptr; if (!this->Grow())
{
DQN_LOGE("DqnArray could not push %d item(s) onto array because growing failed.", num);
return nullptr;
}
} }
for (auto i = 0; i < num; i++) for (auto i = 0; i < num; i++)
{
this->data[this->count++] = item[i]; this->data[this->count++] = item[i];
}
DQN_ASSERT(this->count <= this->max); DQN_ASSERT(this->count <= this->max);
T *result = this->data + (this->count - 1); T *result = this->data + (this->count - 1);
@ -689,33 +702,34 @@ T *DqnArray<T>::Push(const T *item, const i64 num)
} }
template <typename T> template <typename T>
T *DqnArray<T>::Push(const T item) T *DqnArray<T>::Push(T const item)
{ {
T* result = this->Push(&item, 1); T* result = this->Push(&item, 1);
return result; return result;
} }
template <typename T> template <typename T>
T *DqnArray<T>::Insert(const T item, i64 index) T *DqnArray<T>::Insert(T const item, isize index)
{ {
index = DQN_MAX(index, 0);
if (index >= this->count) if (index >= this->count)
{ {
T *result = this->Push(item); T *result = this->Push(item);
return result; return result;
} }
index = DQN_MAX(index, 0); if (!this->data || (this->count + 1) > this->max)
i64 newSize = this->count + 1;
if (!this->data || newSize > this->max)
{ {
if (!this->Grow()) return nullptr; if (!this->Grow())
{
DQN_LOGE("DqnArray could not insert at index %d because growing failed.", index);
return nullptr;
}
} }
this->count++; this->count++;
for (auto i = this->count - 1; (i - 1) >= index; i--) for (auto i = this->count - 1; (i - 1) >= index; i--)
{
this->data[i] = this->data[i - 1]; this->data[i] = this->data[i - 1];
}
this->data[index] = item; this->data[index] = item;
T *result = this->data + index; T *result = this->data + index;
@ -731,7 +745,7 @@ void DqnArray<T>::Pop()
} }
template <typename T> template <typename T>
T *DqnArray<T>::Get(i64 const index) T *DqnArray<T>::Get(isize index)
{ {
T *result = nullptr; T *result = nullptr;
if (index >= 0 && index < this->count) result = &this->data[index]; if (index >= 0 && index < this->count) result = &this->data[index];
@ -739,51 +753,53 @@ T *DqnArray<T>::Get(i64 const index)
} }
template <typename T> template <typename T>
void DqnArray<T>::Clear(bool const zeroClear) void DqnArray<T>::Clear(bool zeroClear)
{ {
if (zeroClear) if (zeroClear)
{ {
i64 sizeToClear = sizeof(T) * this->count; isize sizeToClear = sizeof(T) * this->count;
DqnMem_Clear(this->data, 0, sizeToClear); DqnMem_Clear(this->data, 0, sizeToClear);
} }
this->count = 0; this->count = 0;
} }
template <typename T> template <typename T>
bool DqnArray<T>::Remove(i64 const index) bool DqnArray<T>::Remove(isize index)
{ {
if (index >= this->count || index < 0) return false; if (index >= this->count || index < 0)
return false;
bool firstElementAndOnlyElement = (index == 0 && this->count == 1); bool isLastElement = (index == (this->count - 1));
bool isLastElement = (index == (this->count - 1)); if (isLastElement && this->count == 1)
if (firstElementAndOnlyElement || isLastElement)
{ {
this->count--; this->count--;
return true; }
else
{
this->data[index] = this->data[this->count - 1];
this->count--;
} }
this->data[index] = this->data[this->count - 1];
this->count--;
return true; return true;
} }
template <typename T> template <typename T>
bool DqnArray<T>::RemoveStable(i64 const index) bool DqnArray<T>::RemoveStable(isize index)
{ {
if (index >= this->count || index < 0) return false; if (index >= this->count || index < 0)
return false;
bool firstElementAndOnlyElement = (index == 0 && this->count == 1); bool isLastElement = (index == (this->count - 1));
bool isLastElement = (index == (this->count - 1)); if (isLastElement && this->count == 1)
if (firstElementAndOnlyElement || isLastElement)
{ {
this->count--; this->count--;
return true; return true;
} }
i64 itemToRemoveByteOffset = index * sizeof(T); auto itemToRemoveByteOffset = index * sizeof(T);
i64 oneAfterItemToRemoveByteOffset = (index + 1) * sizeof(T); auto oneAfterItemToRemoveByteOffset = (index + 1) * sizeof(T);
i64 lastItemByteOffset = this->count * sizeof(T); auto lastItemByteOffset = this->count * sizeof(T);
i64 numBytesToMove = lastItemByteOffset - oneAfterItemToRemoveByteOffset; auto numBytesToMove = lastItemByteOffset - oneAfterItemToRemoveByteOffset;
u8 *bytePtr = (u8 *)this->data; u8 *bytePtr = (u8 *)this->data;
u8 *dest = &bytePtr[itemToRemoveByteOffset]; u8 *dest = &bytePtr[itemToRemoveByteOffset];
@ -795,18 +811,18 @@ bool DqnArray<T>::RemoveStable(i64 const index)
} }
template <typename T> template <typename T>
void DqnArray<T>::RemoveStable(i64 *indexList, const i64 numIndexes) void DqnArray<T>::RemoveStable(isize *indexList, isize numIndexes)
{ {
if (numIndexes == 0 || !indexList) return; if (numIndexes == 0 || !indexList) return;
// NOTE: Sort the index list and ensure we only remove indexes up to the size of our array // NOTE: Sort the index list and ensure we only remove indexes up to the size of our array
Dqn_QuickSort<i64>(indexList, numIndexes); Dqn_QuickSort<isize>(indexList, numIndexes);
i64 arrayHighestIndex = this->count - 1; auto arrayHighestIndex = this->count - 1;
i64 realCount = numIndexes; auto realCount = numIndexes;
if (indexList[numIndexes - 1] > arrayHighestIndex) if (indexList[numIndexes - 1] > arrayHighestIndex)
{ {
i64 realNumIndexes = auto realNumIndexes =
Dqn_BSearch(indexList, numIndexes, arrayHighestIndex, Dqn_BSearchBound_Lower); Dqn_BSearch(indexList, numIndexes, arrayHighestIndex, Dqn_BSearchBound_Lower);
// NOTE: If -1, then there's no index in the indexlist that is within the range of our array // NOTE: If -1, then there's no index in the indexlist that is within the range of our array
// i.e. no index we can remove without out of array bounds access // i.e. no index we can remove without out of array bounds access
@ -830,10 +846,10 @@ void DqnArray<T>::RemoveStable(i64 *indexList, const i64 numIndexes)
} }
else else
{ {
i64 indexListIndex = 0; auto indexListIndex = 0;
i64 indexToCopyTo = indexList[indexListIndex++]; auto indexToCopyTo = indexList[indexListIndex++];
i64 indexToCopyFrom = indexToCopyTo + 1; auto indexToCopyFrom = indexToCopyTo + 1;
i64 deadIndex = indexList[indexListIndex++]; auto deadIndex = indexList[indexListIndex++];
bool breakLoop = false; bool breakLoop = false;
for (; for (;
@ -2813,7 +2829,7 @@ DQN_FILE_SCOPE void DqnLog(char *file, char const *const functionName, i32 const
va_end(argList); va_end(argList);
} }
char const *const formatStr = "DqnLog:%s:%s,%d: %s"; char const *const formatStr = "DqnLog:%s:%s,%d: %s\n";
fprintf(stderr, formatStr, file, functionName, lineNum, userMsg); fprintf(stderr, formatStr, file, functionName, lineNum, userMsg);
#if defined(DQN_WIN32_PLATFORM) #if defined(DQN_WIN32_PLATFORM)
@ -2851,7 +2867,7 @@ DQN_FILE_SCOPE void DqnLog(char *file, char const *const functionName, i32 const
va_end(argList); va_end(argList);
} }
char const *const formatStr = "DqnLog:%s:%s,%d(%s): %s"; char const *const formatStr = "DqnLog:%s:%s,%d(%s): %s\n";
fprintf(stderr, formatStr, file, functionName, lineNum, expr, userMsg); fprintf(stderr, formatStr, file, functionName, lineNum, expr, userMsg);
#if defined(DQN_WIN32_PLATFORM) #if defined(DQN_WIN32_PLATFORM)

46
dqn_unit_test.cpp
View File

@ -1141,7 +1141,7 @@ void DqnArray_TestInternal(DqnMemAPI *const memAPI)
DqnArray<DqnV2> array = {}; DqnArray<DqnV2> array = {};
if (1) if (1)
{ {
DQN_ASSERT(array.Init(1, memAPI)); DQN_ASSERT(array.InitSize(1, memAPI));
DQN_ASSERT(array.max >= 1); DQN_ASSERT(array.max >= 1);
DQN_ASSERT(array.count == 0); DQN_ASSERT(array.count == 0);
@ -1219,16 +1219,16 @@ void DqnArray_TestInternal(DqnMemAPI *const memAPI)
LogSuccess("DqnArray(): Test resizing and free"); LogSuccess("DqnArray(): Test resizing and free");
} }
} }
DQN_ASSERT(array.Free()); array.Free();
if (1) if (1)
{ {
DQN_ASSERT(array.Init(1, memAPI)); DQN_ASSERT(array.InitSize(1, memAPI));
DQN_ASSERT(array.max >= 1); DQN_ASSERT(array.max >= 1);
DQN_ASSERT(array.count == 0); DQN_ASSERT(array.count == 0);
LogSuccess("DqnArray(): Empty array"); LogSuccess("DqnArray(): Empty array");
} }
DQN_ASSERT(array.Free()); array.Free();
if (1) if (1)
{ {
@ -1237,7 +1237,7 @@ void DqnArray_TestInternal(DqnMemAPI *const memAPI)
DqnV2 c = DqnV2_(5, 6); DqnV2 c = DqnV2_(5, 6);
DqnV2 d = DqnV2_(7, 8); DqnV2 d = DqnV2_(7, 8);
DQN_ASSERT(array.Init(16, memAPI)); DQN_ASSERT(array.InitSize(16, memAPI));
DQN_ASSERT(array.Remove(0) == false); DQN_ASSERT(array.Remove(0) == false);
DQN_ASSERT(array.max >= 16); DQN_ASSERT(array.max >= 16);
DQN_ASSERT(array.count == 0); DQN_ASSERT(array.count == 0);
@ -1277,7 +1277,7 @@ void DqnArray_TestInternal(DqnMemAPI *const memAPI)
DQN_ASSERT(array.count == 0); DQN_ASSERT(array.count == 0);
LogSuccess("DqnArray(): Test removal"); LogSuccess("DqnArray(): Test removal");
} }
DQN_ASSERT(array.Free()); array.Free();
if (1) if (1)
{ {
@ -1286,7 +1286,7 @@ void DqnArray_TestInternal(DqnMemAPI *const memAPI)
DqnV2 c = DqnV2_(5, 6); DqnV2 c = DqnV2_(5, 6);
DqnV2 d = DqnV2_(7, 8); DqnV2 d = DqnV2_(7, 8);
DQN_ASSERT(array.Init(16, memAPI)); DQN_ASSERT(array.InitSize(16, memAPI));
DQN_ASSERT(array.Push(a)); DQN_ASSERT(array.Push(a));
DQN_ASSERT(array.Push(b)); DQN_ASSERT(array.Push(b));
@ -1315,7 +1315,7 @@ void DqnArray_TestInternal(DqnMemAPI *const memAPI)
LogSuccess("DqnArray(): Test stable removal"); LogSuccess("DqnArray(): Test stable removal");
} }
DQN_ASSERT(array.Free()); array.Free();
} }
if (1) if (1)
@ -1327,7 +1327,7 @@ void DqnArray_TestInternal(DqnMemAPI *const memAPI)
i32 intList[] = {128, 32, 29, 31}; i32 intList[] = {128, 32, 29, 31};
DqnArray<i32> array; DqnArray<i32> array;
array.Init(DQN_ARRAY_COUNT(intList), memAPI); array.InitSize(DQN_ARRAY_COUNT(intList), memAPI);
array.Push(intList, DQN_ARRAY_COUNT(intList)); array.Push(intList, DQN_ARRAY_COUNT(intList));
array.RemoveStable(indexesToFree, DQN_ARRAY_COUNT(indexesToFree)); array.RemoveStable(indexesToFree, DQN_ARRAY_COUNT(indexesToFree));
DQN_ASSERT(array.count == 0); DQN_ASSERT(array.count == 0);
@ -1341,7 +1341,7 @@ void DqnArray_TestInternal(DqnMemAPI *const memAPI)
i32 intList[] = {128, 32, 29, 31}; i32 intList[] = {128, 32, 29, 31};
DqnArray<i32> array; DqnArray<i32> array;
array.Init(DQN_ARRAY_COUNT(intList), memAPI); array.InitSize(DQN_ARRAY_COUNT(intList), memAPI);
array.Push(intList, DQN_ARRAY_COUNT(intList)); array.Push(intList, DQN_ARRAY_COUNT(intList));
array.RemoveStable(indexesToFree, DQN_ARRAY_COUNT(indexesToFree)); array.RemoveStable(indexesToFree, DQN_ARRAY_COUNT(indexesToFree));
DQN_ASSERT(array.count == 4); DQN_ASSERT(array.count == 4);
@ -1359,7 +1359,7 @@ void DqnArray_TestInternal(DqnMemAPI *const memAPI)
i32 intList[] = {128, 32, 29, 31}; i32 intList[] = {128, 32, 29, 31};
DqnArray<i32> array; DqnArray<i32> array;
array.Init(DQN_ARRAY_COUNT(intList), memAPI); array.InitSize(DQN_ARRAY_COUNT(intList), memAPI);
array.Push(intList, DQN_ARRAY_COUNT(intList)); array.Push(intList, DQN_ARRAY_COUNT(intList));
array.RemoveStable(indexesToFree, DQN_ARRAY_COUNT(indexesToFree)); array.RemoveStable(indexesToFree, DQN_ARRAY_COUNT(indexesToFree));
DQN_ASSERT(array.count == 3); DQN_ASSERT(array.count == 3);
@ -1376,7 +1376,7 @@ void DqnArray_TestInternal(DqnMemAPI *const memAPI)
i32 intList[] = {128, 32, 29, 31}; i32 intList[] = {128, 32, 29, 31};
DqnArray<i32> array; DqnArray<i32> array;
array.Init(DQN_ARRAY_COUNT(intList), memAPI); array.InitSize(DQN_ARRAY_COUNT(intList), memAPI);
array.Push(intList, DQN_ARRAY_COUNT(intList)); array.Push(intList, DQN_ARRAY_COUNT(intList));
array.RemoveStable(indexesToFree, DQN_ARRAY_COUNT(indexesToFree)); array.RemoveStable(indexesToFree, DQN_ARRAY_COUNT(indexesToFree));
DQN_ASSERT(array.count == 4); DQN_ASSERT(array.count == 4);
@ -1394,7 +1394,7 @@ void DqnArray_TestInternal(DqnMemAPI *const memAPI)
i32 intList[] = {128, 32, 29, 31}; i32 intList[] = {128, 32, 29, 31};
DqnArray<i32> array; DqnArray<i32> array;
array.Init(DQN_ARRAY_COUNT(intList), memAPI); array.InitSize(DQN_ARRAY_COUNT(intList), memAPI);
array.Push(intList, DQN_ARRAY_COUNT(intList)); array.Push(intList, DQN_ARRAY_COUNT(intList));
array.RemoveStable(indexesToFree, DQN_ARRAY_COUNT(indexesToFree)); array.RemoveStable(indexesToFree, DQN_ARRAY_COUNT(indexesToFree));
DQN_ASSERT(array.count == 3); DQN_ASSERT(array.count == 3);
@ -1411,7 +1411,7 @@ void DqnArray_TestInternal(DqnMemAPI *const memAPI)
i32 intList[] = {128, 32, 29, 31}; i32 intList[] = {128, 32, 29, 31};
DqnArray<i32> array; DqnArray<i32> array;
array.Init(DQN_ARRAY_COUNT(intList), memAPI); array.InitSize(DQN_ARRAY_COUNT(intList), memAPI);
array.Push(intList, DQN_ARRAY_COUNT(intList)); array.Push(intList, DQN_ARRAY_COUNT(intList));
array.RemoveStable(indexesToFree, DQN_ARRAY_COUNT(indexesToFree)); array.RemoveStable(indexesToFree, DQN_ARRAY_COUNT(indexesToFree));
DQN_ASSERT(array.count == 2); DQN_ASSERT(array.count == 2);
@ -1427,7 +1427,7 @@ void DqnArray_TestInternal(DqnMemAPI *const memAPI)
i32 intList[] = {128, 32, 29, 31}; i32 intList[] = {128, 32, 29, 31};
DqnArray<i32> array; DqnArray<i32> array;
array.Init(DQN_ARRAY_COUNT(intList), memAPI); array.InitSize(DQN_ARRAY_COUNT(intList), memAPI);
array.Push(intList, DQN_ARRAY_COUNT(intList)); array.Push(intList, DQN_ARRAY_COUNT(intList));
array.RemoveStable(indexesToFree, DQN_ARRAY_COUNT(indexesToFree)); array.RemoveStable(indexesToFree, DQN_ARRAY_COUNT(indexesToFree));
@ -1444,7 +1444,7 @@ void DqnArray_TestInternal(DqnMemAPI *const memAPI)
i32 intList[] = {128, 32, 29, 31}; i32 intList[] = {128, 32, 29, 31};
DqnArray<i32> array; DqnArray<i32> array;
array.Init(DQN_ARRAY_COUNT(intList), memAPI); array.InitSize(DQN_ARRAY_COUNT(intList), memAPI);
array.Push(intList, DQN_ARRAY_COUNT(intList)); array.Push(intList, DQN_ARRAY_COUNT(intList));
array.RemoveStable(indexesToFree, DQN_ARRAY_COUNT(indexesToFree)); array.RemoveStable(indexesToFree, DQN_ARRAY_COUNT(indexesToFree));
@ -1472,7 +1472,7 @@ void DqnArray_TestRealDataInternal(DqnArray<char> *array)
for (auto i = 0; i < array->count; i++) for (auto i = 0; i < array->count; i++)
DQN_ASSERT(array->data[i] == buf[i]); DQN_ASSERT(array->data[i] == buf[i]);
DQN_ASSERT(array->Free()); array->Free();
free(buf); free(buf);
LogSuccess("DqnArray(): Testing real data"); LogSuccess("DqnArray(): Testing real data");
@ -1492,18 +1492,18 @@ void DqnArray_Test()
{ {
if (1) if (1)
{ {
DqnArray<char> array1 = DqnArray_<char>(3); DqnArray<char> array1;
array1.InitSize(3);
DQN_ASSERT(array1.count == 0); DQN_ASSERT(array1.count == 0);
DQN_ASSERT(array1.max == 3); DQN_ASSERT(array1.max == 3);
array1.Free(); array1.Free();
array1 = DqnArray_<char>(); array1.InitSize(0);
DQN_ASSERT(array1.count == 0); DQN_ASSERT(array1.count == 0);
DQN_ASSERT(array1.max == 0); DQN_ASSERT(array1.max == 0);
array1.Push('c'); array1.Push('c');
DQN_ASSERT(array1.count == 1); DQN_ASSERT(array1.count == 1);
DQN_ASSERT(array1.max == 1);
array1.Free(); array1.Free();
LogSuccess("DqnArray(): Testing faux-array constructors DqnArray_()"); LogSuccess("DqnArray(): Testing faux-array constructors DqnArray_()");
@ -1512,7 +1512,7 @@ void DqnArray_Test()
if (1) if (1)
{ {
DqnArray<char> array = {}; DqnArray<char> array = {};
DQN_ASSERT(array.Init(1)); DQN_ASSERT(array.InitSize(1));
DqnArray_TestRealDataInternal(&array); DqnArray_TestRealDataInternal(&array);
} }
@ -1525,7 +1525,7 @@ void DqnArray_Test()
{ {
auto memGuard0 = stack.TempRegionGuard(); auto memGuard0 = stack.TempRegionGuard();
DqnArray<char> array = {}; DqnArray<char> array = {};
DQN_ASSERT(array.Init(1, &stack.myAPI)); DQN_ASSERT(array.InitSize(1, &stack.myAPI));
DqnArray_TestRealDataInternal(&array); DqnArray_TestRealDataInternal(&array);
} }
@ -1534,7 +1534,7 @@ void DqnArray_Test()
{ {
auto memGuard0 = stack.TempRegionGuard(); auto memGuard0 = stack.TempRegionGuard();
DqnArray<char> array = {}; DqnArray<char> array = {};
DQN_ASSERT(array.Init(128, &stack.myAPI)); DQN_ASSERT(array.InitSize(128, &stack.myAPI));
stack.Push(1024); stack.Push(1024);
DqnArray_TestRealDataInternal(&array); DqnArray_TestRealDataInternal(&array);
} }