christoph/churlos
1
Fork 0
Code Activity

Reformat

Browse Source
This commit is contained in:
Christoph Urlacher
2022-12-08 13:58:44 +01:00
parent 610ec1b2e9
commit 9f89461155
1 changed files with 83 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

165
src/lib/container/Vector.h
View File

@ -21,88 +21,6 @@ class Vector {
public: public:
using iterator = ContinuousIterator<T>; using iterator = ContinuousIterator<T>;
private:
static constexpr const std::size_t default_cap = 16; // Arbitrary but very small
static constexpr const std::size_t min_cap = 8; // Slots to allocate extra when array full
T *buf = nullptr; // Heap allocated as size needs to change during runtime
std::size_t sz = 0; // The current size of the buffer (marks the slot where to insert a new element)
std::size_t buf_cap = 0; // The current capacity of the buffer
void init(std::size_t cap = Vector::default_cap) {
if (buf != nullptr) {
return;
}
buf = new T[cap];
buf_cap = cap;
}
[[nodiscard]] std::size_t get_rem_cap() const {
return buf_cap - size();
}
// Enlarges the buffer if we run out of space
void min_expand() {
// Init if necessary
if (buf == nullptr) {
init();
return; // Dont have to realloc after init
}
// Since we only ever add single elements this should never get below zero
if (get_rem_cap() < min_cap) {
switch_buf(buf_cap + min_cap);
}
}
// 1. Allocates new buffer
// 2. Moves stuff to new buffer
// 3. Deletes old buffer
// 4. Sets new pos/cap
void switch_buf(std::size_t cap) {
// Alloc new array
T *new_buf = new T[cap];
// Swap current elements to new array
for (std::size_t i = 0; i < size(); ++i) {
new_buf[i] = std::move(buf[i]);
buf[i].~T(); // TODO: I think delete[] buf calls these, verify that
}
// Move new array to buf, deleting the old array
delete[] buf;
buf = new_buf;
buf_cap = cap;
}
// Index is location where space should be made
void copy_right(std::size_t i) {
if (i >= size()) {
return; // We don't need to copy anything as space is already there
}
// TODO: Delete instead of ~T()?
for (std::size_t idx = size(); idx > i; --idx) {
buf[idx].~T(); // Delete previously contained element that will be overridden
buf[idx] = std::move(buf[idx - 1]); // This leaves a "shell" of the old object that has to be deleted
buf[idx - 1].~T(); // Delete element in moved-out state
}
}
// Index is the location that will be removed
void copy_left(std::size_t i) {
if (i >= size()) {
return; // We don't need to copy anything as nothing will be overridden
}
// TODO: Delete instead of ~T()?
for (std::size_t idx = i; idx < size(); ++idx) {
buf[idx].~T(); // Delete the element that will be overwritten
buf[idx] = std::move(buf[idx + 1]);
buf[idx + 1].~T();
}
}
public: public:
explicit Vector(bool lazy = false) { explicit Vector(bool lazy = false) {
if (!lazy) { if (!lazy) {
@ -293,6 +211,89 @@ public:
[[nodiscard]] bool initialized() const { [[nodiscard]] bool initialized() const {
return buf != nullptr; return buf != nullptr;
} }
private:
static constexpr const std::size_t default_cap = 16; // Arbitrary but very small
static constexpr const std::size_t min_cap = 8; // Slots to allocate extra when array full
T *buf = nullptr; // Heap allocated as size needs to change during runtime
std::size_t sz = 0; // The current size of the buffer (marks the slot where to insert a new element)
std::size_t buf_cap = 0; // The current capacity of the buffer
private:
void init(std::size_t cap = Vector::default_cap) {
if (buf != nullptr) {
return;
}
buf = new T[cap];
buf_cap = cap;
}
[[nodiscard]] std::size_t get_rem_cap() const {
return buf_cap - size();
}
// Enlarges the buffer if we run out of space
void min_expand() {
// Init if necessary
if (buf == nullptr) {
init();
return; // Dont have to realloc after init
}
// Since we only ever add single elements this should never get below zero
if (get_rem_cap() < min_cap) {
switch_buf(buf_cap + min_cap);
}
}
// 1. Allocates new buffer
// 2. Moves stuff to new buffer
// 3. Deletes old buffer
// 4. Sets new pos/cap
void switch_buf(std::size_t cap) {
// Alloc new array
T *new_buf = new T[cap];
// Swap current elements to new array
for (std::size_t i = 0; i < size(); ++i) {
new_buf[i] = std::move(buf[i]);
buf[i].~T(); // TODO: I think delete[] buf calls these, verify that
}
// Move new array to buf, deleting the old array
delete[] buf;
buf = new_buf;
buf_cap = cap;
}
// Index is location where space should be made
void copy_right(std::size_t i) {
if (i >= size()) {
return; // We don't need to copy anything as space is already there
}
// TODO: Delete instead of ~T()?
for (std::size_t idx = size(); idx > i; --idx) {
buf[idx].~T(); // Delete previously contained element that will be overridden
buf[idx] = std::move(buf[idx - 1]); // This leaves a "shell" of the old object that has to be deleted
buf[idx - 1].~T(); // Delete element in moved-out state
}
}
// Index is the location that will be removed
void copy_left(std::size_t i) {
if (i >= size()) {
return; // We don't need to copy anything as nothing will be overridden
}
// TODO: Delete instead of ~T()?
for (std::size_t idx = i; idx < size(); ++idx) {
buf[idx].~T(); // Delete the element that will be overwritten
buf[idx] = std::move(buf[idx + 1]);
buf[idx + 1].~T();
}
}
}; };
// Erase all elements that match a predicate // Erase all elements that match a predicate