426 lines
10 KiB
C++
426 lines
10 KiB
C++
#pragma once
|
|
|
|
#include "Types.h"
|
|
#include "BaseObj.h"
|
|
|
|
#include <initializer_list>
|
|
#include <algorithm>
|
|
|
|
namespace ehs
|
|
{
|
|
/// A helper class for C-style arrays.
|
|
/// @tparam T Array data type to use.
|
|
/// @tparam N Number data type to use.
|
|
template<typename T, typename N = UInt_64>
|
|
class Array : public BaseObj
|
|
{
|
|
protected:
|
|
T* data;
|
|
N size;
|
|
|
|
public:
|
|
/// Frees any data created on the heap.
|
|
~Array() override
|
|
{
|
|
delete[] data;
|
|
}
|
|
|
|
/// Default members initialization.
|
|
Array()
|
|
: data(nullptr), size(0)
|
|
{
|
|
AddType("Array");
|
|
}
|
|
|
|
/// Initializes an empty array with the given size.
|
|
/// @note Data must be assigned manually using an index.
|
|
explicit Array(const N size)
|
|
: data(new T[size]), size(size)
|
|
{
|
|
AddType("Array");
|
|
}
|
|
|
|
/// Initializes this array with an initializer list object.
|
|
/// @param [in] list The given initializer list.
|
|
Array(std::initializer_list<T> list)
|
|
: data(new T[list.size()]), size(list.size())
|
|
{
|
|
AddType("Array");
|
|
|
|
N i = 0;
|
|
for (auto v = list.begin(); v != list.end(); ++v)
|
|
data[i++] = std::move(*v);
|
|
}
|
|
|
|
/// Initializes members with given C-style array.
|
|
/// @param [in] data The C-style array.
|
|
/// @param [in] size The size of the given C-style array.
|
|
Array(const T* const data, const N size)
|
|
: data(new T[size]), size(size)
|
|
{
|
|
AddType("Array");
|
|
|
|
for (N i = 0; i < size; ++i)
|
|
this->data[i] = data[i];
|
|
}
|
|
|
|
Array(Array&& array) noexcept
|
|
: BaseObj(array), data(array.data), size(array.size)
|
|
{
|
|
array.data = nullptr;
|
|
array.size = 0;
|
|
}
|
|
|
|
/// Copies all members from the given array object.
|
|
/// @param [in] array The array object to copy from.
|
|
Array(const Array& array)
|
|
: BaseObj((BaseObj&&)array), data(new T[array.size]), size(array.size)
|
|
{
|
|
for (N i = 0; i < size; ++i)
|
|
data[i] = array.data[i];
|
|
}
|
|
|
|
Array<T, N>& operator=(Array&& array) noexcept
|
|
{
|
|
if (this == &array)
|
|
return *this;
|
|
|
|
BaseObj::operator=((BaseObj&&)array);
|
|
|
|
delete[] data;
|
|
data = array.data;
|
|
size = array.size;
|
|
|
|
array.data = nullptr;
|
|
array.size = 0;
|
|
|
|
return *this;
|
|
}
|
|
|
|
/// Copies all members from the given array object.
|
|
/// @param [in] array The array object to copy from.
|
|
/// @returns The array that has been assigned to.
|
|
Array<T, N>& operator=(const Array& array)
|
|
{
|
|
if (this == &array)
|
|
return *this;
|
|
|
|
BaseObj::operator=(array);
|
|
|
|
delete[] data;
|
|
data = new T[array.size];
|
|
for (N i = 0; i < array.size; ++i)
|
|
data[i] = array.data[i];
|
|
|
|
size = array.size;
|
|
|
|
return *this;
|
|
}
|
|
|
|
/// Copies all members from the given initializer list object.
|
|
/// @param [in] list The initializer list object to copy from.
|
|
/// @returns The array that has been assigned to.
|
|
Array& operator=(std::initializer_list<T> list)
|
|
{
|
|
delete[] data;
|
|
data = new T[list.size];
|
|
|
|
N i = 0;
|
|
for (auto v = list.begin(); v != list.end(); ++v)
|
|
data[i++] = std::move(*v);
|
|
|
|
size = list.size();
|
|
|
|
return *this;
|
|
}
|
|
|
|
/// Adds a given array object at the end of the array.
|
|
/// @param [in] value The given array object to push to the end of the array.
|
|
Array& operator+=(Array value)
|
|
{
|
|
T* result = new T[size + value.size];
|
|
|
|
for (N i = 0; i < size; ++i)
|
|
result[i] = std::move(data[i]);
|
|
|
|
for (N i = 0; i < value.size; ++i)
|
|
result[size + i] = std::move(value[i]);
|
|
|
|
delete[] data;
|
|
|
|
data = result;
|
|
size += value.size;
|
|
|
|
return *this;
|
|
}
|
|
|
|
bool operator==(const Array& in) const
|
|
{
|
|
if (size != in.size)
|
|
return false;
|
|
|
|
return Util::Compare(data, in.data, size);
|
|
}
|
|
|
|
bool operator!=(const Array& in) const
|
|
{
|
|
if (size != in.size)
|
|
return true;
|
|
|
|
return !Util::Compare(data, in.data, size);
|
|
}
|
|
|
|
/// Adds a given array object at the end of the array.
|
|
/// @param [in] value The given initializer list to push to the end of the array.
|
|
Array& operator+=(std::initializer_list<T> value)
|
|
{
|
|
T* result = new T[size + value.size()];
|
|
|
|
for (N i = 0; i < size; ++i)
|
|
result[i] = std::move(data[i]);
|
|
|
|
N i = 0;
|
|
for (auto v = value.begin(); v != value.end(); ++v)
|
|
result[size + i++] = std::move(*v);
|
|
|
|
delete[] data;
|
|
|
|
data = result;
|
|
size += value.size();
|
|
|
|
return *this;
|
|
}
|
|
|
|
/// Adds a given value at the end of the array.
|
|
/// @param [in] value The given value to push to the end of the array.
|
|
Array& operator+=(const T value)
|
|
{
|
|
T* result = new T[size + 1];
|
|
|
|
for (N i = 0; i < size; ++i)
|
|
result[i] = std::move(data[i]);
|
|
|
|
result[size] = std::move(value);
|
|
|
|
delete[] data;
|
|
|
|
data = result;
|
|
++size;
|
|
|
|
return *this;
|
|
}
|
|
|
|
/// Retrieves the raw C-style array from casting an array object.
|
|
operator T* () const
|
|
{
|
|
return data;
|
|
}
|
|
|
|
/// Swaps two values in the array.
|
|
/// @param a The first index to swap with.
|
|
/// @param b The second index to swap with.
|
|
void Swap(N a, N b) const
|
|
{
|
|
T tmp = std::move(data[a]);
|
|
|
|
data[a] = std::move(data[b]);
|
|
data[b] = std::move(tmp);
|
|
}
|
|
|
|
void Insert(const N index, const T value)
|
|
{
|
|
N newSize = 0;
|
|
if (index > size - 1)
|
|
newSize = size + ((index + 1) - size);
|
|
else
|
|
newSize = size + 1;
|
|
|
|
T* result = new T[newSize];
|
|
|
|
for (N i = 0; i < index; ++i)
|
|
result[i] = std::move(data[i]);
|
|
|
|
result[index] = std::move(value);
|
|
|
|
for (N i = index; i < size; ++i)
|
|
result[i + 1] = std::move(data[i]);
|
|
|
|
delete[] data;
|
|
data = result;
|
|
|
|
size = newSize;
|
|
}
|
|
|
|
T Remove(const N index)
|
|
{
|
|
T popped = {};
|
|
|
|
if (!size || index >= size)
|
|
return popped;
|
|
|
|
popped = std::move(data[index]);
|
|
|
|
N newSize = size - 1;
|
|
T* result = new T[newSize];
|
|
|
|
for (N i = 0; i < index; ++i)
|
|
result[i] = std::move(data[i]);
|
|
|
|
for (N i = index + 1; i < size; ++i)
|
|
result[i - 1] = std::move(data[i]);
|
|
|
|
delete[] data;
|
|
data = result;
|
|
size = newSize;
|
|
|
|
return popped;
|
|
}
|
|
|
|
/// Adds a given C-style array at the end of the array.
|
|
/// @param [in] value The given C-style array to push to the end of the array.
|
|
/// @param [in] size The size of the given C-style array.
|
|
void Push(const T* const value, const N size)
|
|
{
|
|
T* result = new T[this->size + size];
|
|
|
|
for (N i = 0; i < this->size; ++i)
|
|
result[i] = std::move(this->data[i]);
|
|
|
|
for (N i = 0; i < size; ++i)
|
|
result[this->size + i] = value[i];
|
|
|
|
delete[] data;
|
|
|
|
this->data = result;
|
|
this->size += size;
|
|
}
|
|
|
|
/// Adds a given array object at the end of the array.
|
|
/// @param [in] value The given array object to push to the end of the array.
|
|
void Push(Array value)
|
|
{
|
|
T* result = new T[size + value.size];
|
|
|
|
for (N i = 0; i < size; ++i)
|
|
result[i] = std::move(data[i]);
|
|
|
|
for (N i = 0; i < value.size; ++i)
|
|
result[size + i] = std::move(value[i]);
|
|
|
|
delete[] data;
|
|
|
|
data = result;
|
|
size += value.size;
|
|
}
|
|
|
|
/// Adds a given array object at the end of the array.
|
|
/// @param [in] value The given initializer list to push to the end of the array.
|
|
void Push(std::initializer_list<T> value)
|
|
{
|
|
T* result = new T[size + value.size()];
|
|
|
|
for (N i = 0; i < size; ++i)
|
|
result[i] = std::move(data[i]);
|
|
|
|
N i = 0;
|
|
for (auto v = value.begin(); v != value.end(); ++v)
|
|
result[size + i++] = std::move(*v);
|
|
|
|
delete[] data;
|
|
|
|
data = result;
|
|
size += value.size();
|
|
}
|
|
|
|
/// Adds a given value at the end of the array.
|
|
/// @param [in] value The given value to push to the end of the array.
|
|
void Push(T value)
|
|
{
|
|
T* result = new T[size + 1];
|
|
|
|
for (N i = 0; i < size; ++i)
|
|
result[i] = std::move(data[i]);
|
|
|
|
result[size] = std::move(value);
|
|
|
|
delete[] data;
|
|
|
|
data = result;
|
|
++size;
|
|
}
|
|
|
|
/// Removes a value at the end of the array.
|
|
/// @returns The value that was popped.
|
|
T Pop()
|
|
{
|
|
T* result = new T[--size];
|
|
|
|
T popped = (T&&)data[size];
|
|
|
|
for (N i = 0; i < size; ++i)
|
|
result[i] = (T&&)data[i];
|
|
|
|
delete[] data;
|
|
|
|
data = result;
|
|
|
|
return popped;
|
|
}
|
|
|
|
/// Will swap the value at the given index with the value at the end of the array and pops it.
|
|
/// @param [in] index The index of the value to swap with.
|
|
/// @returns The removed value.
|
|
T Pop(const N index)
|
|
{
|
|
if (!size)
|
|
return {};
|
|
|
|
N lastIndex = size - 1;
|
|
|
|
if (index < lastIndex)
|
|
Swap(index, lastIndex);
|
|
|
|
return Pop();
|
|
}
|
|
|
|
void Clear()
|
|
{
|
|
if (!data)
|
|
return;
|
|
|
|
delete[] data;
|
|
data = nullptr;
|
|
size = 0;
|
|
}
|
|
|
|
/// Resizes the array.
|
|
/// @param [in] newSize The size to change to.
|
|
void Resize(const N newSize)
|
|
{
|
|
if (size == newSize)
|
|
return;
|
|
|
|
T* result = new T[newSize];
|
|
|
|
for (N i = 0; i < newSize && i < size; ++i)
|
|
result[i] = std::move(data[i]);
|
|
|
|
delete[] data;
|
|
|
|
data = result;
|
|
size = newSize;
|
|
}
|
|
|
|
/// Retrieves the size of the array.
|
|
/// @returns The resulting size.
|
|
N Size() const
|
|
{
|
|
return size;
|
|
}
|
|
|
|
N End() const
|
|
{
|
|
return size - 1;
|
|
}
|
|
};
|
|
} |