BAN: Rewrite Queue with move semantics

BAN/include/BAN/Queue.h

@@ -2,10 +2,7 @@
 
 #include <BAN/Errors.h>
 #include <BAN/Math.h>
-#include <BAN/Memory.h>
+#include <BAN/Move.h>
-
-#include <stdint.h>
-#include <string.h>
 
 namespace BAN
 {
@@ -14,15 +11,23 @@ namespace BAN
 	class Queue
 	{
 	public:
-		using size_type = uint32_t;
+		using size_type = size_t;
 		using value_type = T;
 
 	public:
 		Queue() = default;
+		Queue(Queue<T>&&);
+		Queue(const Queue<T>&);
 		~Queue();
 
-		[[nodiscard]] ErrorOr<void> Push(const T& value);
+		Queue<T>& operator=(Queue<T>&&);
+		Queue<T>& operator=(const Queue<T>&);
+
+		[[nodiscard]] ErrorOr<void> Push(T&&);
+		[[nodiscard]] ErrorOr<void> Push(const T&);
+
 		void Pop();
+		void Clear();
 
 		bool Empty() const;
 		size_type Size() const;
@@ -32,35 +37,102 @@ namespace BAN
 
 	private:
 		[[nodiscard]] ErrorOr<void> EnsureCapacity(size_type size);
+		T* Address(size_type, uint8_t* = nullptr) const;
 
 	private:
-		T*			m_data		= nullptr;
+		uint8_t*	m_data		= nullptr;
 		size_type	m_capacity	= 0;
 		size_type	m_size		= 0;
 	};
 
+	template<typename T>
+	Queue<T>::Queue(Queue<T>&& other)
+	{
+		m_data = other.m_data;
+		m_capacity = other.m_capacity;
+		m_size = other.m_size;
+
+		other.m_data = nullptr;
+		other.m_capacity = 0;
+		other.m_size = 0;
+	}
+
+	template<typename T>
+	Queue<T>::Queue(const Queue<T>& other)
+	{
+		MUST(EnsureCapacity(other.Size()));
+		for (size_type i = 0; i < other.Size(); i++)
+			new (Address(i)) T(*Address(i, other.m_data));
+		m_size = other.m_size;
+	}
+
 	template<typename T>
 	Queue<T>::~Queue()
 	{
-		for (size_type i = 0; i < m_size; i++)
+		Clear();
-			m_data[i].~T();
+	}
-		delete[] m_data;
+
+	template<typename T>
+	Queue<T>& Queue<T>::operator=(Queue<T>&& other)
+	{
+		Clear();
+
+		m_data = other.m_data;
+		m_capacity = other.m_capacity;
+		m_size = other.m_size;
+
+		other.m_data = nullptr;
+		other.m_capacity = 0;
+		other.m_size = 0;
+
+		return *this;
+	}
+
+	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 (Address(i)) T(*Address(i, other.m_data));
+		m_size = other.m_size;
+		return *this;
+	}
+
+	template<typename T>
+	ErrorOr<void> Queue<T>::Push(T&& value)
+	{
+		TRY(EnsureCapacity(m_size + 1));
+		new (Address(m_size)) T(Move(value));
+		m_size++;
+		return {};
 	}
 
 	template<typename T>
 	ErrorOr<void> Queue<T>::Push(const T& value)
 	{
-		TRY(EnsureCapacity(m_size + 1));
+		return Push(Move(T(value)));
-		m_data[m_size++] = value;
-		return {};
 	}
 
 	template<typename T>
 	void Queue<T>::Pop()
 	{
 		ASSERT(m_size > 0);
-		m_data->~T();
+		for (size_type i = 0; i < m_size - 1; i++)
-		memmove(m_data, m_data + 1, sizeof(T) * (--m_size));
+			*Address(i) = Move(*Address(i + 1));
+		Address(m_size - 1)->~T();
+		m_size--;
+	}
+
+	template<typename T>
+	void Queue<T>::Clear()
+	{
+		for (size_type i = 0; i < m_size; i++)
+			Address(i)->~T();
+		BAN::deallocator(m_data);
+		m_data = nullptr;
+		m_capacity = 0;
+		m_size = 0;
 	}
 
 	template<typename T>
@@ -79,14 +151,14 @@ namespace BAN
 	const T& Queue<T>::Front() const
 	{
 		ASSERT(m_size > 0);
-		return *m_data;
+		return *Address(0);
 	}
 
 	template<typename T>
 	T& Queue<T>::Front()
 	{
 		ASSERT(m_size > 0);
-		return *m_data;
+		return *Address(0);
 	}
 
 	template<typename T>
@@ -95,15 +167,26 @@ namespace BAN
 		if (m_capacity > size)
 			return {};
 		size_type new_cap = BAN::Math::max<size_type>(size, m_capacity * 3 / 2);
-		T* new_data = new T[new_cap];
+		uint8_t* new_data = (uint8_t*)BAN::allocator(new_cap * sizeof(T));
 		if (new_data == nullptr)
 			return Error::FromString("Queue: Could not allocate memory");
-		if (m_data)
+		for (size_type i = 0; i < m_size; i++)
-			memcpy(new_data, m_data, m_size * sizeof(T));
+		{
-		delete[] m_data;
+			new (Address(i, new_data)) T(Move(*Address(i)));
+			Address(i)->~T();
+		}
+		BAN::deallocator(m_data);
 		m_data = new_data;
 		m_capacity = new_cap;
 		return {};
 	}
 
+	template<typename T>
+	T* Queue<T>::Address(size_type index, uint8_t* base) const
+	{
+		if (base == nullptr)
+			base = m_data;
+		return (T*)(base + index * sizeof(T));
+	}
+
 }