Cleanup

src/core/containers/array.h

@@ -122,11 +122,11 @@ namespace array
 
 		if (capacity > 0)
 		{
-			T* tmp = a._array;
+			T* tmp = a._data;
 			a._capacity = capacity;
-			a._array = (T*)a._allocator->allocate(capacity * sizeof(T), CE_ALIGNOF(T));
+			a._data = (T*)a._allocator->allocate(capacity * sizeof(T), CE_ALIGNOF(T));
 
-			memcpy(a._array, tmp, a._size * sizeof(T));
+			memcpy(a._data, tmp, a._size * sizeof(T));
 
 			if (tmp)
 				a._allocator->deallocate(tmp);
@@ -156,7 +156,7 @@ namespace array
 		if (a._capacity == a._size)
 			grow(a, 0);
 
-		a._array[a._size] = item;
+		a._data[a._size] = item;
 
 		return a._size++;
 	}
@@ -175,7 +175,7 @@ namespace array
 		if (a._capacity <= a._size + count)
 			grow(a, a._size + count);
 
-		memcpy(&a._array[a._size], items, sizeof(T) * count);
+		memcpy(&a._data[a._size], items, sizeof(T) * count);
 		a._size += count;
 
 		return a._size;
@@ -190,57 +190,53 @@ namespace array
 	template <typename T>
 	inline const T* begin(const Array<T>& a)
 	{
-		return a._array;
+		return a._data;
 	}
 
 	template <typename T>
 	inline T* begin(Array<T>& a)
 	{
-		return a._array;
+		return a._data;
 	}
 
 	template <typename T>
 	inline const T* end(const Array<T>& a)
 	{
-		return a._array + a._size;
+		return a._data + a._size;
 	}
 
 	template <typename T>
 	inline T* end(Array<T>& a)
 	{
-		return a._array + a._size;
+		return a._data + a._size;
 	}
 
 	template <typename T>
 	inline T& front(Array<T>& a)
 	{
 		CE_ASSERT(a._size > 0, "The array is empty");
-
-		return a._array[0];
+		return a._data[0];
 	}
 
 	template <typename T>
 	inline const T& front(const Array<T>& a)
 	{
 		CE_ASSERT(a._size > 0, "The array is empty");
-
-		return a._array[0];
+		return a._data[0];
 	}
 
 	template <typename T>
 	inline T& back(Array<T>& a)
 	{
 		CE_ASSERT(a._size > 0, "The array is empty");
-
-		return a._array[a._size - 1];
+		return a._data[a._size - 1];
 	}
 
 	template <typename T>
 	inline const T& back(const Array<T>& a)
 	{
 		CE_ASSERT(a._size > 0, "The array is empty");
-
-		return a._array[a._size - 1];
+		return a._data[a._size - 1];
 	}
 } // namespace array
 
@@ -249,7 +245,7 @@ inline Array<T>::Array(Allocator& a)
 	: _allocator(&a)
 	, _capacity(0)
 	, _size(0)
-	, _array(NULL)
+	, _data(NULL)
 {
 }
 
@@ -258,7 +254,7 @@ inline Array<T>::Array(Allocator& a, uint32_t capacity)
 	: _allocator(&a)
 	, _capacity(0)
 	, _size(0)
-	, _array(NULL)
+	, _data(NULL)
 {
 	array::resize(*this, capacity);
 }
@@ -268,7 +264,7 @@ inline Array<T>::Array(const Array<T>& other)
 	: _allocator(other._allocator)
 	, _capacity(0)
 	, _size(0)
-	, _array(NULL)
+	, _data(NULL)
 {
 	*this = other;
 }
@@ -276,8 +272,8 @@ inline Array<T>::Array(const Array<T>& other)
 template <typename T>
 inline Array<T>::~Array()
 {
-	if (_array)
-		_allocator->deallocate(_array);
+	if (_data)
+		_allocator->deallocate(_data);
 }
 
 template <typename T>
@@ -285,7 +281,7 @@ inline T& Array<T>::operator[](uint32_t index)
 {
 	CE_ASSERT(index < _size, "Index out of bounds");
 
-	return _array[index];
+	return _data[index];
 }
 
 template <typename T>
@@ -293,7 +289,7 @@ inline const T& Array<T>::operator[](uint32_t index) const
 {
 	CE_ASSERT(index < _size, "Index out of bounds");
 
-	return _array[index];
+	return _data[index];
 }
 
 template <typename T>
@@ -301,7 +297,7 @@ inline Array<T>& Array<T>::operator=(const Array<T>& other)
 {
 	const uint32_t size = other._size;
 	array::resize(*this, size);
-	memcpy(_array, other._array, sizeof(T) * size);
+	memcpy(_data, other._data, sizeof(T) * size);
 	return *this;
 }
 

src/core/containers/container_types.h

@@ -22,10 +22,10 @@ namespace crown
 template <typename T>
 struct Array
 {
-	Array(Allocator& allocator);
+	Array(Allocator& a);
 
 	/// Allocates capacity * sizeof(T) bytes.
-	Array(Allocator& allocator, uint32_t capacity);
+	Array(Allocator& a, uint32_t capacity);
 	Array(const Array<T>& other);
 	~Array();
 
@@ -38,7 +38,7 @@ struct Array
 	Allocator* _allocator;
 	uint32_t _capacity;
 	uint32_t _size;
-	T* _array;
+	T* _data;
 };
 
 /// Dynamic array of objects.
@@ -50,8 +50,8 @@ struct Array
 template <typename T>
 struct Vector
 {
-	Vector(Allocator& allocator);
-	Vector(Allocator& allocator, uint32_t capacity);
+	Vector(Allocator& a);
+	Vector(Allocator& a, uint32_t capacity);
 	Vector(const Vector<T>& other);
 	~Vector();
 
@@ -64,7 +64,7 @@ struct Vector
 	Allocator* _allocator;
 	uint32_t _capacity;
 	uint32_t _size;
-	T* _array;
+	T* _data;
 };
 
 /// Circular buffer double-ended queue of POD items.
@@ -75,7 +75,7 @@ struct Vector
 template <typename T>
 struct Queue
 {
-	Queue(Allocator& allocator);
+	Queue(Allocator& a);
 
 	/// Random access by index
 	T& operator[](uint32_t index);

src/core/containers/queue.h

@@ -106,7 +106,6 @@ namespace queue
 		if (q._read + q._size > old_size)
 		{
 			memmove(array::begin(q._queue) + capacity - (old_size - q._read), array::begin(q._queue) + q._read, (old_size - q._read) * sizeof(T));
-
 			q._read += (capacity - old_size);
 		}
 	}
@@ -117,9 +116,7 @@ namespace queue
 		uint32_t new_capacity = array::size(q._queue) * 2 + 1;
 
 		if (new_capacity < min_capacity)
-		{
 			new_capacity = min_capacity;
-		}
 
 		increase_capacity(q, new_capacity);
 	}
@@ -128,9 +125,7 @@ namespace queue
 	inline void push_back(Queue<T>& q, const T& item)
 	{
 		if (space(q) == 0)
-		{
 			grow(q, 0);
-		}
 
 		q[q._size] = item;
 
@@ -149,9 +144,7 @@ namespace queue
 	inline void push_front(Queue<T>& q, const T& item)
 	{
 		if (space(q) == 0)
-		{
 			grow(q, 0);
-		}
 
 		q._read = (q._read - 1 + array::size(q._queue)) % array::size(q._queue);
 
@@ -173,18 +166,14 @@ namespace queue
 	inline void push(Queue<T>& q, const T *items, uint32_t n)
 	{
 		if (q.space() < n)
-		{
 			q.grow(q.size() + n);
-		}
 
 		const uint32_t size = array::size(q._queue);
 		const uint32_t insert = (q._read + q._size) % size;
 
 		uint32_t to_insert = n;
 		if (insert + to_insert > size)
-		{
 			to_insert = size - insert;
-		}
 
 		memcpy(array::begin(q._queue) + insert, items, to_insert * sizeof(T));
 
@@ -227,16 +216,14 @@ namespace queue
 	template <typename T>
 	inline T* end(Queue<T>& q)
 	{
-		uint32_t end = q._read + q._size;
-
+		const uint32_t end = q._read + q._size;
 		return end >= array::size(q._queue) ? array::end(q._queue) : array::begin(q._queue) + end;
 	}
 
 	template <typename T>
 	inline const T* end(const Queue<T>& q)
 	{
-		uint32_t end = q._read + q._size;
-
+		const uint32_t end = q._read + q._size;
 		return end >= array::size(q._queue) ? array::end(q._queue) : array::begin(q._queue) + end;
 	}
 
@@ -244,7 +231,6 @@ namespace queue
 	inline T& front(Queue<T>& q)
 	{
 		CE_ASSERT(q._size > 0, "The queue is empty");
-
 		return q._queue[q._read];
 	}
 
@@ -252,7 +238,6 @@ namespace queue
 	inline const T& front(const Queue<T>& q)
 	{
 		CE_ASSERT(q._size > 0, "The queue is empty");
-
 		return q._queue[q._read];
 	}
 
@@ -260,7 +245,6 @@ namespace queue
 	inline T& back(Queue<T>& q)
 	{
 		CE_ASSERT(q._size > 0, "The queue is empty");
-
 		return q[q._size - 1];
 	}
 
@@ -268,17 +252,16 @@ namespace queue
 	inline const T& back(const Queue<T>& q)
 	{
 		CE_ASSERT(q._size > 0, "The queue is empty");
-
 		return q[q._size - 1];
 	}
 
 } // namespace queue
 
 template <typename T>
-inline Queue<T>::Queue(Allocator& allocator)
+inline Queue<T>::Queue(Allocator& a)
 	: _read(0)
 	, _size(0)
-	, _queue(allocator)
+	, _queue(a)
 {
 }
 

src/core/containers/vector.h

@@ -120,13 +120,13 @@ namespace vector
 
 		if (capacity > 0)
 		{
-			T* tmp = v._array;
+			T* tmp = v._data;
 			v._capacity = capacity;
-			v._array = (T*)v._allocator->allocate(capacity * sizeof(T), CE_ALIGNOF(T));
+			v._data = (T*)v._allocator->allocate(capacity * sizeof(T), CE_ALIGNOF(T));
 
 			for (uint32_t i = 0; i < v._size; i++)
 			{
-				new (v._array + i) T(tmp[i]);
+				new (v._data + i) T(tmp[i]);
 			}
 
 			if (tmp)
@@ -163,7 +163,7 @@ namespace vector
 		if (v._capacity == v._size)
 			grow(v, 0);
 
-		new (v._array + v._size) T(item);
+		new (v._data + v._size) T(item);
 
 		return v._size++;
 	}
@@ -173,7 +173,7 @@ namespace vector
 	{
 		CE_ASSERT(v._size > 0, "The vector is empty");
 
-		v._array[v._size - 1].~T();
+		v._data[v._size - 1].~T();
 		--v._size;
 	}
 
@@ -183,11 +183,9 @@ namespace vector
 		if (v._capacity <= v._size + count)
 			grow(v, v._size + count);
 
-		T* arr = &v._array[v._size];
+		T* arr = &v._data[v._size];
 		for (uint32_t i = 0; i < count; i++)
-		{
 			arr[i] = items[i];
-		}
 
 		v._size += count;
 		return v._size;
@@ -197,9 +195,7 @@ namespace vector
 	inline void clear(Vector<T>& v)
 	{
 		for (uint32_t i = 0; i < v._size; i++)
-		{
-			v._array[i].~T();
-		}
+			v._data[i].~T();
 
 		v._size = 0;
 	}
@@ -207,57 +203,53 @@ namespace vector
 	template <typename T>
 	inline T* begin(Vector<T>& v)
 	{
-		return v._array;
+		return v._data;
 	}
 
 	template <typename T>
 	inline const T* begin(const Vector<T>& v)
 	{
-		return v._array;
+		return v._data;
 	}
 
 	template <typename T>
 	inline T* end(Vector<T>& v)
 	{
-		return v._array + v._size;
+		return v._data + v._size;
 	}
 
 	template <typename T>
 	inline const T* end(const Vector<T>& v)
 	{
-		return v._array + v._size;
+		return v._data + v._size;
 	}
 
 	template <typename T>
 	inline T& front(Vector<T>& v)
 	{
 		CE_ASSERT(v._size > 0, "The vector is empty");
-
-		return v._array[0];
+		return v._data[0];
 	}
 
 	template <typename T>
 	inline const T& front(const Vector<T>& v)
 	{
 		CE_ASSERT(v._size > 0, "The vector is empty");
-
-		return v._array[0];
+		return v._data[0];
 	}
 
 	template <typename T>
 	inline T& back(Vector<T>& v)
 	{
 		CE_ASSERT(v._size > 0, "The vector is empty");
-
-		return v._array[v._size - 1];
+		return v._data[v._size - 1];
 	}
 
 	template <typename T>
 	inline const T& back(const Vector<T>& v)
 	{
 		CE_ASSERT(v._size > 0, "The vector is empty");
-
-		return v._array[v._size - 1];
+		return v._data[v._size - 1];
 	}
 } // namespace vector
 
@@ -266,7 +258,7 @@ inline Vector<T>::Vector(Allocator& a)
 	: _allocator(&a)
 	, _capacity(0)
 	, _size(0)
-	, _array(NULL)
+	, _data(NULL)
 {
 }
 
@@ -275,7 +267,7 @@ inline Vector<T>::Vector(Allocator& a, uint32_t capacity)
 	: _allocator(&a)
 	, _capacity(0)
 	, _size(0)
-	, _array(NULL)
+	, _data(NULL)
 {
 	vector::resize(*this, capacity);
 }
@@ -285,7 +277,7 @@ inline Vector<T>::Vector(const Vector<T>& other)
 	: _allocator(other._allocator)
 	, _capacity(0)
 	, _size(0)
-	, _array(NULL)
+	, _data(NULL)
 {
 	*this = other;
 }
@@ -294,12 +286,10 @@ template <typename T>
 inline Vector<T>::~Vector()
 {
 	for (uint32_t i = 0; i < _size; i++)
-	{
-		_array[i].~T();
-	}
+		_data[i].~T();
 
-	if (_array)
-		_allocator->deallocate(_array);
+	if (_data)
+		_allocator->deallocate(_data);
 }
 
 template <typename T>
@@ -307,7 +297,7 @@ inline T& Vector<T>::operator[](uint32_t index)
 {
 	CE_ASSERT(index < _size, "Index out of bounds");
 
-	return _array[index];
+	return _data[index];
 }
 
 template <typename T>
@@ -315,7 +305,7 @@ inline const T& Vector<T>::operator[](uint32_t index) const
 {
 	CE_ASSERT(index < _size, "Index out of bounds");
 
-	return _array[index];
+	return _data[index];
 }
 
 template <typename T>
@@ -325,9 +315,7 @@ inline const Vector<T>& Vector<T>::operator=(const Vector<T>& other)
 	vector::resize(*this, size);
 
 	for (uint32_t i = 0; i < size; i++)
-	{
-		_array[i] = other._array[i];
-	}
+		_data[i] = other._data[i];
 
 	return *this;
 }