Bananymous
/
banan-os
1
1
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

BAN: Vector's and Queue's underlying type is T* instead of uint8_t* 

I have no idea what kind of brainfart I had to make use uint8_t*
that just complicated the code :D
This commit is contained in:
Bananymous 2023-02-10 00:06:58 +02:00
parent e5ffc1686f
commit 7ee4ecd7f4
2 changed files with 46 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
BAN/include/BAN/Queue.h
View File

@ -40,11 +40,9 @@ namespace BAN
private: private:
[[nodiscard]] ErrorOr<void> ensure_capacity(size_type size); [[nodiscard]] ErrorOr<void> ensure_capacity(size_type size);
const T* address_of(size_type, void* = nullptr) const;
T* address_of(size_type, void* = nullptr);
private: private:
uint8_t* m_data = nullptr; T* m_data = nullptr;
size_type m_capacity = 0; size_type m_capacity = 0;
size_type m_size = 0; size_type m_size = 0;
}; };
@ -66,7 +64,7 @@ namespace BAN
{ {
MUST(ensure_capacity(other.size())); MUST(ensure_capacity(other.size()));
for (size_type i = 0; i < other.size(); i++) for (size_type i = 0; i < other.size(); i++)
new (address_of(i)) T(*address_of(i, other.m_data)); new (m_data + i) T(other.m_data[i]);
m_size = other.m_size; m_size = other.m_size;
} }
@ -98,7 +96,7 @@ namespace BAN
clear(); clear();
MUST(ensure_capacity(other.size())); MUST(ensure_capacity(other.size()));
for (size_type i = 0; i < other.size(); i++) for (size_type i = 0; i < other.size(); i++)
new (address_of(i)) T(*address_of(i, other.m_data)); new (m_data + i) T(other.m_data[i]);
m_size = other.m_size; m_size = other.m_size;
return *this; return *this;
} }
@ -107,7 +105,7 @@ namespace BAN
ErrorOr<void> Queue<T>::push(T&& value) ErrorOr<void> Queue<T>::push(T&& value)
{ {
TRY(ensure_capacity(m_size + 1)); TRY(ensure_capacity(m_size + 1));
new (address_of(m_size)) T(move(value)); new (m_data + m_size) T(move(value));
m_size++; m_size++;
return {}; return {};
} }
@ -123,7 +121,7 @@ namespace BAN
ErrorOr<void> Queue<T>::emplace(Args&&... args) ErrorOr<void> Queue<T>::emplace(Args&&... args)
{ {
TRY(ensure_capacity(m_size + 1)); TRY(ensure_capacity(m_size + 1));
new (address_of(m_size)) T(forward<Args>(args)...); new (m_data + m_size) T(forward<Args>(args)...);
m_size++; m_size++;
return {}; return {};
} }
@ -133,8 +131,8 @@ namespace BAN
{ {
ASSERT(m_size > 0); ASSERT(m_size > 0);
for (size_type i = 0; i < m_size - 1; i++) for (size_type i = 0; i < m_size - 1; i++)
*address_of(i) = move(*address_of(i + 1)); m_data[i] = move(m_data[i + 1]);
address_of(m_size - 1)->~T(); m_data[m_size - 1].~T();
m_size--; m_size--;
} }
@ -142,7 +140,7 @@ namespace BAN
void Queue<T>::clear() void Queue<T>::clear()
{ {
for (size_type i = 0; i < m_size; i++) for (size_type i = 0; i < m_size; i++)
address_of(i)->~T(); m_data[i].~T();
BAN::deallocator(m_data); BAN::deallocator(m_data);
m_data = nullptr; m_data = nullptr;
m_capacity = 0; m_capacity = 0;
@ -165,14 +163,14 @@ namespace BAN
const T& Queue<T>::front() const const T& Queue<T>::front() const
{ {
ASSERT(m_size > 0); ASSERT(m_size > 0);
return *address_of(0); return m_data[0];
} }
template<typename T> template<typename T>
T& Queue<T>::front() T& Queue<T>::front()
{ {
ASSERT(m_size > 0); ASSERT(m_size > 0);
return *address_of(0); return m_data[0];
} }
template<typename T> template<typename T>
@ -181,13 +179,13 @@ namespace BAN
if (m_capacity > size) if (m_capacity > size)
return {}; return {};
size_type new_cap = BAN::Math::max<size_type>(size, m_capacity * 3 / 2); size_type new_cap = BAN::Math::max<size_type>(size, m_capacity * 3 / 2);
uint8_t* new_data = (uint8_t*)BAN::allocator(new_cap * sizeof(T)); T* new_data = (T*)BAN::allocator(new_cap * sizeof(T));
if (new_data == nullptr) if (new_data == nullptr)
return Error::from_string("Queue: Could not allocate memory"); return Error::from_string("Queue: Could not allocate memory");
for (size_type i = 0; i < m_size; i++) for (size_type i = 0; i < m_size; i++)
{ {
new (address_of(i, new_data)) T(move(*address_of(i))); new (new_data + i) T(move(m_data[i]));
address_of(i)->~T(); m_data[i].~T();
} }
BAN::deallocator(m_data); BAN::deallocator(m_data);
m_data = new_data; m_data = new_data;
@ -195,20 +193,4 @@ namespace BAN
return {}; return {};
} }
template<typename T>
const T* Queue<T>::address_of(size_type index, void* base) const
{
if (base == nullptr)
base = m_data;
return (T*)base + index;
}
template<typename T>
T* Queue<T>::address_of(size_type index, void* base)
{
if (base == nullptr)
base = m_data;
return (T*)base + index;
}
} }

84
BAN/include/BAN/Vector.h
View File

@ -39,10 +39,10 @@ namespace BAN
[[nodiscard]] ErrorOr<void> insert(size_type, T&&); [[nodiscard]] ErrorOr<void> insert(size_type, T&&);
[[nodiscard]] ErrorOr<void> insert(size_type, const T&); [[nodiscard]] ErrorOr<void> insert(size_type, const T&);
iterator begin() { return iterator(address_of(0)); } iterator begin() { return iterator (m_data); }
const_iterator begin() const { return const_iterator(address_of(0)); } const_iterator begin() const { return const_iterator(m_data); }
iterator end() { return iterator(address_of(m_size)); } iterator end() { return iterator (m_data + m_size); }
const_iterator end() const { return const_iterator(address_of(m_size)); } const_iterator end() const { return const_iterator(m_data + m_size); }
void pop_back(); void pop_back();
void remove(size_type); void remove(size_type);
@ -67,11 +67,9 @@ namespace BAN
private: private:
[[nodiscard]] ErrorOr<void> ensure_capacity(size_type); [[nodiscard]] ErrorOr<void> ensure_capacity(size_type);
const T* address_of(size_type, void* = nullptr) const;
T* address_of(size_type, void* = nullptr);
private: private:
uint8_t* m_data = nullptr; T* m_data = nullptr;
size_type m_capacity = 0; size_type m_capacity = 0;
size_type m_size = 0; size_type m_size = 0;
}; };
@ -136,7 +134,7 @@ namespace BAN
{ {
MUST(ensure_capacity(other.m_size)); MUST(ensure_capacity(other.m_size));
for (size_type i = 0; i < other.m_size; i++) for (size_type i = 0; i < other.m_size; i++)
new (address_of(i)) T(other[i]); new (m_data + i) T(other.m_data[i]);
m_size = other.m_size; m_size = other.m_size;
} }
@ -168,7 +166,7 @@ namespace BAN
clear(); clear();
MUST(ensure_capacity(other.size())); MUST(ensure_capacity(other.size()));
for (size_type i = 0; i < other.size(); i++) for (size_type i = 0; i < other.size(); i++)
new (address_of(i)) T(other[i]); new (m_data + i) T(other[i]);
m_size = other.m_size; m_size = other.m_size;
return *this; return *this;
} }
@ -177,7 +175,7 @@ namespace BAN
ErrorOr<void> Vector<T>::push_back(T&& value) ErrorOr<void> Vector<T>::push_back(T&& value)
{ {
TRY(ensure_capacity(m_size + 1)); TRY(ensure_capacity(m_size + 1));
new (address_of(m_size)) T(move(value)); new (m_data + m_size) T(move(value));
m_size++; m_size++;
return {}; return {};
} }
@ -193,7 +191,7 @@ namespace BAN
ErrorOr<void> Vector<T>::emplace_back(Args&&... args) ErrorOr<void> Vector<T>::emplace_back(Args&&... args)
{ {
TRY(ensure_capacity(m_size + 1)); TRY(ensure_capacity(m_size + 1));
new (address_of(m_size)) T(forward<Args>(args)...); new (m_data + m_size) T(forward<Args>(args)...);
m_size++; m_size++;
return {}; return {};
} }
@ -206,14 +204,14 @@ namespace BAN
TRY(ensure_capacity(m_size + 1)); TRY(ensure_capacity(m_size + 1));
if (index < m_size) if (index < m_size)
{ {
new (address_of(m_size)) T(move(*address_of(m_size - 1))); new (m_data + m_size) T(move(m_data[m_size - 1]));
for (size_type i = m_size - 1; i > index; i--) for (size_type i = m_size - 1; i > index; i--)
*address_of(i) = move(*address_of(i - 1)); m_data[i] = move(m_data[i - 1]);
*address_of(index) = move(T(forward<Args>(args)...)); m_data[index] = move(T(forward<Args>(args)...));
} }
else else
{ {
new (address_of(m_size)) T(forward<Args>(args)...); new (m_data + m_size) T(forward<Args>(args)...);
} }
m_size++; m_size++;
return {}; return {};
@ -226,14 +224,14 @@ namespace BAN
TRY(ensure_capacity(m_size + 1)); TRY(ensure_capacity(m_size + 1));
if (index < m_size) if (index < m_size)
{ {
new (address_of(m_size)) T(move(*address_of(m_size - 1))); new (m_data + m_size) T(move(m_data[m_size - 1]));
for (size_type i = m_size - 1; i > index; i--) for (size_type i = m_size - 1; i > index; i--)
*address_of(i) = move(*address_of(i - 1)); m_data[i] = move(m_data[i - 1]);
*address_of(index) = move(value); m_data[index] = move(value);
} }
else else
{ {
new (address_of(m_size)) T(move(value)); new (m_data + m_size) T(move(value));
} }
m_size++; m_size++;
return {}; return {};
@ -249,7 +247,7 @@ namespace BAN
void Vector<T>::pop_back() void Vector<T>::pop_back()
{ {
ASSERT(m_size > 0); ASSERT(m_size > 0);
address_of(m_size - 1)->~T(); m_data[m_size - 1].~T();
m_size--; m_size--;
} }
@ -258,8 +256,8 @@ namespace BAN
{ {
ASSERT(index < m_size); ASSERT(index < m_size);
for (size_type i = index; i < m_size - 1; i++) for (size_type i = index; i < m_size - 1; i++)
*address_of(i) = move(*address_of(i + 1)); m_data[i] = move(m_data[i + 1]);
address_of(m_size - 1)->~T(); m_data[m_size - 1].~T();
m_size--; m_size--;
} }
@ -267,7 +265,7 @@ namespace BAN
void Vector<T>::clear() void Vector<T>::clear()
{ {
for (size_type i = 0; i < m_size; i++) for (size_type i = 0; i < m_size; i++)
address_of(i)->~T(); m_data[i].~T();
BAN::deallocator(m_data); BAN::deallocator(m_data);
m_data = nullptr; m_data = nullptr;
m_capacity = 0; m_capacity = 0;
@ -278,7 +276,7 @@ namespace BAN
bool Vector<T>::contains(const T& other) const bool Vector<T>::contains(const T& other) const
{ {
for (size_type i = 0; i < m_size; i++) for (size_type i = 0; i < m_size; i++)
if (*address_of(i) == other) if (m_data[i] == other)
return true; return true;
return false; return false;
} }
@ -287,41 +285,41 @@ namespace BAN
const T& Vector<T>::operator[](size_type index) const const T& Vector<T>::operator[](size_type index) const
{ {
ASSERT(index < m_size); ASSERT(index < m_size);
return *address_of(index); return m_data[index];
} }
template<typename T> template<typename T>
T& Vector<T>::operator[](size_type index) T& Vector<T>::operator[](size_type index)
{ {
ASSERT(index < m_size); ASSERT(index < m_size);
return *address_of(index); return m_data[index];
} }
template<typename T> template<typename T>
const T& Vector<T>::back() const const T& Vector<T>::back() const
{ {
ASSERT(m_size > 0); ASSERT(m_size > 0);
return *address_of(m_size - 1); return m_data[m_size - 1];
} }
template<typename T> template<typename T>
T& Vector<T>::back() T& Vector<T>::back()
{ {
ASSERT(m_size > 0); ASSERT(m_size > 0);
return *address_of(m_size - 1); return m_data[m_size - 1];
} }
template<typename T> template<typename T>
const T& Vector<T>::front() const const T& Vector<T>::front() const
{ {
ASSERT(m_size > 0); ASSERT(m_size > 0);
return *address_of(0); return m_data[0];
} }
template<typename T> template<typename T>
T& Vector<T>::front() T& Vector<T>::front()
{ {
ASSERT(m_size > 0); ASSERT(m_size > 0);
return *address_of(0); return m_data[0];
} }
template<typename T> template<typename T>
@ -330,10 +328,10 @@ namespace BAN
TRY(ensure_capacity(size)); TRY(ensure_capacity(size));
if (size < m_size) if (size < m_size)
for (size_type i = size; i < m_size; i++) for (size_type i = size; i < m_size; i++)
address_of(i)->~T(); m_data[i].~T();
if (size > m_size) if (size > m_size)
for (size_type i = m_size; i < size; i++) for (size_type i = m_size; i < size; i++)
new (address_of(i)) T(); new (m_data + i) T();
m_size = size; m_size = size;
return {}; return {};
} }
@ -369,13 +367,13 @@ namespace BAN
if (m_capacity >= size) if (m_capacity >= size)
return {}; return {};
size_type new_cap = BAN::Math::max<size_type>(size, m_capacity * 3 / 2); size_type new_cap = BAN::Math::max<size_type>(size, m_capacity * 3 / 2);
uint8_t* new_data = (uint8_t*)BAN::allocator(new_cap * sizeof(T)); T* new_data = (T*)BAN::allocator(new_cap * sizeof(T));
if (new_data == nullptr) if (new_data == nullptr)
return Error::from_string("Vector: Could not allocate memory"); return Error::from_string("Vector: Could not allocate memory");
for (size_type i = 0; i < m_size; i++) for (size_type i = 0; i < m_size; i++)
{ {
new (address_of(i, new_data)) T(move(*address_of(i))); new (new_data + i) T(move(m_data[i]));
address_of(i)->~T(); m_data[i].~T();
} }
BAN::deallocator(m_data); BAN::deallocator(m_data);
m_data = new_data; m_data = new_data;
@ -383,20 +381,4 @@ namespace BAN
return {}; return {};
} }
template<typename T>
const T* Vector<T>::address_of(size_type index, void* base) const
{
if (base == nullptr)
base = m_data;
return (T*)base + index;
}
template<typename T>
T* Vector<T>::address_of(size_type index, void* base)
{
if (base == nullptr)
base = m_data;
return (T*)base + index;
}
} }