160 lines
2.9 KiB
C++
160 lines
2.9 KiB
C++
#pragma once
|
|
|
|
#include <inttypes.h>
|
|
#include "new.hpp"
|
|
|
|
namespace ker
|
|
{
|
|
template<typename T>
|
|
class Vector
|
|
{
|
|
public:
|
|
static const size_t initialCap = 32;
|
|
private:
|
|
T *mData;
|
|
size_t mLength;
|
|
size_t mReserved;
|
|
public:
|
|
Vector() :
|
|
mData(nullptr),
|
|
mLength(0),
|
|
mReserved(0)
|
|
{
|
|
this->reserve(Vector<T>::initialCap);
|
|
}
|
|
|
|
Vector(const Vector &other) :
|
|
mData(nullptr),
|
|
mLength(0),
|
|
mReserved(0)
|
|
{
|
|
this->mLength = other.mLength;
|
|
if(this->mLength > 0) {
|
|
this->reserve(this->mLength);
|
|
for(size_t i = 0; i < this->mLength; i++) {
|
|
new (&this->mData[i]) T(other.mData[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
Vector(Vector &&other) :
|
|
mData(other.mData),
|
|
mLength(other.mLength),
|
|
mReserved(other.mReserved)
|
|
{
|
|
other.mData = nullptr;
|
|
other.mLength = 0;
|
|
other.mReserved = 0;
|
|
}
|
|
|
|
Vector & operator = (const Vector &other)
|
|
{
|
|
this->resize(other.mLength);
|
|
for(size_t i = 0; i < this->mLength; i++)
|
|
{
|
|
this->mData[i] = other.mData[i];
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
explicit Vector(size_t initialReserve) :
|
|
Vector()
|
|
{
|
|
this->reserve(initialReserve);
|
|
}
|
|
|
|
~Vector()
|
|
{
|
|
if(this->mData != nullptr) {
|
|
free(this->mData);
|
|
}
|
|
}
|
|
|
|
size_t length() const
|
|
{
|
|
return this->mLength;
|
|
}
|
|
|
|
T &at(size_t index)
|
|
{
|
|
return this->mData[index];
|
|
}
|
|
|
|
const T &at(size_t index) const
|
|
{
|
|
return this->mData[index];
|
|
}
|
|
|
|
void append(const T &value)
|
|
{
|
|
this->reserve(this->mLength + 1);
|
|
new (&this->mData[this->mLength]) T(value);
|
|
this->mLength += 1;
|
|
}
|
|
|
|
void resize(size_t size)
|
|
{
|
|
size_t current = this->mLength;
|
|
this->reserve(size);
|
|
|
|
if(current > size) {
|
|
// "Downgrade"
|
|
for(size_t i = this->mLength - 1; i > size; i--) {
|
|
this->mData[i].~T();
|
|
}
|
|
} else {
|
|
// "Upgrade"
|
|
for(size_t i = this->mLength; i < size; i++) {
|
|
new (&this->mData[i]) T ();
|
|
}
|
|
}
|
|
this->mLength = size;
|
|
}
|
|
|
|
void reserve(size_t space)
|
|
{
|
|
if(this->mReserved >= space) {
|
|
return;
|
|
}
|
|
const size_t newSize = sizeof(T) * space;
|
|
|
|
T *newData = (T*)malloc(newSize);
|
|
if(this->mData != nullptr) {
|
|
memcpy(newData, this->mData, newSize);
|
|
free(this->mData);
|
|
}
|
|
this->mData = newData;
|
|
this->mReserved = space;
|
|
}
|
|
|
|
T& operator [](size_t idx)
|
|
{
|
|
return this->at(idx);
|
|
}
|
|
|
|
const T& operator [](size_t idx) const
|
|
{
|
|
return this->at(idx);
|
|
}
|
|
|
|
T* begin()
|
|
{
|
|
return &this->mData[0];
|
|
}
|
|
|
|
T* end()
|
|
{
|
|
return &this->mData[this->mLength];
|
|
}
|
|
|
|
const T* begin() const
|
|
{
|
|
return &this->mData[0];
|
|
}
|
|
|
|
const T* end() const
|
|
{
|
|
return &this->mData[this->mLength];
|
|
}
|
|
};
|
|
}
|