From e7bae9891a84c967d01f32018f154d36121a9908 Mon Sep 17 00:00:00 2001
From: Christophe Riccio <christopheri@unity3d.com>
Date: Mon, 31 Aug 2015 22:50:24 +0200
Subject: [PATCH] Improved coding style consistency

---
 glm/gtx/hash.hpp | 58 +++++++++++++++++++++---------------------
 glm/gtx/hash.inl | 65 +++++++++++++++++++-----------------------------
 2 files changed, 54 insertions(+), 69 deletions(-)

diff --git a/glm/gtx/hash.hpp b/glm/gtx/hash.hpp
index 1d9e5572..02030987 100644
--- a/glm/gtx/hash.hpp
+++ b/glm/gtx/hash.hpp
@@ -70,93 +70,93 @@
 namespace std
 {
 	template <typename T, glm::precision P>
-	struct hash<glm::tvec1<T,P>>
+	struct hash<glm::tvec1<T,P> >
 	{
-		GLM_FUNC_DECL size_t operator()(const glm::tvec1<T,P> &v) const;
+		GLM_FUNC_DECL size_t operator()(glm::tvec1<T, P> const & v) const;
 	};
 
 	template <typename T, glm::precision P>
-	struct hash<glm::tvec2<T,P>>
+	struct hash<glm::tvec2<T,P> >
 	{
-		GLM_FUNC_DECL size_t operator()(const glm::tvec2<T,P> &v) const;
+		GLM_FUNC_DECL size_t operator()(glm::tvec2<T, P> const & v) const;
 	};
 
 	template <typename T, glm::precision P>
-	struct hash<glm::tvec3<T,P>>
+	struct hash<glm::tvec3<T,P> >
 	{
-		GLM_FUNC_DECL size_t operator()(const glm::tvec3<T,P> &v) const;
+		GLM_FUNC_DECL size_t operator()(glm::tvec3<T, P> const & v) const;
 	};
 
 	template <typename T, glm::precision P>
-	struct hash<glm::tvec4<T,P>>
+	struct hash<glm::tvec4<T,P> >
 	{
-		GLM_FUNC_DECL size_t operator()(const glm::tvec4<T,P> &v) const;
+		GLM_FUNC_DECL size_t operator()(glm::tvec4<T, P> const & v) const;
 	};
 
 	template <typename T, glm::precision P>
 	struct hash<glm::tquat<T,P>>
 	{
-		GLM_FUNC_DECL size_t operator()(const glm::tquat<T,P> &q) const;
+		GLM_FUNC_DECL size_t operator()(glm::tquat<T, P> const & q) const;
 	};
 
 	template <typename T, glm::precision P>
-	struct hash<glm::tdualquat<T,P>>
+	struct hash<glm::tdualquat<T,P> >
 	{
-		GLM_FUNC_DECL size_t operator()(const glm::tdualquat<T,P> &q) const;
+		GLM_FUNC_DECL size_t operator()(glm::tdualquat<T,P> const & q) const;
 	};
 
 	template <typename T, glm::precision P>
-	struct hash<glm::tmat2x2<T,P>>
+	struct hash<glm::tmat2x2<T,P> >
 	{
-		GLM_FUNC_DECL size_t operator()(const glm::tmat2x2<T,P> &m) const;
+		GLM_FUNC_DECL size_t operator()(glm::tmat2x2<T,P> const & m) const;
 	};
 
 	template <typename T, glm::precision P>
-	struct hash<glm::tmat2x3<T,P>>
+	struct hash<glm::tmat2x3<T,P> >
 	{
-		GLM_FUNC_DECL size_t operator()(const glm::tmat2x3<T,P> &m) const;
+		GLM_FUNC_DECL size_t operator()(glm::tmat2x3<T,P> const & m) const;
 	};
 
 	template <typename T, glm::precision P>
-	struct hash<glm::tmat2x4<T,P>>
+	struct hash<glm::tmat2x4<T,P> >
 	{
-		GLM_FUNC_DECL size_t operator()(const glm::tmat2x4<T,P> &m) const;
+		GLM_FUNC_DECL size_t operator()(glm::tmat2x4<T,P> const & m) const;
 	};
 
 	template <typename T, glm::precision P>
-	struct hash<glm::tmat3x2<T,P>>
+	struct hash<glm::tmat3x2<T,P> >
 	{
-		GLM_FUNC_DECL size_t operator()(const glm::tmat3x2<T,P> &m) const;
+		GLM_FUNC_DECL size_t operator()(glm::tmat3x2<T,P> const & m) const;
 	};
 
 	template <typename T, glm::precision P>
-	struct hash<glm::tmat3x3<T,P>>
+	struct hash<glm::tmat3x3<T,P> >
 	{
-		GLM_FUNC_DECL size_t operator()(const glm::tmat3x3<T,P> &m) const;
+		GLM_FUNC_DECL size_t operator()(glm::tmat3x3<T,P> const & m) const;
 	};
 
 	template <typename T, glm::precision P>
-	struct hash<glm::tmat3x4<T,P>>
+	struct hash<glm::tmat3x4<T,P> >
 	{
-		GLM_FUNC_DECL size_t operator()(const glm::tmat3x4<T,P> &m) const;
+		GLM_FUNC_DECL size_t operator()(glm::tmat3x4<T,P> const & m) const;
 	};
 
 	template <typename T, glm::precision P>
-	struct hash<glm::tmat4x2<T,P>>
+	struct hash<glm::tmat4x2<T,P> >
 	{
-		GLM_FUNC_DECL size_t operator()(const glm::tmat4x2<T,P> &m) const;
+		GLM_FUNC_DECL size_t operator()(glm::tmat4x2<T,P> const & m) const;
 	};
 	
 	template <typename T, glm::precision P>
-	struct hash<glm::tmat4x3<T,P>>
+	struct hash<glm::tmat4x3<T,P> >
 	{
-		GLM_FUNC_DECL size_t operator()(const glm::tmat4x3<T,P> &m) const;
+		GLM_FUNC_DECL size_t operator()(glm::tmat4x3<T,P> const & m) const;
 	};
 
 	template <typename T, glm::precision P>
-	struct hash<glm::tmat4x4<T,P>>
+	struct hash<glm::tmat4x4<T,P> >
 	{
-		GLM_FUNC_DECL size_t operator()(const glm::tmat4x4<T,P> &m) const;
+		GLM_FUNC_DECL size_t operator()(glm::tmat4x4<T,P> const & m) const;
 	};
 } // namespace std
 
diff --git a/glm/gtx/hash.inl b/glm/gtx/hash.inl
index bba2c1ed..8aa299e1 100644
--- a/glm/gtx/hash.inl
+++ b/glm/gtx/hash.inl
@@ -52,16 +52,14 @@ namespace detail
 namespace std
 {
 	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t
-	hash<glm::tvec1<T,P>>::operator()(const glm::tvec1<T,P> &v) const
+	GLM_FUNC_QUALIFIER size_t hash<glm::tvec1<T, P>>::operator()(glm::tvec1<T, P> const & v) const
 	{
 		hash<T> hasher;
 		return hasher(v.x);
 	}
 
 	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t
-	hash<glm::tvec2<T,P>>::operator()(const glm::tvec2<T,P> &v) const
+	GLM_FUNC_QUALIFIER size_t hash<glm::tvec2<T, P>>::operator()(glm::tvec2<T, P> const & v) const
 	{
 		size_t seed = 0;
 		hash<T> hasher;
@@ -71,8 +69,7 @@ namespace std
 	}
 
 	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t
-	hash<glm::tvec3<T,P>>::operator()(const glm::tvec3<T,P> &v) const
+	GLM_FUNC_QUALIFIER size_t hash<glm::tvec3<T, P>>::operator()(glm::tvec3<T, P> const & v) const
 	{
 		size_t seed = 0;
 		hash<T> hasher;
@@ -83,8 +80,7 @@ namespace std
 	}
 
 	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t
-	hash<glm::tvec4<T,P>>::operator()(const glm::tvec4<T,P> &v) const
+	GLM_FUNC_QUALIFIER size_t hash<glm::tvec4<T, P>>::operator()(glm::tvec4<T, P> const & v) const
 	{
 		size_t seed = 0;
 		hash<T> hasher;
@@ -96,8 +92,7 @@ namespace std
 	}
 
 	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t
-	hash<glm::tquat<T,P>>::operator()(const glm::tquat<T,P> &q) const
+	GLM_FUNC_QUALIFIER size_t hash<glm::tquat<T, P>>::operator()(glm::tquat<T,P> const & q) const
 	{
 		size_t seed = 0;
 		hash<T> hasher;
@@ -109,55 +104,50 @@ namespace std
 	}
 
 	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t
-	hash<glm::tdualquat<T,P>>::operator()(const glm::tdualquat<T,P> &q) const
+	GLM_FUNC_QUALIFIER size_t hash<glm::tdualquat<T, P>>::operator()(glm::tdualquat<T, P> const & q) const
 	{
 		size_t seed = 0;
-		hash<glm::tquat<T,P>> hasher;
+		hash<glm::tquat<T, P>> hasher;
 		glm::detail::hash_combine(seed, hasher(q.real));
 		glm::detail::hash_combine(seed, hasher(q.dual));
 		return seed;
 	}
 
 	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t
-	hash<glm::tmat2x2<T,P>>::operator()(const glm::tmat2x2<T,P> &m) const
+	GLM_FUNC_QUALIFIER size_t hash<glm::tmat2x2<T, P>>::operator()(glm::tmat2x2<T, P> const & m) const
 	{
 		size_t seed = 0;
-		hash<glm::tvec2<T,P>> hasher;
+		hash<glm::tvec2<T, P>> hasher;
 		glm::detail::hash_combine(seed, hasher(m[0]));
 		glm::detail::hash_combine(seed, hasher(m[1]));
 		return seed;
 	}
 
 	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t
-	hash<glm::tmat2x3<T,P>>::operator()(const glm::tmat2x3<T,P> &m) const
+	GLM_FUNC_QUALIFIER size_t hash<glm::tmat2x3<T, P>>::operator()(glm::tmat2x3<T, P> const & m) const
 	{
 		size_t seed = 0;
-		hash<glm::tvec3<T,P>> hasher;
+		hash<glm::tvec3<T, P>> hasher;
 		glm::detail::hash_combine(seed, hasher(m[0]));
 		glm::detail::hash_combine(seed, hasher(m[1]));
 		return seed;
 	}
 
 	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t
-	hash<glm::tmat2x4<T,P>>::operator()(const glm::tmat2x4<T,P> &m) const
+	GLM_FUNC_QUALIFIER size_t hash<glm::tmat2x4<T, P>>::operator()(glm::tmat2x4<T, P> const & m) const
 	{
 		size_t seed = 0;
-		hash<glm::tvec4<T,P>> hasher;
+		hash<glm::tvec4<T, P>> hasher;
 		glm::detail::hash_combine(seed, hasher(m[0]));
 		glm::detail::hash_combine(seed, hasher(m[1]));
 		return seed;
 	}
 
 	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t
-	hash<glm::tmat3x2<T,P>>::operator()(const glm::tmat3x2<T,P> &m) const
+	GLM_FUNC_QUALIFIER size_t hash<glm::tmat3x2<T, P>>::operator()(glm::tmat3x2<T, P> const & m) const
 	{
 		size_t seed = 0;
-		hash<glm::tvec2<T,P>> hasher;
+		hash<glm::tvec2<T, P>> hasher;
 		glm::detail::hash_combine(seed, hasher(m[0]));
 		glm::detail::hash_combine(seed, hasher(m[1]));
 		glm::detail::hash_combine(seed, hasher(m[2]));
@@ -165,11 +155,10 @@ namespace std
 	}
 
 	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t
-	hash<glm::tmat3x3<T,P>>::operator()(const glm::tmat3x3<T,P> &m) const
+	GLM_FUNC_QUALIFIER size_t hash<glm::tmat3x3<T, P>>::operator()(glm::tmat3x3<T, P> const & m) const
 	{
 		size_t seed = 0;
-		hash<glm::tvec3<T,P>> hasher;
+		hash<glm::tvec3<T, P>> hasher;
 		glm::detail::hash_combine(seed, hasher(m[0]));
 		glm::detail::hash_combine(seed, hasher(m[1]));
 		glm::detail::hash_combine(seed, hasher(m[2]));
@@ -177,11 +166,10 @@ namespace std
 	}
 
 	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t
-	hash<glm::tmat3x4<T,P>>::operator()(const glm::tmat3x4<T,P> &m) const
+	GLM_FUNC_QUALIFIER size_t hash<glm::tmat3x4<T, P>>::operator()(glm::tmat3x4<T, P> const & m) const
 	{
 		size_t seed = 0;
-		hash<glm::tvec4<T,P>> hasher;
+		hash<glm::tvec4<T, P>> hasher;
 		glm::detail::hash_combine(seed, hasher(m[0]));
 		glm::detail::hash_combine(seed, hasher(m[1]));
 		glm::detail::hash_combine(seed, hasher(m[2]));
@@ -189,11 +177,10 @@ namespace std
 	}
 
 	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t
-	hash<glm::tmat4x2<T,P>>::operator()(const glm::tmat4x2<T,P> &m) const
+	GLM_FUNC_QUALIFIER size_t hash<glm::tmat4x2<T,P>>::operator()(glm::tmat4x2<T,P> const & m) const
 	{
 		size_t seed = 0;
-		hash<glm::tvec2<T,P>> hasher;
+		hash<glm::tvec2<T, P>> hasher;
 		glm::detail::hash_combine(seed, hasher(m[0]));
 		glm::detail::hash_combine(seed, hasher(m[1]));
 		glm::detail::hash_combine(seed, hasher(m[2]));
@@ -202,11 +189,10 @@ namespace std
 	}
 
 	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t
-	hash<glm::tmat4x3<T,P>>::operator()(const glm::tmat4x3<T,P> &m) const
+	GLM_FUNC_QUALIFIER size_t hash<glm::tmat4x3<T,P>>::operator()(glm::tmat4x3<T,P> const & m) const
 	{
 		size_t seed = 0;
-		hash<glm::tvec3<T,P>> hasher;
+		hash<glm::tvec3<T, P>> hasher;
 		glm::detail::hash_combine(seed, hasher(m[0]));
 		glm::detail::hash_combine(seed, hasher(m[1]));
 		glm::detail::hash_combine(seed, hasher(m[2]));
@@ -215,11 +201,10 @@ namespace std
 	}
 
 	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t
-	hash<glm::tmat4x4<T,P>>::operator()(const glm::tmat4x4<T,P> &m) const
+	GLM_FUNC_QUALIFIER size_t hash<glm::tmat4x4<T,P>>::operator()(glm::tmat4x4<T, P> const & m) const
 	{
 		size_t seed = 0;
-		hash<glm::tvec4<T,P>> hasher;
+		hash<glm::tvec4<T, P>> hasher;
 		glm::detail::hash_combine(seed, hasher(m[0]));
 		glm::detail::hash_combine(seed, hasher(m[1]));
 		glm::detail::hash_combine(seed, hasher(m[2]));