Sinipelto/banan-os
1
0
Fork 0
forked from Bananymous/banan-os
Code Pull Requests Activity

All: rename every function from UpperCamelCase to snake_case

Browse Source 
This was a mess since I didn't know which to use but now I decided
to go with snake_case :)
This commit is contained in:
Bananymous
2023-02-01 21:05:44 +02:00
parent 4faa662a59
commit 9b8de5025a
50 changed files with 737 additions and 709 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
BAN/include/BAN/Array.h
View File

@@ -21,12 +21,12 @@ namespace BAN
const T& operator[](size_type) const;
T& operator[](size_type);
const T& Back() const;
T& Back();
const T& Front() const;
T& Front();
const T& back() const;
T& back();
const T& front() const;
T& front();
constexpr size_type Size() const;
constexpr size_type size() const;
private:
T m_data[S];
@@ -61,35 +61,35 @@ namespace BAN
}
template<typename T, size_t S>
const T& Array<T, S>::Back() const
const T& Array<T, S>::back() const
{
ASSERT(S != 0);
return m_data[S - 1];
}
template<typename T, size_t S>
T& Array<T, S>::Back()
T& Array<T, S>::back()
{
ASSERT(S != 0);
return m_data[S - 1];
}
template<typename T, size_t S>
const T& Array<T, S>::Front() const
const T& Array<T, S>::front() const
{
ASSERT(S != 0);
return m_data[0];
}
template<typename T, size_t S>
T& Array<T, S>::Front()
T& Array<T, S>::front()
{
ASSERT(S != 0);
return m_data[0];
}
template<typename T, size_t S>
constexpr typename Array<T, S>::size_type Array<T, S>::Size() const
constexpr typename Array<T, S>::size_type Array<T, S>::size() const
{
return S;
}

34
BAN/include/BAN/Errors.h
View File

@@ -6,13 +6,13 @@
#if defined(__is_kernel)
#include <kernel/Panic.h>
#define MUST(error) ({ auto e = error; if (e.IsError()) Kernel::Panic("{}", e.GetError()); e.Value(); })
#define ASSERT(cond) do { if (!(cond)) Kernel::Panic("ASSERT("#cond") failed"); } while(false)
#define MUST(error) ({ auto e = error; if (e.is_error()) Kernel::panic("{}", e.get_error()); e.value(); })
#define ASSERT(cond) do { if (!(cond)) Kernel::panic("ASSERT("#cond") failed"); } while(false)
#else
#error "NOT IMPLEMENTED"
#endif
#define TRY(error) ({ auto e = error; if (e.IsError()) return e.GetError(); e.Value(); })
#define TRY(error) ({ auto e = error; if (e.is_error()) return e.get_error(); e.value(); })
namespace BAN
{
@@ -20,7 +20,7 @@ namespace BAN
class Error
{
public:
static Error FromString(const char* message)
static Error from_string(const char* message)
{
Error result;
strncpy(result.m_message, message, sizeof(m_message));
@@ -29,8 +29,8 @@ namespace BAN
return result;
}
uint8_t GetErrorCode() const { return m_error_code; }
const char* GetMessage() const { return m_message; }
uint8_t get_error_code() const { return m_error_code; }
const char* get_message() const { return m_message; }
private:
char m_message[128];
@@ -43,12 +43,12 @@ namespace BAN
public:
ErrorOr(const T& value) : m_has_error(false) { m_data = (void*)new T(value); }
ErrorOr(const Error& error) : m_has_error(true) { m_data = (void*)new Error(error); }
template<typename S> ErrorOr(const ErrorOr<S>& other) : ErrorOr(other.GetError()) {}
~ErrorOr() { IsError() ? (delete reinterpret_cast<Error*>(m_data)) : (delete reinterpret_cast<T*>(m_data)); }
template<typename S> ErrorOr(const ErrorOr<S>& other) : ErrorOr(other.get_error()) {}
~ErrorOr() { is_error() ? (delete reinterpret_cast<Error*>(m_data)) : (delete reinterpret_cast<T*>(m_data)); }
bool IsError() const { return m_has_error; }
const Error& GetError() const { return *reinterpret_cast<Error*>(m_data); }
T& Value() { return *reinterpret_cast<T*>(m_data); }
bool is_error() const { return m_has_error; }
const Error& get_error() const { return *reinterpret_cast<Error*>(m_data); }
T& value() { return *reinterpret_cast<T*>(m_data); }
private:
bool m_has_error = false;
@@ -63,9 +63,9 @@ namespace BAN
ErrorOr(const Error& error) : m_error(error) { }
~ErrorOr() { }
bool IsError() const { return m_has_error; }
const Error& GetError() const { return m_error; }
void Value() { }
bool is_error() const { return m_has_error; }
const Error& get_error() const { return m_error; }
void value() { }
private:
Error m_error;
@@ -79,9 +79,9 @@ namespace BAN::Formatter
template<typename F>
void print_argument_impl(F putc, const Error& error, const ValueFormat&)
{
if (error.GetErrorCode() == 0xFF)
print(putc, error.GetMessage());
if (error.get_error_code() == 0xFF)
print(putc, error.get_message());
else
print(putc, "{} ({})", error.GetMessage(), error.GetErrorCode());
print(putc, "{} ({})", error.get_message(), error.get_error_code());
}
}

1
BAN/include/BAN/ForwardList.h
View File

@@ -13,5 +13,6 @@ namespace BAN
class String;
class StringView;
template<typename> class Vector;
template<typename> class LinkedList;
}

10
BAN/include/BAN/Function.h
View File

@@ -41,7 +41,7 @@ namespace BAN
Ret operator()(Args... args)
{
ASSERT(*this);
return reinterpret_cast<CallableBase*>(m_storage)->call(Forward<Args>(args)...);
return reinterpret_cast<CallableBase*>(m_storage)->call(forward<Args>(args)...);
}
operator bool() const
@@ -67,7 +67,7 @@ namespace BAN
virtual Ret call(Args... args) override
{
return m_function(Forward<Args>(args)...);
return m_function(forward<Args>(args)...);
}
private:
@@ -84,7 +84,7 @@ namespace BAN
virtual Ret call(Args... args) override
{
return (m_owner->*m_function)(Forward<Args>(args)...);
return (m_owner->*m_function)(forward<Args>(args)...);
}
private:
@@ -102,7 +102,7 @@ namespace BAN
virtual Ret call(Args... args) override
{
return (m_owner->*m_function)(Forward<Args>(args)...);
return (m_owner->*m_function)(forward<Args>(args)...);
}
private:
@@ -119,7 +119,7 @@ namespace BAN
virtual Ret call(Args... args) override
{
return m_lambda(Forward<Args>(args)...);
return m_lambda(forward<Args>(args)...);
}
private:

78
BAN/include/BAN/LinkedList.h
View File

@@ -28,31 +28,31 @@ namespace BAN
LinkedList() = default;
~LinkedList();
[[nodiscard]] ErrorOr<void> PushBack(const T&);
[[nodiscard]] ErrorOr<void> PushBack(T&&);
[[nodiscard]] ErrorOr<void> Insert(const_iterator, const T&);
[[nodiscard]] ErrorOr<void> Insert(const_iterator, T&&);
[[nodiscard]] ErrorOr<void> push_back(const T&);
[[nodiscard]] ErrorOr<void> push_back(T&&);
[[nodiscard]] ErrorOr<void> insert(const_iterator, const T&);
[[nodiscard]] ErrorOr<void> insert(const_iterator, T&&);
template<typename... Args>
[[nodiscard]] ErrorOr<void> EmplaceBack(Args...);
[[nodiscard]] ErrorOr<void> emplace_back(Args...);
template<typename... Args>
[[nodiscard]] ErrorOr<void> Emplace(const_iterator, Args...);
[[nodiscard]] ErrorOr<void> emplace(const_iterator, Args...);
void PopBack();
void Remove(const_iterator);
void Clear();
void pop_back();
void remove(const_iterator);
void clear();
iterator begin() { return iterator(m_data, false); }
const_iterator begin() const { return const_iterator(m_data, false); }
iterator end() { return iterator(m_last, true); }
const_iterator end() const { return const_iterator(m_last, true); }
const T& Back() const;
T& Back();
const T& Front() const;
T& Front();
const T& back() const;
T& back();
const T& front() const;
T& front();
size_type Size() const;
bool Empty() const;
size_type size() const;
bool empty() const;
private:
struct Node
@@ -166,34 +166,34 @@ namespace BAN
template<typename T>
LinkedList<T>::~LinkedList()
{
Clear();
clear();
}
template<typename T>
ErrorOr<void> LinkedList<T>::PushBack(const T& value)
ErrorOr<void> LinkedList<T>::push_back(const T& value)
{
return PushBack(Move(T(value)));
return push_back(Move(T(value)));
}
template<typename T>
ErrorOr<void> LinkedList<T>::PushBack(T&& value)
ErrorOr<void> LinkedList<T>::push_back(T&& value)
{
return Insert(end(), Move(value));
return insert(end(), Move(value));
}
template<typename T>
ErrorOr<void> LinkedList<T>::Insert(const_iterator iter, const T& value)
ErrorOr<void> LinkedList<T>::insert(const_iterator iter, const T& value)
{
return Insert(iter, Move(T(value)));
return insert(iter, Move(T(value)));
}
template<typename T>
ErrorOr<void> LinkedList<T>::Insert(const_iterator iter, T&& value)
ErrorOr<void> LinkedList<T>::insert(const_iterator iter, T&& value)
{
Node* next = iter.m_past_end ? nullptr : iter.m_current;
Node* prev = next ? next->prev : m_last;
Node* new_node = TRY(allocate_node());
new (&new_node->value) T(Move(value));
new (&new_node->value) T(move(value));
new_node->next = next;
new_node->prev = prev;
(prev ? prev->next : m_data) = new_node;
@@ -204,19 +204,19 @@ namespace BAN
template<typename T>
template<typename... Args>
ErrorOr<void> LinkedList<T>::EmplaceBack(Args... args)
ErrorOr<void> LinkedList<T>::emplace_back(Args... args)
{
return Emplace(end(), Forward<Args>(args)...);
return emplace(end(), forward<Args>(args)...);
}
template<typename T>
template<typename... Args>
ErrorOr<void> LinkedList<T>::Emplace(const_iterator iter, Args... args)
ErrorOr<void> LinkedList<T>::emplace(const_iterator iter, Args... args)
{
Node* next = iter.m_past_end ? nullptr : iter.m_current;
Node* prev = next ? next->prev : m_last;
Node* new_node = TRY(allocate_node());
new (&new_node->value) T(Forward<Args>(args)...);
new (&new_node->value) T(forward<Args>(args)...);
new_node->next = next;
new_node->prev = prev;
(prev ? prev->next : m_data) = new_node;
@@ -226,13 +226,13 @@ namespace BAN
}
template<typename T>
void LinkedList<T>::PopBack()
void LinkedList<T>::pop_back()
{
return Remove(m_last);
return remove(m_last);
}
template<typename T>
void LinkedList<T>::Remove(const_iterator iter)
void LinkedList<T>::remove(const_iterator iter)
{
ASSERT(m_size > 0);
Node* node = iter.m_current;
@@ -246,7 +246,7 @@ namespace BAN
}
template<typename T>
void LinkedList<T>::Clear()
void LinkedList<T>::clear()
{
Node* ptr = m_data;
while (ptr)
@@ -262,41 +262,41 @@ namespace BAN
}
template<typename T>
const T& LinkedList<T>::Back() const
const T& LinkedList<T>::back() const
{
ASSERT(m_size > 0);
return *const_iterator(m_last);
}
template<typename T>
T& LinkedList<T>::Back()
T& LinkedList<T>::back()
{
ASSERT(m_size > 0);
return *iterator(m_last);
}
template<typename T>
const T& LinkedList<T>::Front() const
const T& LinkedList<T>::front() const
{
ASSERT(m_size > 0);
return *const_iterator(m_data);
}
template<typename T>
T& LinkedList<T>::Front()
T& LinkedList<T>::front()
{
ASSERT(m_size > 0);
return *iterator(m_data);
}
template<typename T>
typename LinkedList<T>::size_type LinkedList<T>::Size() const
typename LinkedList<T>::size_type LinkedList<T>::size() const
{
return m_size;
}
template<typename T>
bool LinkedList<T>::Empty() const
bool LinkedList<T>::empty() const
{
return m_size == 0;
}
@@ -306,7 +306,7 @@ namespace BAN
{
Node* node = (Node*)BAN::allocator(sizeof(Node));
if (node == nullptr)
return Error::FromString("LinkedList: Could not allocate memory");
return Error::from_string("LinkedList: Could not allocate memory");
return node;
}

16
BAN/include/BAN/Memory.h
View File

@@ -70,22 +70,22 @@ namespace BAN
}
RefCounted(RefCounted<T>&& other)
{
*this = Move(other);
*this = move(other);
}
~RefCounted()
{
Reset();
reset();
}
template<typename... Args>
static RefCounted<T> Create(Args... args)
static RefCounted<T> create(Args... args)
{
return RefCounted<T>(new T(Forward<Args>(args)...), new int32_t(1));
return RefCounted<T>(new T(forward<Args>(args)...), new int32_t(1));
}
RefCounted<T>& operator=(const RefCounted<T>& other)
{
Reset();
reset();
if (other)
{
m_pointer = other.m_pointer;
@@ -97,13 +97,13 @@ namespace BAN
RefCounted<T>& operator=(RefCounted<T>&& other)
{
Reset();
reset();
m_pointer = other.m_pointer;
m_count = other.m_count;
other.m_pointer = nullptr;
other.m_count = nullptr;
if (!(*this))
Reset();
reset();
return *this;
}
@@ -113,7 +113,7 @@ namespace BAN
T* operator->() { return m_pointer; }
const T* operator->() const { return m_pointer; }
void Reset()
void reset()
{
ASSERT(!m_count == !m_pointer);
if (!m_count)

6
BAN/include/BAN/Move.h
View File

@@ -6,19 +6,19 @@ namespace BAN
{
template<typename T>
constexpr remove_reference_t<T>&& Move(T&& arg)
constexpr remove_reference_t<T>&& move(T&& arg)
{
return static_cast<remove_reference_t<T>&&>(arg);
}
template<typename T>
constexpr T&& Forward(remove_reference_t<T>& arg)
constexpr T&& forward(remove_reference_t<T>& arg)
{
return static_cast<T&&>(arg);
}
template<typename T>
constexpr T&& Forward(remove_reference_t<T>&& arg)
constexpr T&& forward(remove_reference_t<T>&& arg)
{
static_assert(!is_lvalue_reference_v<T>);
return static_cast<T&&>(arg);

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

@@ -24,24 +24,24 @@ namespace BAN
Queue<T>& operator=(Queue<T>&&);
Queue<T>& operator=(const Queue<T>&);
[[nodiscard]] ErrorOr<void> Push(T&&);
[[nodiscard]] ErrorOr<void> Push(const T&);
[[nodiscard]] ErrorOr<void> push(T&&);
[[nodiscard]] ErrorOr<void> push(const T&);
template<typename... Args>
[[nodiscard]] ErrorOr<void> Emplace(Args...);
[[nodiscard]] ErrorOr<void> emplace(Args...);
void Pop();
void Clear();
void pop();
void clear();
bool Empty() const;
size_type Size() const;
bool empty() const;
size_type size() const;
const T& Front() const;
T& Front();
const T& front() const;
T& front();
private:
[[nodiscard]] ErrorOr<void> EnsureCapacity(size_type size);
const T* AddressOf(size_type, void* = nullptr) const;
T* AddressOf(size_type, void* = nullptr);
[[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:
uint8_t* m_data = nullptr;
@@ -64,22 +64,22 @@ namespace BAN
template<typename T>
Queue<T>::Queue(const Queue<T>& other)
{
MUST(EnsureCapacity(other.Size()));
for (size_type i = 0; i < other.Size(); i++)
new (AddressOf(i)) T(*AddressOf(i, other.m_data));
MUST(ensure_capacity(other.size()));
for (size_type i = 0; i < other.size(); i++)
new (address_of(i)) T(*address_of(i, other.m_data));
m_size = other.m_size;
}
template<typename T>
Queue<T>::~Queue()
{
Clear();
clear();
}
template<typename T>
Queue<T>& Queue<T>::operator=(Queue<T>&& other)
{
Clear();
clear();
m_data = other.m_data;
m_capacity = other.m_capacity;
@@ -95,54 +95,54 @@ namespace BAN
template<typename T>
Queue<T>& Queue<T>::operator=(const Queue<T>& other)
{
Clear();
MUST(EnsureCapacity(other.Size()));
for (size_type i = 0; i < other.Size(); i++)
new (AddressOf(i)) T(*AddressOf(i, other.m_data));
clear();
MUST(ensure_capacity(other.size()));
for (size_type i = 0; i < other.size(); i++)
new (address_of(i)) T(*address_of(i, other.m_data));
m_size = other.m_size;
return *this;
}
template<typename T>
ErrorOr<void> Queue<T>::Push(T&& value)
ErrorOr<void> Queue<T>::push(T&& value)
{
TRY(EnsureCapacity(m_size + 1));
new (AddressOf(m_size)) T(Move(value));
TRY(ensure_capacity(m_size + 1));
new (address_of(m_size)) T(move(value));
m_size++;
return {};
}
template<typename T>
ErrorOr<void> Queue<T>::Push(const T& value)
ErrorOr<void> Queue<T>::push(const T& value)
{
return Push(Move(T(value)));
return push(move(T(value)));
}
template<typename T>
template<typename... Args>
ErrorOr<void> Queue<T>::Emplace(Args... args)
ErrorOr<void> Queue<T>::emplace(Args... args)
{
TRY(EnsureCapacity(m_size + 1));
new (AddressOf(m_size)) T(Forward<Args>(args)...);
TRY(ensure_capacity(m_size + 1));
new (address_of(m_size)) T(forward<Args>(args)...);
m_size++;
return {};
}
template<typename T>
void Queue<T>::Pop()
void Queue<T>::pop()
{
ASSERT(m_size > 0);
for (size_type i = 0; i < m_size - 1; i++)
*AddressOf(i) = Move(*AddressOf(i + 1));
AddressOf(m_size - 1)->~T();
*address_of(i) = move(*address_of(i + 1));
address_of(m_size - 1)->~T();
m_size--;
}
template<typename T>
void Queue<T>::Clear()
void Queue<T>::clear()
{
for (size_type i = 0; i < m_size; i++)
AddressOf(i)->~T();
address_of(i)->~T();
BAN::deallocator(m_data);
m_data = nullptr;
m_capacity = 0;
@@ -150,44 +150,44 @@ namespace BAN
}
template<typename T>
bool Queue<T>::Empty() const
bool Queue<T>::empty() const
{
return m_size == 0;
}
template<typename T>
typename Queue<T>::size_type Queue<T>::Size() const
typename Queue<T>::size_type Queue<T>::size() const
{
return m_size;
}
template<typename T>
const T& Queue<T>::Front() const
const T& Queue<T>::front() const
{
ASSERT(m_size > 0);
return *AddressOf(0);
return *address_of(0);
}
template<typename T>
T& Queue<T>::Front()
T& Queue<T>::front()
{
ASSERT(m_size > 0);
return *AddressOf(0);
return *address_of(0);
}
template<typename T>
ErrorOr<void> Queue<T>::EnsureCapacity(size_type size)
ErrorOr<void> Queue<T>::ensure_capacity(size_type size)
{
if (m_capacity > size)
return {};
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));
if (new_data == nullptr)
return Error::FromString("Queue: Could not allocate memory");
return Error::from_string("Queue: Could not allocate memory");
for (size_type i = 0; i < m_size; i++)
{
new (AddressOf(i, new_data)) T(Move(*AddressOf(i)));
AddressOf(i)->~T();
new (address_of(i, new_data)) T(move(*address_of(i)));
address_of(i)->~T();
}
BAN::deallocator(m_data);
m_data = new_data;
@@ -196,7 +196,7 @@ namespace BAN
}
template<typename T>
const T* Queue<T>::AddressOf(size_type index, void* base) const
const T* Queue<T>::address_of(size_type index, void* base) const
{
if (base == nullptr)
base = m_data;
@@ -204,7 +204,7 @@ namespace BAN
}
template<typename T>
T* Queue<T>::AddressOf(size_type index, void* base)
T* Queue<T>::address_of(size_type index, void* base)
{
if (base == nullptr)
base = m_data;

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

@@ -19,23 +19,23 @@ namespace BAN
~String();
template<typename... Args>
static String Formatted(const char* format, const Args&... args);
static String formatted(const char* format, const Args&... args);
String& operator=(const String&);
String& operator=(String&&);
String& operator=(StringView);
[[nodiscard]] ErrorOr<void> PushBack(char);
[[nodiscard]] ErrorOr<void> Insert(char, size_type);
[[nodiscard]] ErrorOr<void> Insert(StringView, size_type);
[[nodiscard]] ErrorOr<void> Append(StringView);
[[nodiscard]] ErrorOr<void> Append(const String&);
[[nodiscard]] ErrorOr<void> push_back(char);
[[nodiscard]] ErrorOr<void> insert(char, size_type);
[[nodiscard]] ErrorOr<void> insert(StringView, size_type);
[[nodiscard]] ErrorOr<void> append(StringView);
[[nodiscard]] ErrorOr<void> append(const String&);
void PopBack();
void Remove(size_type);
void Erase(size_type, size_type);
void pop_back();
void remove(size_type);
void erase(size_type, size_type);
void Clear();
void clear();
char operator[](size_type) const;
char& operator[](size_type);
@@ -44,34 +44,34 @@ namespace BAN
bool operator==(StringView) const;
bool operator==(const char*) const;
[[nodiscard]] ErrorOr<void> Resize(size_type, char = '\0');
[[nodiscard]] ErrorOr<void> Reserve(size_type);
[[nodiscard]] ErrorOr<void> resize(size_type, char = '\0');
[[nodiscard]] ErrorOr<void> reserve(size_type);
StringView SV() const;
StringView sv() const;
bool Empty() const;
size_type Size() const;
size_type Capasity() const;
bool empty() const;
size_type size() const;
size_type capacity() const;
const char* Data() const;
const char* data() const;
private:
[[nodiscard]] ErrorOr<void> EnsureCapasity(size_type);
[[nodiscard]] ErrorOr<void> ensure_capacity(size_type);
[[nodiscard]] ErrorOr<void> copy_impl(StringView);
void move_impl(String&&);
private:
char* m_data = nullptr;
size_type m_capasity = 0;
size_type m_capacity = 0;
size_type m_size = 0;
};
template<typename... Args>
String String::Formatted(const char* format, const Args&... args)
String String::formatted(const char* format, const Args&... args)
{
String result;
BAN::Formatter::print([&](char c){ result.PushBack(c); }, format, args...);
BAN::Formatter::print([&](char c){ result.push_back(c); }, format, args...);
return result;
}
@@ -83,7 +83,7 @@ namespace BAN::Formatter
template<typename F>
void print_argument_impl(F putc, const String& string, const ValueFormat&)
{
for (String::size_type i = 0; i < string.Size(); i++)
for (String::size_type i = 0; i < string.size(); i++)
putc(string[i]);
}

20
BAN/include/BAN/StringView.h
View File

@@ -22,20 +22,20 @@ namespace BAN
bool operator==(StringView) const;
bool operator==(const char*) const;
StringView Substring(size_type, size_type = -1) const;
StringView substring(size_type, size_type = -1) const;
[[nodiscard]] ErrorOr<Vector<StringView>> Split(char, bool = false);
[[nodiscard]] ErrorOr<Vector<StringView>> Split(bool(*comp)(char), bool = false);
[[nodiscard]] ErrorOr<Vector<StringView>> split(char, bool = false);
[[nodiscard]] ErrorOr<Vector<StringView>> split(bool(*comp)(char), bool = false);
char Back() const;
char Front() const;
char back() const;
char front() const;
size_type Count(char) const;
size_type count(char) const;
bool Empty() const;
size_type Size() const;
bool empty() const;
size_type size() const;
const char* Data() const;
const char* data() const;
private:
const char* m_data = nullptr;
@@ -52,7 +52,7 @@ namespace BAN::Formatter
template<typename F>
void print_argument_impl(F putc, const StringView& sv, const ValueFormat&)
{
for (StringView::size_type i = 0; i < sv.Size(); i++)
for (StringView::size_type i = 0; i < sv.size(); i++)
putc(sv[i]);
}

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

@@ -70,45 +70,45 @@ namespace BAN
Vector<T>& operator=(Vector<T>&&);
Vector<T>& operator=(const Vector<T>&);
[[nodiscard]] ErrorOr<void> PushBack(T&&);
[[nodiscard]] ErrorOr<void> PushBack(const T&);
[[nodiscard]] ErrorOr<void> push_back(T&&);
[[nodiscard]] ErrorOr<void> push_back(const T&);
template<typename... Args>
[[nodiscard]] ErrorOr<void> EmplaceBack(Args...);
[[nodiscard]] ErrorOr<void> emplace_back(Args...);
template<typename... Args>
[[nodiscard]] ErrorOr<void> Emplace(size_type, Args...);
[[nodiscard]] ErrorOr<void> Insert(size_type, T&&);
[[nodiscard]] ErrorOr<void> Insert(size_type, const T&);
[[nodiscard]] ErrorOr<void> emplace(size_type, Args...);
[[nodiscard]] ErrorOr<void> insert(size_type, T&&);
[[nodiscard]] ErrorOr<void> insert(size_type, const T&);
iterator begin();
iterator end();
const_iterator begin() const;
const_iterator end() const;
void PopBack();
void Remove(size_type);
void Clear();
void pop_back();
void remove(size_type);
void clear();
bool Has(const T&) const;
bool has(const T&) const;
const T& operator[](size_type) const;
T& operator[](size_type);
const T& Back() const;
T& Back();
const T& Front() const;
T& Front();
const T& back() const;
T& back();
const T& front() const;
T& front();
[[nodiscard]] ErrorOr<void> Resize(size_type);
[[nodiscard]] ErrorOr<void> Reserve(size_type);
[[nodiscard]] ErrorOr<void> resize(size_type);
[[nodiscard]] ErrorOr<void> reserve(size_type);
bool Empty() const;
size_type Size() const;
size_type Capacity() const;
bool empty() const;
size_type size() const;
size_type capacity() const;
private:
[[nodiscard]] ErrorOr<void> EnsureCapasity(size_type);
const T* AddressOf(size_type, void* = nullptr) const;
T* AddressOf(size_type, void* = nullptr);
[[nodiscard]] ErrorOr<void> ensure_capacity(size_type);
const T* address_of(size_type, void* = nullptr) const;
T* address_of(size_type, void* = nullptr);
private:
uint8_t* m_data = nullptr;
@@ -131,22 +131,22 @@ namespace BAN
template<typename T>
Vector<T>::Vector(const Vector<T>& other)
{
MUST(EnsureCapasity(other.m_size));
MUST(ensure_capacity(other.m_size));
for (size_type i = 0; i < other.m_size; i++)
new (AddressOf(i)) T(other[i]);
new (address_of(i)) T(other[i]);
m_size = other.m_size;
}
template<typename T>
Vector<T>::~Vector()
{
Clear();
clear();
}
template<typename T>
Vector<T>& Vector<T>::operator=(Vector<T>&& other)
{
Clear();
clear();
m_data = other.m_data;
m_capacity = other.m_capacity;
@@ -162,133 +162,133 @@ namespace BAN
template<typename T>
Vector<T>& Vector<T>::operator=(const Vector<T>& other)
{
Clear();
MUST(EnsureCapasity(other.Size()));
for (size_type i = 0; i < other.Size(); i++)
new (AddressOf(i)) T(other[i]);
clear();
MUST(ensure_capacity(other.size()));
for (size_type i = 0; i < other.size(); i++)
new (address_of(i)) T(other[i]);
m_size = other.m_size;
return *this;
}
template<typename T>
ErrorOr<void> Vector<T>::PushBack(T&& value)
ErrorOr<void> Vector<T>::push_back(T&& value)
{
TRY(EnsureCapasity(m_size + 1));
new (AddressOf(m_size)) T(Move(value));
TRY(ensure_capacity(m_size + 1));
new (address_of(m_size)) T(move(value));
m_size++;
return {};
}
template<typename T>
ErrorOr<void> Vector<T>::PushBack(const T& value)
ErrorOr<void> Vector<T>::push_back(const T& value)
{
return PushBack(Move(T(value)));
return push_back(move(T(value)));
}
template<typename T>
template<typename... Args>
ErrorOr<void> Vector<T>::EmplaceBack(Args... args)
ErrorOr<void> Vector<T>::emplace_back(Args... args)
{
TRY(EnsureCapasity(m_size + 1));
new (AddressOf(m_size)) T(Forward<Args>(args)...);
TRY(ensure_capacity(m_size + 1));
new (address_of(m_size)) T(forward<Args>(args)...);
m_size++;
return {};
}
template<typename T>
template<typename... Args>
ErrorOr<void> Vector<T>::Emplace(size_type index, Args... args)
ErrorOr<void> Vector<T>::emplace(size_type index, Args... args)
{
ASSERT(index <= m_size);
TRY(EnsureCapasity(m_size + 1));
TRY(ensure_capacity(m_size + 1));
if (index < m_size)
{
new (AddressOf(m_size)) T(Move(*AddressOf(m_size - 1)));
new (address_of(m_size)) T(move(*address_of(m_size - 1)));
for (size_type i = m_size - 1; i > index; i--)
*AddressOf(i) = Move(*AddressOf(i - 1));
*AddressOf(index) = Move(T(Forward<Args>(args)...));
*address_of(i) = move(*address_of(i - 1));
*address_of(index) = move(T(forward<Args>(args)...));
}
else
{
new (AddressOf(m_size)) T(Forward<Args>(args)...);
new (address_of(m_size)) T(forward<Args>(args)...);
}
m_size++;
return {};
}
template<typename T>
ErrorOr<void> Vector<T>::Insert(size_type index, T&& value)
ErrorOr<void> Vector<T>::insert(size_type index, T&& value)
{
ASSERT(index <= m_size);
TRY(EnsureCapasity(m_size + 1));
TRY(ensure_capacity(m_size + 1));
if (index < m_size)
{
new (AddressOf(m_size)) T(Move(*AddressOf(m_size - 1)));
new (address_of(m_size)) T(move(*address_of(m_size - 1)));
for (size_type i = m_size - 1; i > index; i--)
*AddressOf(i) = Move(*AddressOf(i - 1));
*AddressOf(index) = Move(value);
*address_of(i) = move(*address_of(i - 1));
*address_of(index) = move(value);
}
else
{
new (AddressOf(m_size)) T(Move(value));
new (address_of(m_size)) T(move(value));
}
m_size++;
return {};
}
template<typename T>
ErrorOr<void> Vector<T>::Insert(size_type index, const T& value)
ErrorOr<void> Vector<T>::insert(size_type index, const T& value)
{
return Insert(Move(T(value)), index);
return insert(move(T(value)), index);
}
template<typename T>
typename Vector<T>::iterator Vector<T>::begin()
{
return VectorIterator<T>(AddressOf(0));
return VectorIterator<T>(address_of(0));
}
template<typename T>
typename Vector<T>::iterator Vector<T>::end()
{
return VectorIterator<T>(AddressOf(m_size));
return VectorIterator<T>(address_of(m_size));
}
template<typename T>
typename Vector<T>::const_iterator Vector<T>::begin() const
{
return VectorConstIterator<T>(AddressOf(0));
return VectorConstIterator<T>(address_of(0));
}
template<typename T>
typename Vector<T>::const_iterator Vector<T>::end() const
{
return VectorConstIterator<T>(AddressOf(m_size));
return VectorConstIterator<T>(address_of(m_size));
}
template<typename T>
void Vector<T>::PopBack()
void Vector<T>::pop_back()
{
ASSERT(m_size > 0);
AddressOf(m_size - 1)->~T();
address_of(m_size - 1)->~T();
m_size--;
}
template<typename T>
void Vector<T>::Remove(size_type index)
void Vector<T>::remove(size_type index)
{
ASSERT(index < m_size);
for (size_type i = index; i < m_size - 1; i++)
*AddressOf(i) = Move(*AddressOf(i + 1));
AddressOf(m_size - 1)->~T();
*address_of(i) = move(*address_of(i + 1));
address_of(m_size - 1)->~T();
m_size--;
}
template<typename T>
void Vector<T>::Clear()
void Vector<T>::clear()
{
for (size_type i = 0; i < m_size; i++)
AddressOf(i)->~T();
address_of(i)->~T();
BAN::deallocator(m_data);
m_data = nullptr;
m_capacity = 0;
@@ -296,10 +296,10 @@ namespace BAN
}
template<typename T>
bool Vector<T>::Has(const T& other) const
bool Vector<T>::has(const T& other) const
{
for (size_type i = 0; i < m_size; i++)
if (*AddressOf(i) == other)
if (*address_of(i) == other)
return true;
return false;
}
@@ -308,95 +308,95 @@ namespace BAN
const T& Vector<T>::operator[](size_type index) const
{
ASSERT(index < m_size);
return *AddressOf(index);
return *address_of(index);
}
template<typename T>
T& Vector<T>::operator[](size_type index)
{
ASSERT(index < m_size);
return *AddressOf(index);
return *address_of(index);
}
template<typename T>
const T& Vector<T>::Back() const
const T& Vector<T>::back() const
{
ASSERT(m_size > 0);
return *AddressOf(m_size - 1);
return *address_of(m_size - 1);
}
template<typename T>
T& Vector<T>::Back()
T& Vector<T>::back()
{
ASSERT(m_size > 0);
return *AddressOf(m_size - 1);
return *address_of(m_size - 1);
}
template<typename T>
const T& Vector<T>::Front() const
const T& Vector<T>::front() const
{
ASSERT(m_size > 0);
return *AddressOf(0);
return *address_of(0);
}
template<typename T>
T& Vector<T>::Front()
T& Vector<T>::front()
{
ASSERT(m_size > 0);
return *AddressOf(0);
return *address_of(0);
}
template<typename T>
ErrorOr<void> Vector<T>::Resize(size_type size)
ErrorOr<void> Vector<T>::resize(size_type size)
{
TRY(EnsureCapasity(size));
TRY(ensure_capacity(size));
if (size < m_size)
for (size_type i = size; i < m_size; i++)
AddressOf(i)->~T();
address_of(i)->~T();
if (size > m_size)
for (size_type i = m_size; i < size; i++)
new (AddressOf(i)) T();
new (address_of(i)) T();
m_size = size;
return {};
}
template<typename T>
ErrorOr<void> Vector<T>::Reserve(size_type size)
ErrorOr<void> Vector<T>::reserve(size_type size)
{
TRY(EnsureCapasity(size));
TRY(ensure_capacity(size));
return {};
}
template<typename T>
bool Vector<T>::Empty() const
bool Vector<T>::empty() const
{
return m_size == 0;
}
template<typename T>
typename Vector<T>::size_type Vector<T>::Size() const
typename Vector<T>::size_type Vector<T>::size() const
{
return m_size;
}
template<typename T>
typename Vector<T>::size_type Vector<T>::Capacity() const
typename Vector<T>::size_type Vector<T>::capacity() const
{
return m_capacity;
}
template<typename T>
ErrorOr<void> Vector<T>::EnsureCapasity(size_type size)
ErrorOr<void> Vector<T>::ensure_capacity(size_type size)
{
if (m_capacity >= size)
return {};
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));
if (new_data == nullptr)
return Error::FromString("Vector: Could not allocate memory");
return Error::from_string("Vector: Could not allocate memory");
for (size_type i = 0; i < m_size; i++)
{
new (AddressOf(i, new_data)) T(Move(*AddressOf(i)));
AddressOf(i)->~T();
new (address_of(i, new_data)) T(move(*address_of(i)));
address_of(i)->~T();
}
BAN::deallocator(m_data);
m_data = new_data;
@@ -405,7 +405,7 @@ namespace BAN
}
template<typename T>
const T* Vector<T>::AddressOf(size_type index, void* base) const
const T* Vector<T>::address_of(size_type index, void* base) const
{
if (base == nullptr)
base = m_data;
@@ -413,7 +413,7 @@ namespace BAN
}
template<typename T>
T* Vector<T>::AddressOf(size_type index, void* base)
T* Vector<T>::address_of(size_type index, void* base)
{
if (base == nullptr)
base = m_data;