src/*: code-style: fix template style

src/core/containers/array.inl

@@ -18,97 +18,97 @@ namespace crown
 namespace array
 {
 	/// Returns whether the array @a a is empty.
-	template <typename T> bool empty(const Array<T>& a);
+	template<typename T> bool empty(const Array<T>& a);
 
 	/// Returns the number of items in the array @a a.
-	template <typename T> u32 size(const Array<T>& a);
+	template<typename T> u32 size(const Array<T>& a);
 
 	/// Returns the maximum number of items the array @a a can hold.
-	template <typename T> u32 capacity(const Array<T>& a);
+	template<typename T> u32 capacity(const Array<T>& a);
 
 	/// Resizes the array @a a to the given @a size.
 	/// @note
 	/// Old items will be copied to the newly created array.
 	/// If the new capacity is smaller than the previous one, the
 	/// array will be truncated.
-	template <typename T> void resize(Array<T>& a, u32 size);
+	template<typename T> void resize(Array<T>& a, u32 size);
 
 	/// Reserves space in the array @a a for at least @a capacity items.
-	template <typename T> void reserve(Array<T>& a, u32 capacity);
+	template<typename T> void reserve(Array<T>& a, u32 capacity);
 
 	/// Sets the capacity of array @a a.
-	template <typename T> void set_capacity(Array<T>& a, u32 capacity);
+	template<typename T> void set_capacity(Array<T>& a, u32 capacity);
 
 	/// Grows the array @a a to contain at least @a min_capacity items.
-	template <typename T> void grow(Array<T>& a, u32 min_capacity);
+	template<typename T> void grow(Array<T>& a, u32 min_capacity);
 
 	/// Condenses the array @a a so that its capacity matches the actual number
 	/// of items in the array.
-	template <typename T> void condense(Array<T>& a);
+	template<typename T> void condense(Array<T>& a);
 
 	/// Appends an item to the array @a a and returns its index.
-	template <typename T> u32 push_back(Array<T>& a, const T& item);
+	template<typename T> u32 push_back(Array<T>& a, const T& item);
 
 	/// Removes the last item from the array @a a.
-	template <typename T> void pop_back(Array<T>& a);
+	template<typename T> void pop_back(Array<T>& a);
 
 	/// Appends @a count @a items to the array @a a and returns the number
 	/// of items in the array after the append operation.
-	template <typename T> u32 push(Array<T>& a, const T* items, u32 count);
+	template<typename T> u32 push(Array<T>& a, const T* items, u32 count);
 
 	/// Clears the content of the array @a a.
 	/// @note
 	/// Does not free memory nor call destructors, it only zeroes
 	/// the number of items in the array.
-	template <typename T> void clear(Array<T>& a);
+	template<typename T> void clear(Array<T>& a);
 
 	/// Returns a pointer to the first item in the array @a a.
-	template <typename T> T* begin(Array<T>& a);
+	template<typename T> T* begin(Array<T>& a);
 
 	/// Returns a pointer to the first item in the array @a a.
-	template <typename T> const T* begin(const Array<T>& a);
+	template<typename T> const T* begin(const Array<T>& a);
 
 	/// Returns a pointer to the item following the last item in the array @a a.
-	template <typename T> T* end(Array<T>& a);
+	template<typename T> T* end(Array<T>& a);
 
 	/// Returns a pointer to the item following the last item in the array @a a.
-	template <typename T> const T* end(const Array<T>& a);
+	template<typename T> const T* end(const Array<T>& a);
 
 	/// Returns the first element of the array @a a.
-	template <typename T> T& front(Array<T>& a);
+	template<typename T> T& front(Array<T>& a);
 
 	/// Returns the first element of the array @a a.
-	template <typename T> const T& front(const Array<T>& a);
+	template<typename T> const T& front(const Array<T>& a);
 
 	/// Returns the last element of the array @a a.
-	template <typename T> T& back(Array<T>& a);
+	template<typename T> T& back(Array<T>& a);
 
 	/// Returns the last element of the array @a a.
-	template <typename T> const T& back(const Array<T>& a);
+	template<typename T> const T& back(const Array<T>& a);
 
 } // namespace array
 
 namespace array
 {
-	template <typename T>
+	template<typename T>
 	inline bool empty(const Array<T>& a)
 	{
 		return a._size == 0;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline u32 size(const Array<T>& a)
 	{
 		return a._size;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline u32 capacity(const Array<T>& a)
 	{
 		return a._capacity;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline void resize(Array<T>& a, u32 size)
 	{
 		if (size > a._capacity)
@@ -117,14 +117,14 @@ namespace array
 		a._size = size;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline void reserve(Array<T>& a, u32 capacity)
 	{
 		if (capacity > a._capacity)
 			grow(a, capacity);
 	}
 
-	template <typename T>
+	template<typename T>
 	inline void set_capacity(Array<T>& a, u32 capacity)
 	{
 		if (capacity == a._capacity)
@@ -145,7 +145,7 @@ namespace array
 		}
 	}
 
-	template <typename T>
+	template<typename T>
 	inline void grow(Array<T>& a, u32 min_capacity)
 	{
 		u32 new_capacity = a._capacity * 2 + 1;
@@ -156,13 +156,13 @@ namespace array
 		set_capacity(a, new_capacity);
 	}
 
-	template <typename T>
+	template<typename T>
 	inline void condense(Array<T>& a)
 	{
 		resize(a, a._size);
 	}
 
-	template <typename T>
+	template<typename T>
 	inline u32 push_back(Array<T>& a, const T& item)
 	{
 		if (a._capacity == a._size)
@@ -173,14 +173,14 @@ namespace array
 		return a._size++;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline void pop_back(Array<T>& a)
 	{
 		CE_ASSERT(a._size > 0, "The array is empty");
 		--a._size;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline u32 push(Array<T>& a, const T* items, u32 count)
 	{
 		if (a._capacity <= a._size + count)
@@ -192,58 +192,58 @@ namespace array
 		return a._size;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline void clear(Array<T>& a)
 	{
 		a._size = 0;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline const T* begin(const Array<T>& a)
 	{
 		return a._data;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline T* begin(Array<T>& a)
 	{
 		return a._data;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline const T* end(const Array<T>& a)
 	{
 		return a._data + a._size;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline T* end(Array<T>& a)
 	{
 		return a._data + a._size;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline T& front(Array<T>& a)
 	{
 		CE_ASSERT(a._size > 0, "The array is empty");
 		return a._data[0];
 	}
 
-	template <typename T>
+	template<typename T>
 	inline const T& front(const Array<T>& a)
 	{
 		CE_ASSERT(a._size > 0, "The array is empty");
 		return a._data[0];
 	}
 
-	template <typename T>
+	template<typename T>
 	inline T& back(Array<T>& a)
 	{
 		CE_ASSERT(a._size > 0, "The array is empty");
 		return a._data[a._size - 1];
 	}
 
-	template <typename T>
+	template<typename T>
 	inline const T& back(const Array<T>& a)
 	{
 		CE_ASSERT(a._size > 0, "The array is empty");
@@ -252,7 +252,7 @@ namespace array
 
 } // namespace array
 
-template <typename T>
+template<typename T>
 inline Array<T>::Array(Allocator& a)
 	: _allocator(&a)
 	, _capacity(0)
@@ -261,7 +261,7 @@ inline Array<T>::Array(Allocator& a)
 {
 }
 
-template <typename T>
+template<typename T>
 inline Array<T>::Array(const Array<T>& other)
 	: _allocator(other._allocator)
 	, _capacity(0)
@@ -273,27 +273,27 @@ inline Array<T>::Array(const Array<T>& other)
 	memcpy(_data, other._data, sizeof(T) * size);
 }
 
-template <typename T>
+template<typename T>
 inline Array<T>::~Array()
 {
 	_allocator->deallocate(_data);
 }
 
-template <typename T>
+template<typename T>
 inline T& Array<T>::operator[](u32 index)
 {
 	CE_ASSERT(index < _size, "Index out of bounds");
 	return _data[index];
 }
 
-template <typename T>
+template<typename T>
 inline const T& Array<T>::operator[](u32 index) const
 {
 	CE_ASSERT(index < _size, "Index out of bounds");
 	return _data[index];
 }
 
-template <typename T>
+template<typename T>
 inline Array<T>& Array<T>::operator=(const Array<T>& other)
 {
 	const u32 size = other._size;

src/core/containers/hash_map.inl

@@ -21,44 +21,44 @@ namespace crown
 namespace hash_map
 {
 	/// Returns the number of items in the map @a m.
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual> u32 size(const HashMap<TKey, TValue, Hash, KeyEqual>& m);
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual> u32 size(const HashMap<TKey, TValue, Hash, KeyEqual>& m);
 
 	/// Returns the maximum number of items the map @a m can hold.
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual> u32 capacity(const HashMap<TKey, TValue, Hash, KeyEqual>& m);
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual> u32 capacity(const HashMap<TKey, TValue, Hash, KeyEqual>& m);
 
 	/// Returns whether the given @a key exists in the map @a m.
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual> bool has(const HashMap<TKey, TValue, Hash, KeyEqual>& m, const TKey& key);
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual> bool has(const HashMap<TKey, TValue, Hash, KeyEqual>& m, const TKey& key);
 
 	/// Returns the value for the given @a key or @a deffault if
 	/// the key does not exist in the map.
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual> const TValue& get(const HashMap<TKey, TValue, Hash, KeyEqual>& m, const TKey& key, const TValue& deffault);
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual> const TValue& get(const HashMap<TKey, TValue, Hash, KeyEqual>& m, const TKey& key, const TValue& deffault);
 
 	/// Returns the value for the given @a key or @a deffault if
 	/// the key does not exist in the map.
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual> TValue& get(HashMap<TKey, TValue, Hash, KeyEqual>& m, const TKey& key, const TValue& deffault);
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual> TValue& get(HashMap<TKey, TValue, Hash, KeyEqual>& m, const TKey& key, const TValue& deffault);
 
 	/// Sets the @a value for the @a key in the map.
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual> void set(HashMap<TKey, TValue, Hash, KeyEqual>& m, const TKey& key, const TValue& value);
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual> void set(HashMap<TKey, TValue, Hash, KeyEqual>& m, const TKey& key, const TValue& value);
 
 	/// Removes the @a key from the map if it exists.
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual> void remove(HashMap<TKey, TValue, Hash, KeyEqual>& m, const TKey& key);
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual> void remove(HashMap<TKey, TValue, Hash, KeyEqual>& m, const TKey& key);
 
 	/// Removes all the items in the map.
 	///
 	/// @note
 	/// Calls destructor on the items.
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual> void clear(HashMap<TKey, TValue, Hash, KeyEqual>& m);
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual> void clear(HashMap<TKey, TValue, Hash, KeyEqual>& m);
 
 	/// Returns whether the @a entry in the map @a m contains data or is a hole.
 	/// If the entry is a hole you should not touch data in the entry.
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual> bool is_hole(const HashMap<TKey, TValue, Hash, KeyEqual>& m, const typename HashMap<TKey, TValue, Hash, KeyEqual>::Entry* entry);
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual> bool is_hole(const HashMap<TKey, TValue, Hash, KeyEqual>& m, const typename HashMap<TKey, TValue, Hash, KeyEqual>::Entry* entry);
 
 	/// Returns a pointer to the first item in the map, can be used to
 	/// efficiently iterate over the elements (in random order).
 	/// @note
 	/// You should skip invalid items with HASH_MAP_SKIP_HOLE().
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual> const typename HashMap<TKey, TValue, Hash, KeyEqual>::Entry* begin(const HashMap<TKey, TValue, Hash, KeyEqual>& m);
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual> const typename HashMap<TKey, TValue, Hash, KeyEqual>::Entry* end(const HashMap<TKey, TValue, Hash, KeyEqual>& m);
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual> const typename HashMap<TKey, TValue, Hash, KeyEqual>::Entry* begin(const HashMap<TKey, TValue, Hash, KeyEqual>& m);
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual> const typename HashMap<TKey, TValue, Hash, KeyEqual>::Entry* end(const HashMap<TKey, TValue, Hash, KeyEqual>& m);
 
 } // namespace hash_map
 
@@ -71,14 +71,14 @@ namespace hash_map_internal
 		FREE        = 0x00000000u
 	};
 
-	template <typename TKey, typename Hash>
+	template<typename TKey, typename Hash>
 	inline u32 key_hash(const TKey& key)
 	{
 		const Hash hash;
 		return hash(key);
 	}
 
-	template <typename TKey, typename KeyEqual>
+	template<typename TKey, typename KeyEqual>
 	inline bool key_equals(const TKey& key_a, const TKey& key_b)
 	{
 		const KeyEqual equal;
@@ -91,14 +91,14 @@ namespace hash_map_internal
 		return (index >> 31) != 0;
 	}
 
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual>
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual>
 	inline u32 probe_distance(const HashMap<TKey, TValue, Hash, KeyEqual>& m, u32 hash, u32 slot_index)
 	{
 		const u32 hash_i = hash & m._mask;
 		return (slot_index + m._capacity - hash_i) & m._mask;
 	}
 
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual>
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual>
 	u32 find(const HashMap<TKey, TValue, Hash, KeyEqual>& m, const TKey& key)
 	{
 		if (m._size == 0)
@@ -120,7 +120,7 @@ namespace hash_map_internal
 		}
 	}
 
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual>
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual>
 	void insert(HashMap<TKey, TValue, Hash, KeyEqual>& m, u32 hash, const TKey& key, const TValue& value)
 	{
 		PAIR(TKey, TValue) new_item(*m._allocator);
@@ -160,7 +160,7 @@ namespace hash_map_internal
 		memcpy((void*)&new_item, &empty, sizeof(new_item));
 	}
 
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual>
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual>
 	void rehash(HashMap<TKey, TValue, Hash, KeyEqual>& m, u32 new_capacity)
 	{
 		typedef typename HashMap<TKey, TValue, Hash, KeyEqual>::Entry Entry;
@@ -199,14 +199,14 @@ namespace hash_map_internal
 		memcpy((void*)&nm, (void*)&empty, sizeof(HashMap<TKey, TValue, Hash, KeyEqual>));
 	}
 
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual>
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual>
 	void grow(HashMap<TKey, TValue, Hash, KeyEqual>& m)
 	{
 		const u32 new_capacity = (m._capacity == 0 ? 16 : m._capacity * 2);
 		rehash(m, new_capacity);
 	}
 
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual>
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual>
 	bool full(const HashMap<TKey, TValue, Hash, KeyEqual>& m)
 	{
 		return m._size >= m._capacity * 0.9f;
@@ -216,25 +216,25 @@ namespace hash_map_internal
 
 namespace hash_map
 {
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual>
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual>
 	u32 size(const HashMap<TKey, TValue, Hash, KeyEqual>& m)
 	{
 		return m._size;
 	}
 
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual>
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual>
 	u32 capacity(const HashMap<TKey, TValue, Hash, KeyEqual>& m)
 	{
 		return m._capacity;
 	}
 
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual>
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual>
 	bool has(const HashMap<TKey, TValue, Hash, KeyEqual>& m, const TKey& key)
 	{
 		return hash_map_internal::find(m, key) != hash_map_internal::END_OF_LIST;
 	}
 
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual>
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual>
 	const TValue& get(const HashMap<TKey, TValue, Hash, KeyEqual>& m, const TKey& key, const TValue& deffault)
 	{
 		const u32 i = hash_map_internal::find(m, key);
@@ -244,13 +244,13 @@ namespace hash_map
 			return m._data[i].second;
 	}
 
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual>
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual>
 	TValue& get(HashMap<TKey, TValue, Hash, KeyEqual>& m, const TKey& key, const TValue& deffault)
 	{
 		return const_cast<TValue&>(hash_map::get((const HashMap<TKey, TValue, Hash, KeyEqual>&)m, key, deffault));
 	}
 
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual>
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual>
 	void set(HashMap<TKey, TValue, Hash, KeyEqual>& m, const TKey& key, const TValue& value)
 	{
 		if (m._capacity == 0)
@@ -271,7 +271,7 @@ namespace hash_map
 			hash_map_internal::grow(m);
 	}
 
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual>
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual>
 	void remove(HashMap<TKey, TValue, Hash, KeyEqual>& m, const TKey& key)
 	{
 		const u32 i = hash_map_internal::find(m, key);
@@ -283,7 +283,7 @@ namespace hash_map
 		--m._size;
 	}
 
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual>
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual>
 	void clear(HashMap<TKey, TValue, Hash, KeyEqual>& m)
 	{
 		for (u32 i = 0; i < m._capacity; ++i)
@@ -296,7 +296,7 @@ namespace hash_map
 		m._size = 0;
 	}
 
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual>
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual>
 	bool is_hole(const HashMap<TKey, TValue, Hash, KeyEqual>& m, const typename HashMap<TKey, TValue, Hash, KeyEqual>::Entry* entry)
 	{
 		const u32 ii = u32(entry - m._data);
@@ -305,13 +305,13 @@ namespace hash_map
 		return index == hash_map_internal::FREE || hash_map_internal::is_deleted(index);
 	}
 
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual>
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual>
 	inline const typename HashMap<TKey, TValue, Hash, KeyEqual>::Entry* begin(const HashMap<TKey, TValue, Hash, KeyEqual>& m)
 	{
 		return m._data;
 	}
 
-	template <typename TKey, typename TValue, typename Hash, typename KeyEqual>
+	template<typename TKey, typename TValue, typename Hash, typename KeyEqual>
 	inline const typename HashMap<TKey, TValue, Hash, KeyEqual>::Entry* end(const HashMap<TKey, TValue, Hash, KeyEqual>& m)
 	{
 		return m._data + m._capacity;
@@ -319,7 +319,7 @@ namespace hash_map
 
 } // namespace hash_map
 
-template <typename TKey, typename TValue, typename Hash, typename KeyEqual>
+template<typename TKey, typename TValue, typename Hash, typename KeyEqual>
 inline HashMap<TKey, TValue, Hash, KeyEqual>::HashMap(Allocator& a)
 	: _allocator(&a)
 	, _capacity(0)
@@ -331,7 +331,7 @@ inline HashMap<TKey, TValue, Hash, KeyEqual>::HashMap(Allocator& a)
 {
 }
 
-template <typename TKey, typename TValue, typename Hash, typename KeyEqual>
+template<typename TKey, typename TValue, typename Hash, typename KeyEqual>
 HashMap<TKey, TValue, Hash, KeyEqual>::HashMap(const HashMap<TKey, TValue, Hash, KeyEqual>& other)
 	: _allocator(other._allocator)
 	, _capacity(0)
@@ -363,7 +363,7 @@ HashMap<TKey, TValue, Hash, KeyEqual>::HashMap(const HashMap<TKey, TValue, Hash,
 	}
 }
 
-template <typename TKey, typename TValue, typename Hash, typename KeyEqual>
+template<typename TKey, typename TValue, typename Hash, typename KeyEqual>
 inline HashMap<TKey, TValue, Hash, KeyEqual>::~HashMap()
 {
 	for (u32 i = 0; i < _capacity; ++i)
@@ -375,7 +375,7 @@ inline HashMap<TKey, TValue, Hash, KeyEqual>::~HashMap()
 	_allocator->deallocate(_buffer);
 }
 
-template <typename TKey, typename TValue, typename Hash, typename KeyEqual>
+template<typename TKey, typename TValue, typename Hash, typename KeyEqual>
 HashMap<TKey, TValue, Hash, KeyEqual>& HashMap<TKey, TValue, Hash, KeyEqual>::operator=(const HashMap<TKey, TValue, Hash, KeyEqual>& other)
 {
 	_capacity = other._capacity;

src/core/containers/hash_set.inl

@@ -18,36 +18,36 @@ namespace crown
 namespace hash_set
 {
 	/// Returns the number of items in the set @a m.
-	template <typename TKey, typename Hash, typename KeyEqual> u32 size(const HashSet<TKey, Hash, KeyEqual>& m);
+	template<typename TKey, typename Hash, typename KeyEqual> u32 size(const HashSet<TKey, Hash, KeyEqual>& m);
 
 	/// Returns the maximum number of items the set @a m can hold.
-	template <typename TKey, typename Hash, typename KeyEqual> u32 capacity(const HashSet<TKey, Hash, KeyEqual>& m);
+	template<typename TKey, typename Hash, typename KeyEqual> u32 capacity(const HashSet<TKey, Hash, KeyEqual>& m);
 
 	/// Returns whether the given @a key exists in the set @a m.
-	template <typename TKey, typename Hash, typename KeyEqual> bool has(const HashSet<TKey, Hash, KeyEqual>& m, const TKey& key);
+	template<typename TKey, typename Hash, typename KeyEqual> bool has(const HashSet<TKey, Hash, KeyEqual>& m, const TKey& key);
 
 	/// Inserts the @a key in the set if it does not exist.
-	template <typename TKey, typename Hash, typename KeyEqual> void insert(HashSet<TKey, Hash, KeyEqual>& m, const TKey& key);
+	template<typename TKey, typename Hash, typename KeyEqual> void insert(HashSet<TKey, Hash, KeyEqual>& m, const TKey& key);
 
 	/// Removes the @a key from the set if it exists.
-	template <typename TKey, typename Hash, typename KeyEqual> void remove(HashSet<TKey, Hash, KeyEqual>& m, const TKey& key);
+	template<typename TKey, typename Hash, typename KeyEqual> void remove(HashSet<TKey, Hash, KeyEqual>& m, const TKey& key);
 
 	/// Removes all the items in the set.
 	///
 	/// @note
 	/// Calls destructor on the items.
-	template <typename TKey, typename Hash, typename KeyEqual> void clear(HashSet<TKey, Hash, KeyEqual>& m);
+	template<typename TKey, typename Hash, typename KeyEqual> void clear(HashSet<TKey, Hash, KeyEqual>& m);
 
 	/// Returns whether the @a entry in the set @a m contains data or is a hole.
 	/// If the entry is a hole you should not touch data in the entry.
-	template <typename TKey, typename Hash, typename KeyEqual> bool is_hole(const HashSet<TKey, Hash, KeyEqual>& m, const TKey* entry);
+	template<typename TKey, typename Hash, typename KeyEqual> bool is_hole(const HashSet<TKey, Hash, KeyEqual>& m, const TKey* entry);
 
 	/// Returns a pointer to the first item in the set, can be used to
 	/// efficiently iterate over the elements (in random order).
 	/// @note
 	/// You should skip invalid items with HASH_SET_SKIP_HOLE().
-	template <typename TKey, typename Hash, typename KeyEqual> const TKey* begin(const HashSet<TKey, Hash, KeyEqual>& m);
-	template <typename TKey, typename Hash, typename KeyEqual> const TKey* end(const HashSet<TKey, Hash, KeyEqual>& m);
+	template<typename TKey, typename Hash, typename KeyEqual> const TKey* begin(const HashSet<TKey, Hash, KeyEqual>& m);
+	template<typename TKey, typename Hash, typename KeyEqual> const TKey* end(const HashSet<TKey, Hash, KeyEqual>& m);
 
 } // namespace hash_set
 
@@ -60,14 +60,14 @@ namespace hash_set_internal
 		FREE        = 0x00000000u
 	};
 
-	template <typename TKey, typename Hash>
+	template<typename TKey, typename Hash>
 	inline u32 key_hash(const TKey& key)
 	{
 		const Hash hash;
 		return hash(key);
 	}
 
-	template <typename TKey, typename KeyEqual>
+	template<typename TKey, typename KeyEqual>
 	inline bool key_equals(const TKey& key_a, const TKey& key_b)
 	{
 		const KeyEqual equal;
@@ -80,14 +80,14 @@ namespace hash_set_internal
 		return (index >> 31) != 0;
 	}
 
-	template <typename TKey, typename Hash, typename KeyEqual>
+	template<typename TKey, typename Hash, typename KeyEqual>
 	inline u32 probe_distance(const HashSet<TKey, Hash, KeyEqual>& m, u32 hash, u32 slot_index)
 	{
 		const u32 hash_i = hash & m._mask;
 		return (slot_index + m._capacity - hash_i) & m._mask;
 	}
 
-	template <typename TKey, typename Hash, typename KeyEqual>
+	template<typename TKey, typename Hash, typename KeyEqual>
 	u32 find(const HashSet<TKey, Hash, KeyEqual>& m, const TKey& key)
 	{
 		if (m._size == 0)
@@ -109,7 +109,7 @@ namespace hash_set_internal
 		}
 	}
 
-	template <typename TKey, typename Hash, typename KeyEqual>
+	template<typename TKey, typename Hash, typename KeyEqual>
 	void insert(HashSet<TKey, Hash, KeyEqual>& m, u32 hash, const TKey& key)
 	{
 		char new_item[sizeof(TKey)];
@@ -158,7 +158,7 @@ namespace hash_set_internal
 		return;
 	}
 
-	template <typename TKey, typename Hash, typename KeyEqual>
+	template<typename TKey, typename Hash, typename KeyEqual>
 	void rehash(HashSet<TKey, Hash, KeyEqual>& m, u32 new_capacity)
 	{
 		typedef typename HashSet<TKey, Hash, KeyEqual>::Index Index;
@@ -196,14 +196,14 @@ namespace hash_set_internal
 		memcpy((void*)&nm, (void*)&empty, sizeof(HashSet<TKey, Hash, KeyEqual>));
 	}
 
-	template <typename TKey, typename Hash, typename KeyEqual>
+	template<typename TKey, typename Hash, typename KeyEqual>
 	void grow(HashSet<TKey, Hash, KeyEqual>& m)
 	{
 		const u32 new_capacity = (m._capacity == 0 ? 16 : m._capacity * 2);
 		rehash(m, new_capacity);
 	}
 
-	template <typename TKey, typename Hash, typename KeyEqual>
+	template<typename TKey, typename Hash, typename KeyEqual>
 	bool full(const HashSet<TKey, Hash, KeyEqual>& m)
 	{
 		return m._size >= m._capacity * 0.9f;
@@ -213,25 +213,25 @@ namespace hash_set_internal
 
 namespace hash_set
 {
-	template <typename TKey, typename Hash, typename KeyEqual>
+	template<typename TKey, typename Hash, typename KeyEqual>
 	u32 size(const HashSet<TKey, Hash, KeyEqual>& m)
 	{
 		return m._size;
 	}
 
-	template <typename TKey, typename Hash, typename KeyEqual>
+	template<typename TKey, typename Hash, typename KeyEqual>
 	u32 capacity(const HashSet<TKey, Hash, KeyEqual>& m)
 	{
 		return m._capacity;
 	}
 
-	template <typename TKey, typename Hash, typename KeyEqual>
+	template<typename TKey, typename Hash, typename KeyEqual>
 	bool has(const HashSet<TKey, Hash, KeyEqual>& m, const TKey& key)
 	{
 		return hash_set_internal::find(m, key) != hash_set_internal::END_OF_LIST;
 	}
 
-	template <typename TKey, typename Hash, typename KeyEqual>
+	template<typename TKey, typename Hash, typename KeyEqual>
 	void insert(HashSet<TKey, Hash, KeyEqual>& m, const TKey& key)
 	{
 		if (m._capacity == 0)
@@ -248,7 +248,7 @@ namespace hash_set
 			hash_set_internal::grow(m);
 	}
 
-	template <typename TKey, typename Hash, typename KeyEqual>
+	template<typename TKey, typename Hash, typename KeyEqual>
 	void remove(HashSet<TKey, Hash, KeyEqual>& m, const TKey& key)
 	{
 		const u32 i = hash_set_internal::find(m, key);
@@ -260,7 +260,7 @@ namespace hash_set
 		--m._size;
 	}
 
-	template <typename TKey, typename Hash, typename KeyEqual>
+	template<typename TKey, typename Hash, typename KeyEqual>
 	void clear(HashSet<TKey, Hash, KeyEqual>& m)
 	{
 		for (u32 i = 0; i < m._capacity; ++i)
@@ -273,7 +273,7 @@ namespace hash_set
 		m._size = 0;
 	}
 
-	template <typename TKey, typename Hash, typename KeyEqual>
+	template<typename TKey, typename Hash, typename KeyEqual>
 	bool is_hole(const HashSet<TKey, Hash, KeyEqual>& m, const TKey* entry)
 	{
 		const u32 ii = u32(entry - m._data);
@@ -282,13 +282,13 @@ namespace hash_set
 		return index == hash_set_internal::FREE || hash_set_internal::is_deleted(index);
 	}
 
-	template <typename TKey, typename Hash, typename KeyEqual>
+	template<typename TKey, typename Hash, typename KeyEqual>
 	inline const TKey* begin(const HashSet<TKey, Hash, KeyEqual>& m)
 	{
 		return m._data;
 	}
 
-	template <typename TKey, typename Hash, typename KeyEqual>
+	template<typename TKey, typename Hash, typename KeyEqual>
 	inline const TKey* end(const HashSet<TKey, Hash, KeyEqual>& m)
 	{
 		return m._data + m._capacity;
@@ -296,7 +296,7 @@ namespace hash_set
 
 } // namespace hash_set
 
-template <typename TKey, typename Hash, typename KeyEqual>
+template<typename TKey, typename Hash, typename KeyEqual>
 inline HashSet<TKey, Hash, KeyEqual>::HashSet(Allocator& a)
 	: _allocator(&a)
 	, _capacity(0)
@@ -308,7 +308,7 @@ inline HashSet<TKey, Hash, KeyEqual>::HashSet(Allocator& a)
 {
 }
 
-template <typename TKey, typename Hash, typename KeyEqual>
+template<typename TKey, typename Hash, typename KeyEqual>
 HashSet<TKey, Hash, KeyEqual>::HashSet(const HashSet& other)
 	: _allocator(other._allocator)
 	, _capacity(0)
@@ -340,7 +340,7 @@ HashSet<TKey, Hash, KeyEqual>::HashSet(const HashSet& other)
 	}
 }
 
-template <typename TKey, typename Hash, typename KeyEqual>
+template<typename TKey, typename Hash, typename KeyEqual>
 inline HashSet<TKey, Hash, KeyEqual>::~HashSet()
 {
 	for (u32 i = 0; i < _capacity; ++i)
@@ -352,7 +352,7 @@ inline HashSet<TKey, Hash, KeyEqual>::~HashSet()
 	_allocator->deallocate(_buffer);
 }
 
-template <typename TKey, typename Hash, typename KeyEqual>
+template<typename TKey, typename Hash, typename KeyEqual>
 HashSet<TKey, Hash, KeyEqual>& HashSet<TKey, Hash, KeyEqual>::operator=(const HashSet<TKey, Hash, KeyEqual>& other)
 {
 	_capacity = other._capacity;

src/core/containers/queue.inl

@@ -78,25 +78,25 @@ namespace queue
 
 namespace queue
 {
-	template <typename T>
+	template<typename T>
 	inline bool empty(const Queue<T>& q)
 	{
 		return q._size == 0;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline u32 size(const Queue<T>& q)
 	{
 		return q._size;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline u32 space(const Queue<T>& q)
 	{
 		return array::size(q._queue) - q._size;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline void increase_capacity(Queue<T>& q, u32 capacity)
 	{
 		u32 old_size = array::size(q._queue);
@@ -110,7 +110,7 @@ namespace queue
 		}
 	}
 
-	template <typename T>
+	template<typename T>
 	inline void grow(Queue<T>& q, u32 min_capacity)
 	{
 		u32 new_capacity = array::size(q._queue) * 2 + 1;
@@ -121,7 +121,7 @@ namespace queue
 		increase_capacity(q, new_capacity);
 	}
 
-	template <typename T>
+	template<typename T>
 	inline void push_back(Queue<T>& q, const T& item)
 	{
 		if (space(q) == 0)
@@ -132,14 +132,14 @@ namespace queue
 		++q._size;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline void pop_back(Queue<T>& q)
 	{
 		CE_ASSERT(q._size > 0, "The queue is empty");
 		--q._size;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline void push_front(Queue<T>& q, const T& item)
 	{
 		if (space(q) == 0)
@@ -152,7 +152,7 @@ namespace queue
 		++q._size;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline void pop_front(Queue<T>& q)
 	{
 		CE_ASSERT(q._size > 0, "The queue is empty");
@@ -161,7 +161,7 @@ namespace queue
 		--q._size;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline void push(Queue<T>& q, const T *items, u32 n)
 	{
 		if (q.space() < n)
@@ -184,7 +184,7 @@ namespace queue
 		q._size += n;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline void pop(Queue<T>& q, u32 n)
 	{
 		CE_ASSERT(q._size > 0, "The queue is empty");
@@ -193,61 +193,61 @@ namespace queue
 		q._size -= n;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline void clear(Queue<T>& q)
 	{
 		q._read = 0;
 		q._size = 0;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline T* begin(Queue<T>& q)
 	{
 		return array::begin(q._queue) + q._read;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline const T* begin(const Queue<T>& q)
 	{
 		return array::begin(q._queue) + q._read;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline T* end(Queue<T>& q)
 	{
 		const u32 end = q._read + q._size;
 		return end >= array::size(q._queue) ? array::end(q._queue) : array::begin(q._queue) + end;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline const T* end(const Queue<T>& q)
 	{
 		const u32 end = q._read + q._size;
 		return end >= array::size(q._queue) ? array::end(q._queue) : array::begin(q._queue) + end;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline T& front(Queue<T>& q)
 	{
 		CE_ASSERT(q._size > 0, "The queue is empty");
 		return q._queue[q._read];
 	}
 
-	template <typename T>
+	template<typename T>
 	inline const T& front(const Queue<T>& q)
 	{
 		CE_ASSERT(q._size > 0, "The queue is empty");
 		return q._queue[q._read];
 	}
 
-	template <typename T>
+	template<typename T>
 	inline T& back(Queue<T>& q)
 	{
 		CE_ASSERT(q._size > 0, "The queue is empty");
 		return q[q._size - 1];
 	}
 
-	template <typename T>
+	template<typename T>
 	inline const T& back(const Queue<T>& q)
 	{
 		CE_ASSERT(q._size > 0, "The queue is empty");
@@ -256,7 +256,7 @@ namespace queue
 
 } // namespace queue
 
-template <typename T>
+template<typename T>
 inline Queue<T>::Queue(Allocator& a)
 	: _read(0)
 	, _size(0)
@@ -264,13 +264,13 @@ inline Queue<T>::Queue(Allocator& a)
 {
 }
 
-template <typename T>
+template<typename T>
 inline T& Queue<T>::operator[](u32 index)
 {
 	return _queue[(_read + index) % array::size(_queue)];
 }
 
-template <typename T>
+template<typename T>
 inline const T& Queue<T>::operator[](u32 index) const
 {
 	return _queue[(_read + index) % array::size(_queue)];

src/core/containers/types.h

@@ -21,7 +21,7 @@ namespace crown
 /// memcpy to move stuff around.
 ///
 /// @ingroup Containers
-template <typename T>
+template<typename T>
 struct Array
 {
 	ALLOCATOR_AWARE;
@@ -48,7 +48,7 @@ typedef Array<char> Buffer;
 /// If your data is POD, use Array<T> instead.
 ///
 /// @ingroup Containers
-template <typename T>
+template<typename T>
 struct Vector
 {
 	ALLOCATOR_AWARE;
@@ -69,7 +69,7 @@ struct Vector
 /// Circular buffer double-ended queue of POD items.
 ///
 /// @ingroup Containers
-template <typename T>
+template<typename T>
 struct Queue
 {
 	ALLOCATOR_AWARE;
@@ -86,7 +86,7 @@ struct Queue
 /// Hash map.
 ///
 /// @ingroup Containers
-template <typename TKey, typename TValue, typename Hash = hash<TKey>, typename KeyEqual = equal_to<TKey> >
+template<typename TKey, typename TValue, typename Hash = hash<TKey>, typename KeyEqual = equal_to<TKey>>
 struct HashMap
 {
 	ALLOCATOR_AWARE;
@@ -116,7 +116,7 @@ struct HashMap
 /// Hash set.
 ///
 /// @ingroup Containers
-template <typename TKey, typename Hash = hash<TKey>, typename KeyEqual = equal_to<TKey> >
+template<typename TKey, typename Hash = hash<TKey>, typename KeyEqual = equal_to<TKey>>
 struct HashSet
 {
 	ALLOCATOR_AWARE;

src/core/containers/vector.inl

@@ -18,96 +18,96 @@ namespace crown
 namespace vector
 {
 	/// Returns whether the vector @a v is empty.
-	template <typename T> bool empty(const Vector<T>& v);
+	template<typename T> bool empty(const Vector<T>& v);
 
 	/// Returns the number of items in the vector @a v.
-	template <typename T> u32 size(const Vector<T>& v);
+	template<typename T> u32 size(const Vector<T>& v);
 
 	/// Returns the maximum number of items the vector @a v can hold.
-	template <typename T> u32 capacity(const Vector<T>& v);
+	template<typename T> u32 capacity(const Vector<T>& v);
 
 	/// Resizes the vector @a v to the given @a size.
 	/// @note
 	/// Old items will be copied to the newly created vector.
 	/// If the new capacity is smaller than the previous one, the
 	/// vector will be truncated.
-	template <typename T> void resize(Vector<T>& v, u32 size);
+	template<typename T> void resize(Vector<T>& v, u32 size);
 
 	/// Reserves space in the vector @a v for at least @a capacity items.
-	template <typename T> void reserve(Vector<T>& v, u32 capacity);
+	template<typename T> void reserve(Vector<T>& v, u32 capacity);
 
 	/// Sets the capacity of vector @a v.
-	template <typename T> void set_capacity(Vector<T>& v, u32 capacity);
+	template<typename T> void set_capacity(Vector<T>& v, u32 capacity);
 
 	/// Grows the vector @a v to contain at least @a min_capacity items.
-	template <typename T> void grow(Vector<T>& v, u32 min_capacity);
+	template<typename T> void grow(Vector<T>& v, u32 min_capacity);
 
 	/// Condenses the vector @a v so that its capacity matches the actual number
 	/// of items in the vector.
-	template <typename T> void condense(Vector<T>& v);
+	template<typename T> void condense(Vector<T>& v);
 
 	/// Appends an item to the vector @a v and returns its index.
-	template <typename T> u32 push_back(Vector<T>& v, const T& item);
+	template<typename T> u32 push_back(Vector<T>& v, const T& item);
 
 	/// Removes the last item from the vector @a v.
-	template <typename T> void pop_back(Vector<T>& v);
+	template<typename T> void pop_back(Vector<T>& v);
 
 	/// Appends @a count @a items to the vector @a v and returns the number
 	/// of items in the vector after the append operation.
-	template <typename T> u32 push(Vector<T>& v, const T* items, u32 count);
+	template<typename T> u32 push(Vector<T>& v, const T* items, u32 count);
 
 	/// Clears the content of the vector @a v.
 	/// @note
 	/// Calls destructor on the items.
-	template <typename T> void clear(Vector<T>& v);
+	template<typename T> void clear(Vector<T>& v);
 
 	/// Returns a pointer to the first item in the vector @a v.
-	template <typename T> T* begin(Vector<T>& v);
+	template<typename T> T* begin(Vector<T>& v);
 
 	/// Returns a pointer to the first item in the vector @a v.
-	template <typename T> const T* begin(const Vector<T>& v);
+	template<typename T> const T* begin(const Vector<T>& v);
 
 	/// Returns a pointer to the item following the last item in the vector @a v.
-	template <typename T> T* end(Vector<T>& v);
+	template<typename T> T* end(Vector<T>& v);
 
 	/// Returns a pointer to the item following the last item in the vector @a v.
-	template <typename T> const T* end(const Vector<T>& v);
+	template<typename T> const T* end(const Vector<T>& v);
 
 	/// Returns the first item of the vector @a v.
-	template <typename T> T& front(Vector<T>& v);
+	template<typename T> T& front(Vector<T>& v);
 
 	/// Returns the first item of the vector @a v.
-	template <typename T> const T& front(const Vector<T>& v);
+	template<typename T> const T& front(const Vector<T>& v);
 
 	/// Returns the last item of the vector @a v.
-	template <typename T> T& back(Vector<T>& v);
+	template<typename T> T& back(Vector<T>& v);
 
 	/// Returns the last item of the vector @a v.
-	template <typename T> const T& back(const Vector<T>& v);
+	template<typename T> const T& back(const Vector<T>& v);
 
 } // namespace vector
 
 namespace vector
 {
-	template <typename T>
+	template<typename T>
 	inline bool empty(const Vector<T>& v)
 	{
 		return v._size == 0;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline u32 size(const Vector<T>& v)
 	{
 		return v._size;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline u32 capacity(const Vector<T>& v)
 	{
 		return v._capacity;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline void resize(Vector<T>& v, u32 size)
 	{
 		if (size > v._capacity)
@@ -116,14 +116,14 @@ namespace vector
 		v._size = size;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline void reserve(Vector<T>& v, u32 capacity)
 	{
 		if (capacity > v._capacity)
 			grow(v, capacity);
 	}
 
-	template <typename T>
+	template<typename T>
 	inline void set_capacity(Vector<T>& v, u32 capacity)
 	{
 		if (capacity == v._capacity)
@@ -148,7 +148,7 @@ namespace vector
 		}
 	}
 
-	template <typename T>
+	template<typename T>
 	inline void grow(Vector<T>& v, u32 min_capacity)
 	{
 		u32 new_capacity = v._capacity * 2 + 1;
@@ -159,13 +159,13 @@ namespace vector
 		set_capacity(v, new_capacity);
 	}
 
-	template <typename T>
+	template<typename T>
 	inline void condense(Vector<T>& v)
 	{
 		resize(v, v._size);
 	}
 
-	template <typename T>
+	template<typename T>
 	inline u32 push_back(Vector<T>& v, const T& item)
 	{
 		if (v._capacity == v._size)
@@ -177,7 +177,7 @@ namespace vector
 		return v._size++;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline void pop_back(Vector<T>& v)
 	{
 		CE_ASSERT(v._size > 0, "The vector is empty");
@@ -185,7 +185,7 @@ namespace vector
 		--v._size;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline u32 push(Vector<T>& v, const T* items, u32 count)
 	{
 		if (v._capacity <= v._size + count)
@@ -199,7 +199,7 @@ namespace vector
 		return v._size;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline void clear(Vector<T>& v)
 	{
 		for (u32 i = 0; i < v._size; ++i)
@@ -208,52 +208,52 @@ namespace vector
 		v._size = 0;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline T* begin(Vector<T>& v)
 	{
 		return v._data;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline const T* begin(const Vector<T>& v)
 	{
 		return v._data;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline T* end(Vector<T>& v)
 	{
 		return v._data + v._size;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline const T* end(const Vector<T>& v)
 	{
 		return v._data + v._size;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline T& front(Vector<T>& v)
 	{
 		CE_ASSERT(v._size > 0, "The vector is empty");
 		return v._data[0];
 	}
 
-	template <typename T>
+	template<typename T>
 	inline const T& front(const Vector<T>& v)
 	{
 		CE_ASSERT(v._size > 0, "The vector is empty");
 		return v._data[0];
 	}
 
-	template <typename T>
+	template<typename T>
 	inline T& back(Vector<T>& v)
 	{
 		CE_ASSERT(v._size > 0, "The vector is empty");
 		return v._data[v._size - 1];
 	}
 
-	template <typename T>
+	template<typename T>
 	inline const T& back(const Vector<T>& v)
 	{
 		CE_ASSERT(v._size > 0, "The vector is empty");
@@ -262,7 +262,7 @@ namespace vector
 
 } // namespace vector
 
-template <typename T>
+template<typename T>
 inline Vector<T>::Vector(Allocator& a)
 	: _allocator(&a)
 	, _capacity(0)
@@ -271,7 +271,7 @@ inline Vector<T>::Vector(Allocator& a)
 {
 }
 
-template <typename T>
+template<typename T>
 inline Vector<T>::Vector(const Vector<T>& other)
 	: _allocator(other._allocator)
 	, _capacity(0)
@@ -285,7 +285,7 @@ inline Vector<T>::Vector(const Vector<T>& other)
 		new (&_data[i]) T(other._data[i]);
 }
 
-template <typename T>
+template<typename T>
 inline Vector<T>::~Vector()
 {
 	for (u32 i = 0; i < _size; ++i)
@@ -294,21 +294,21 @@ inline Vector<T>::~Vector()
 	_allocator->deallocate(_data);
 }
 
-template <typename T>
+template<typename T>
 inline T& Vector<T>::operator[](u32 index)
 {
 	CE_ASSERT(index < _size, "Index out of bounds");
 	return _data[index];
 }
 
-template <typename T>
+template<typename T>
 inline const T& Vector<T>::operator[](u32 index) const
 {
 	CE_ASSERT(index < _size, "Index out of bounds");
 	return _data[index];
 }
 
-template <typename T>
+template<typename T>
 inline const Vector<T>& Vector<T>::operator=(const Vector<T>& other)
 {
 	const u32 size = vector::size(other);

src/core/filesystem/reader_writer.h

@@ -27,11 +27,11 @@ struct BinaryWriter
 	void write(const void* data, u32 size);
 
 	///
-	template <typename T>
+	template<typename T>
 	void write(const T& data);
 
 	///
-	template <typename T>
+	template<typename T>
 	void write_unaligned(const T& data);
 
 	///
@@ -55,11 +55,11 @@ struct BinaryReader
 	void read(void* data, u32 size);
 
 	///
-	template <typename T>
+	template<typename T>
 	void read(T& data);
 
 	///
-	template <typename T>
+	template<typename T>
 	void read_unaligned(T& data);
 
 	///

src/core/filesystem/reader_writer.inl

@@ -30,14 +30,14 @@ inline void BinaryWriter::write(const void* data, u32 size)
 	_file.write(data, size);
 }
 
-template <typename T>
+template<typename T>
 inline void BinaryWriter::write(const T& data)
 {
 	align(alignof(T));
 	_file.write(&data, sizeof(T));
 }
 
-template <typename T>
+template<typename T>
 inline void BinaryWriter::write_unaligned(const T& data)
 {
 	_file.write(&data, sizeof(T));
@@ -66,14 +66,14 @@ inline void BinaryReader::read(void* data, u32 size)
 	_file.read(data, size);
 }
 
-template <typename T>
+template<typename T>
 inline void BinaryReader::read(T& data)
 {
 	align(alignof(T));
 	_file.read(&data, sizeof(T));
 }
 
-template <typename T>
+template<typename T>
 inline void BinaryReader::read_unaligned(T& data)
 {
 	_file.read(&data, sizeof(T));

src/core/functional.h

@@ -21,7 +21,7 @@ struct not_equal_to
 	bool operator()(const T& a, const T& b) const;
 };
 
-template <typename T>
+template<typename T>
 struct greater
 {
 	bool operator()(const T& a, const T& b) const;
@@ -45,7 +45,7 @@ struct less_equal
 	bool operator()(const T& a, const T& b) const;
 };
 
-template <typename T>
+template<typename T>
 struct hash;
 
 template<>

src/core/math/vector3.inl

@@ -161,7 +161,7 @@ inline f32 angle(const Vector3& a, const Vector3& b)
 }
 
 /// Returns a vector that contains the largest value for each element from @a a and @a b.
-template <>
+template<>
 inline Vector3 max<Vector3>(const Vector3& a, const Vector3& b)
 {
 	Vector3 v;
@@ -172,7 +172,7 @@ inline Vector3 max<Vector3>(const Vector3& a, const Vector3& b)
 }
 
 /// Returns a vector that contains the smallest value for each element from @a a and @a b.
-template <>
+template<>
 inline Vector3 min<Vector3>(const Vector3& a, const Vector3& b)
 {
 	Vector3 v;

src/core/memory/memory.inl

@@ -27,7 +27,7 @@ namespace memory
 	}
 
 	/// Respects standard behaviour when calling on NULL @a ptr
-	template <typename T>
+	template<typename T>
 	inline void call_destructor_and_deallocate(Allocator& a, T* ptr)
 	{
 		if (!ptr)
@@ -40,22 +40,22 @@ namespace memory
 } // namespace memory
 
 /// Convert integer to type.
-template <int v>
+template<int v>
 struct Int2Type { enum {value=v}; };
 
-template <typename T>
+template<typename T>
 inline T &construct(void *p, Allocator& a, Int2Type<true>)
 {
 	return *(T*)new (p) T(a);
 }
 
-template <typename T>
+template<typename T>
 inline T &construct(void *p, Allocator& /*a*/, Int2Type<false>)
 {
 	return *(T*)new (p) T();
 }
 
-template <typename T>
+template<typename T>
 inline T &construct(void *p, Allocator& a)
 {
 	return construct<T>(p, a, IS_ALLOCATOR_AWARE_TYPE(T)());

src/core/memory/temp_allocator.inl

@@ -24,7 +24,7 @@ namespace crown
 /// automatically deallocated when the TempAllocator is destroyed.
 ///
 /// @ingroup Memory
-template <int BUFFER_SIZE>
+template<int BUFFER_SIZE>
 struct TempAllocator : public Allocator
 {
 	char _buffer[BUFFER_SIZE];	//< Local stack buffer for allocations.
@@ -65,7 +65,7 @@ typedef TempAllocator<4096> TempAllocator4096;
 // Inline function implementations
 // ---------------------------------------------------------------
 
-template <int BUFFER_SIZE>
+template<int BUFFER_SIZE>
 TempAllocator<BUFFER_SIZE>::TempAllocator(Allocator &backing) : _backing(backing), _chunk_size(4*1024)
 {
 	_p = _start = _buffer;
@@ -74,7 +74,7 @@ TempAllocator<BUFFER_SIZE>::TempAllocator(Allocator &backing) : _backing(backing
 	_p += sizeof(void *);
 }
 
-template <int BUFFER_SIZE>
+template<int BUFFER_SIZE>
 TempAllocator<BUFFER_SIZE>::~TempAllocator()
 {
 	char* start = _buffer;
@@ -86,7 +86,7 @@ TempAllocator<BUFFER_SIZE>::~TempAllocator()
 	}
 }
 
-template <int BUFFER_SIZE>
+template<int BUFFER_SIZE>
 void *TempAllocator<BUFFER_SIZE>::allocate(u32 size, u32 align)
 {
 	_p = (char *)memory::align_top(_p, align);

src/core/memory/types.h

@@ -12,12 +12,12 @@ namespace crown
 struct Allocator;
 
 /// Determines if a type is allocator aware.
-template <typename T>
+template<typename T>
 struct is_allocator_aware {
-	template <typename C>
+	template<typename C>
 	static char test_fun(typename C::allocator_aware *);
 
-	template <typename C>
+	template<typename C>
 	static int test_fun(...);
 
 	enum {

src/core/pair.h

@@ -9,12 +9,12 @@
 
 namespace crown
 {
-template <typename T1, typename T2, int T1Aware, int T2Aware>
+template<typename T1, typename T2, int T1Aware, int T2Aware>
 struct Pair
 {
 };
 
-template <typename T1, typename T2>
+template<typename T1, typename T2>
 struct Pair<T1, T2, 0, 0>
 {
 	ALLOCATOR_AWARE;
@@ -29,7 +29,7 @@ struct Pair<T1, T2, 0, 0>
 	Pair(Allocator& /*a*/);
 };
 
-template <typename T1, typename T2>
+template<typename T1, typename T2>
 struct Pair<T1, T2, 1, 0>
 {
 	ALLOCATOR_AWARE;
@@ -44,7 +44,7 @@ struct Pair<T1, T2, 1, 0>
 	Pair(Allocator& a);
 };
 
-template <typename T1, typename T2>
+template<typename T1, typename T2>
 struct Pair<T1, T2, 0, 1>
 {
 	ALLOCATOR_AWARE;
@@ -59,7 +59,7 @@ struct Pair<T1, T2, 0, 1>
 	Pair(Allocator& a);
 };
 
-template <typename T1, typename T2>
+template<typename T1, typename T2>
 struct Pair<T1, T2, 1, 1>
 {
 	ALLOCATOR_AWARE;

src/core/pair.inl

@@ -10,63 +10,63 @@
 
 namespace crown
 {
-template <typename T1, typename T2>
+template<typename T1, typename T2>
 inline Pair<T1, T2, 0, 0>::Pair(T1& f, T2& s)
 	: first(f)
 	, second(s)
 {
 }
 
-template <typename T1, typename T2>
+template<typename T1, typename T2>
 inline Pair<T1, T2, 0, 0>::Pair(Allocator& /*a*/)
 	: first()
 	, second()
 {
 }
 
-template <typename T1, typename T2>
+template<typename T1, typename T2>
 inline Pair<T1, T2, 1, 0>::Pair(T1& f, T2& s)
 	: first(f)
 	, second(s)
 {
 }
 
-template <typename T1, typename T2>
+template<typename T1, typename T2>
 inline Pair<T1, T2, 1, 0>::Pair(Allocator& a)
 	: first(a)
 	, second()
 {
 }
 
-template <typename T1, typename T2>
+template<typename T1, typename T2>
 inline Pair<T1, T2, 0, 1>::Pair(T1& f, T2& s)
 	: first(f)
 	, second(s)
 {
 }
 
-template <typename T1, typename T2>
+template<typename T1, typename T2>
 inline Pair<T1, T2, 0, 1>::Pair(Allocator& a)
 	: first()
 	, second(a)
 {
 }
 
-template <typename T1, typename T2>
+template<typename T1, typename T2>
 inline Pair<T1, T2, 1, 1>::Pair(T1& f, T2& s)
 	: first(f)
 	, second(s)
 {
 }
 
-template <typename T1, typename T2>
+template<typename T1, typename T2>
 inline Pair<T1, T2, 1, 1>::Pair(Allocator& a)
 	: first(a)
 	, second(a)
 {
 }
 
-template <typename T1, typename T2>
+template<typename T1, typename T2>
 inline void swap(Pair<T1, T2, 0, 0>& a, Pair<T1, T2, 0, 0>& b)
 {
 	char c[sizeof(a)];
@@ -75,7 +75,7 @@ inline void swap(Pair<T1, T2, 0, 0>& a, Pair<T1, T2, 0, 0>& b)
 	memcpy((void*)&b, (void*)&c, sizeof(a));
 }
 
-template <typename T1, typename T2>
+template<typename T1, typename T2>
 inline void swap(Pair<T1, T2, 0, 1>& a, Pair<T1, T2, 0, 1>& b)
 {
 	char c[sizeof(a)];
@@ -84,7 +84,7 @@ inline void swap(Pair<T1, T2, 0, 1>& a, Pair<T1, T2, 0, 1>& b)
 	memcpy((void*)&b, (void*)&c, sizeof(a));
 }
 
-template <typename T1, typename T2>
+template<typename T1, typename T2>
 inline void swap(Pair<T1, T2, 1, 0>& a, Pair<T1, T2, 1, 0>& b)
 {
 	char c[sizeof(a)];
@@ -93,7 +93,7 @@ inline void swap(Pair<T1, T2, 1, 0>& a, Pair<T1, T2, 1, 0>& b)
 	memcpy((void*)&b, (void*)&c, sizeof(a));
 }
 
-template <typename T1, typename T2>
+template<typename T1, typename T2>
 inline void swap(Pair<T1, T2, 1, 1>& a, Pair<T1, T2, 1, 1>& b)
 {
 	char c[sizeof(a)];

src/core/strings/dynamic_string.inl

@@ -171,7 +171,7 @@ inline const char* DynamicString::c_str() const
 	return array::begin(_data);
 }
 
-template <>
+template<>
 struct hash<DynamicString>
 {
 	u32 operator()(const DynamicString& val) const

src/core/strings/string_id.inl

@@ -54,7 +54,7 @@ inline bool operator<(const StringId64& a, const StringId64& b)
 	return a._id < b._id;
 }
 
-template <>
+template<>
 struct hash<StringId32>
 {
 	u32 operator()(const StringId32& id) const
@@ -63,7 +63,7 @@ struct hash<StringId32>
 	}
 };
 
-template <>
+template<>
 struct hash<StringId64>
 {
 	u32 operator()(const StringId64& id) const

src/core/strings/string_stream.h

@@ -23,7 +23,7 @@ namespace string_stream
 	const char* c_str(StringStream& s);
 
 	///
-	template <typename T> StringStream& stream_printf(StringStream& s, const char* format, T& val);
+	template<typename T> StringStream& stream_printf(StringStream& s, const char* format, T& val);
 
 } // namespace string_stream
 

src/core/strings/string_stream.inl

@@ -88,7 +88,7 @@ namespace string_stream
 		return array::begin(s);
 	}
 
-	template <typename T>
+	template<typename T>
 	inline StringStream& stream_printf(StringStream& s, const char* format, T& val)
 	{
 		char buf[32];

src/core/types.h

@@ -35,7 +35,7 @@ typedef float    f32;
 typedef double   f64;
 /// @}
 
-template <typename T>
+template<typename T>
 inline void exchange(T& a, T& b)
 {
 	T c = a;
@@ -43,19 +43,19 @@ inline void exchange(T& a, T& b)
 	b = c;
 }
 
-template <typename T>
+template<typename T>
 inline T min(const T& a, const T& b)
 {
 	return a < b ? a : b;
 }
 
-template <typename T>
+template<typename T>
 inline T max(const T& a, const T& b)
 {
 	return a > b ? a : b;
 }
 
-template <typename T>
+template<typename T>
 inline T clamp(T val, T mmin, T mmax)
 {
 	return min(max(mmin, val), mmax);

src/device/profiler.cpp

@@ -55,7 +55,7 @@ namespace profiler
 		_thread_buffer_size = 0;
 	}
 
-	template <typename T>
+	template<typename T>
 	static void push(ProfilerEventType::Enum type, const T& ev)
 	{
 		if (_thread_buffer_size + 2*sizeof(u32) + sizeof(ev) >= THREAD_BUFFER_SIZE)

src/resource/compile_options.h

@@ -139,7 +139,7 @@ struct CompileOptions
 	void write(const void* data, u32 size);
 
 	///
-	template <typename T>
+	template<typename T>
 	void write(const T& data);
 
 	///

src/resource/compile_options.inl

@@ -12,7 +12,7 @@
 namespace crown
 {
 ///
-template <typename T>
+template<typename T>
 void CompileOptions::write(const T& data)
 {
 	_binary_writer.write(data);

src/resource/data_compiler.cpp

@@ -385,7 +385,7 @@ static void read_data_mtimes(HashMap<StringId64, u64>& mtimes, FilesystemDisk& d
 	parse_data_mtimes(mtimes, obj, data_index);
 }
 
-static void add_dependency_internal(HashMap<StringId64, HashMap<DynamicString, u32> >& dependencies, ResourceId id, const DynamicString& dependency)
+static void add_dependency_internal(HashMap<StringId64, HashMap<DynamicString, u32>>& dependencies, ResourceId id, const DynamicString& dependency)
 {
 	HashMap<DynamicString, u32> deps_deffault(default_allocator());
 	HashMap<DynamicString, u32>& deps = hash_map::get(dependencies, id, deps_deffault);
@@ -396,7 +396,7 @@ static void add_dependency_internal(HashMap<StringId64, HashMap<DynamicString, u
 		hash_map::set(dependencies, id, deps);
 }
 
-static void add_dependency_internal(HashMap<StringId64, HashMap<DynamicString, u32> >& dependencies, ResourceId id, const char* dependency)
+static void add_dependency_internal(HashMap<StringId64, HashMap<DynamicString, u32>>& dependencies, ResourceId id, const char* dependency)
 {
 	TempAllocator512 ta;
 	DynamicString dependency_str(ta);
@@ -517,7 +517,7 @@ static void write_data_mtimes(FilesystemDisk& data_fs, const char* filename, con
 	data_fs.close(*file);
 }
 
-static void write_data_dependencies(FilesystemDisk& data_fs, const char* filename, const HashMap<StringId64, DynamicString>& index, const HashMap<StringId64, HashMap<DynamicString, u32> >& dependencies, const HashMap<StringId64, HashMap<DynamicString, u32> >& requirements)
+static void write_data_dependencies(FilesystemDisk& data_fs, const char* filename, const HashMap<StringId64, DynamicString>& index, const HashMap<StringId64, HashMap<DynamicString, u32>>& dependencies, const HashMap<StringId64, HashMap<DynamicString, u32>>& requirements)
 {
 	StringStream ss(default_allocator());
 

src/resource/data_compiler.h

@@ -58,8 +58,8 @@ struct DataCompiler
 	Vector<DynamicString> _globs;
 	HashMap<StringId64, DynamicString> _data_index;
 	HashMap<StringId64, u64> _data_mtimes;
-	HashMap<StringId64, HashMap<DynamicString, u32> > _data_dependencies;
-	HashMap<StringId64, HashMap<DynamicString, u32> > _data_requirements;
+	HashMap<StringId64, HashMap<DynamicString, u32>> _data_dependencies;
+	HashMap<StringId64, HashMap<DynamicString, u32>> _data_requirements;
 	HashMap<DynamicString, u32> _data_versions;
 	FileMonitor _file_monitor;
 	SourceIndex _source_index;

src/resource/material_resource.cpp

@@ -148,7 +148,7 @@ namespace material_resource_internal
 	};
 
 	// Returns offset to start of data
-	template <typename T>
+	template<typename T>
 	static u32 reserve_dynamic_data(Array<char>& dynamic, T data)
 	{
 		u32 offt = array::size(dynamic);

src/world/event_stream.inl

@@ -36,7 +36,7 @@ namespace event_stream
 	}
 
 	/// Appends the @a event of the given @a type to the stream @a s
-	template <typename T>
+	template<typename T>
 	inline void write(EventStream& s, u32 type, const T& event)
 	{
 		event_stream::write(s, type, sizeof(T), &event);

src/world/types.h

@@ -248,7 +248,7 @@ inline bool operator!=(const UnitId& a, const UnitId& b)
 
 const UnitId UNIT_INVALID = { UINT32_MAX };
 
-template <>
+template<>
 struct hash<UnitId>
 {
 	u32 operator()(const UnitId& id) const