From 7d873302497c1de3e792f22b07e0a8d7c62e59f1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= <mosra@centrum.cz>
Date: Mon, 2 Sep 2013 23:38:02 +0200
Subject: [PATCH] Gaah.

---
 src/Math/RectangularMatrix.h |  4 ++--
 src/Math/Vector.h            | 42 ++++++++++++++++++------------------
 2 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/src/Math/RectangularMatrix.h b/src/Math/RectangularMatrix.h
index c867564ed..901dbb0cd 100644
--- a/src/Math/RectangularMatrix.h
+++ b/src/Math/RectangularMatrix.h
@@ -511,7 +511,7 @@ extern template Corrade::Utility::Debug MAGNUM_EXPORT operator<<(Corrade::Utilit
         return number/static_cast<const Math::RectangularMatrix<size, size, T>&>(matrix); \
     }                                                                       \
     template<std::size_t size, class T> inline __VA_ARGS__ operator*(const Vector<size, T>& vector, const RectangularMatrix<size, 1, T>& matrix) { \
-        return Math::RectangularMatrix<1, size, T>(vector)*matrix; \
+        return Math::RectangularMatrix<1, size, T>(vector)*matrix;          \
     }
 
 #define MAGNUM_MATRIXn_OPERATOR_IMPLEMENTATION(size, Type)                  \
@@ -522,7 +522,7 @@ extern template Corrade::Utility::Debug MAGNUM_EXPORT operator<<(Corrade::Utilit
         return number/static_cast<const Math::RectangularMatrix<size, size, T>&>(matrix); \
     }                                                                       \
     template<class T> inline Type<T> operator*(const Vector<size, T>& vector, const RectangularMatrix<size, 1, T>& matrix) { \
-        return Math::RectangularMatrix<1, size, T>(vector)*matrix; \
+        return Math::RectangularMatrix<1, size, T>(vector)*matrix;          \
     }
 #endif
 
diff --git a/src/Math/Vector.h b/src/Math/Vector.h
index dc5980e0f..e32c41f2d 100644
--- a/src/Math/Vector.h
+++ b/src/Math/Vector.h
@@ -1051,84 +1051,84 @@ extern template Corrade::Utility::Debug MAGNUM_EXPORT operator<<(Corrade::Utilit
 
 #define MAGNUM_VECTORn_OPERATOR_IMPLEMENTATION(size, Type)                  \
     template<class T> inline Type<T> operator*(typename std::common_type<T>::type number, const Type<T>& vector) { \
-        return number*static_cast<const Math::Vector<size, T>&>(vector);          \
+        return number*static_cast<const Math::Vector<size, T>&>(vector);    \
     }                                                                       \
     template<class T> inline Type<T> operator/(typename std::common_type<T>::type number, const Type<T>& vector) { \
-        return number/static_cast<const Math::Vector<size, T>&>(vector);          \
+        return number/static_cast<const Math::Vector<size, T>&>(vector);    \
     }                                                                       \
                                                                             \
     template<class Integral> inline typename std::enable_if<std::is_integral<Integral>::value, Type<Integral>>::type operator~(const Type<Integral>& vector) { \
-        return ~static_cast<const Math::Vector<size, Integral>&>(vector);         \
+        return ~static_cast<const Math::Vector<size, Integral>&>(vector);   \
     }                                                                       \
     template<class Integral> inline typename std::enable_if<std::is_integral<Integral>::value, Type<Integral>&>::type operator&=(Type<Integral>& a, const Math::Vector<size, Integral>& b) { \
-        static_cast<Math::Vector<size, Integral>&>(a) &= b;                       \
+        static_cast<Math::Vector<size, Integral>&>(a) &= b;                 \
         return a;                                                           \
     }                                                                       \
     template<class Integral> inline typename std::enable_if<std::is_integral<Integral>::value, Type<Integral>>::type operator&(const Type<Integral>& a, const Math::Vector<size, Integral>& b) { \
-        return static_cast<const Math::Vector<size, Integral>&>(a) & b;           \
+        return static_cast<const Math::Vector<size, Integral>&>(a) & b;     \
     }                                                                       \
     template<class Integral> inline typename std::enable_if<std::is_integral<Integral>::value, Type<Integral>&>::type operator|=(Type<Integral>& a, const Math::Vector<size, Integral>& b) { \
-        static_cast<Math::Vector<size, Integral>&>(a) |= b;                       \
+        static_cast<Math::Vector<size, Integral>&>(a) |= b;                 \
         return a;                                                           \
     }                                                                       \
     template<class Integral> inline typename std::enable_if<std::is_integral<Integral>::value, Type<Integral>>::type operator|(const Type<Integral>& a, const Math::Vector<size, Integral>& b) { \
-        return static_cast<const Math::Vector<size, Integral>&>(a) | b;           \
+        return static_cast<const Math::Vector<size, Integral>&>(a) | b;     \
     }                                                                       \
     template<class Integral> inline typename std::enable_if<std::is_integral<Integral>::value, Type<Integral>&>::type operator^=(Type<Integral>& a, const Math::Vector<size, Integral>& b) { \
-        static_cast<Math::Vector<size, Integral>&>(a) ^= b;                       \
+        static_cast<Math::Vector<size, Integral>&>(a) ^= b;                 \
         return a;                                                           \
     }                                                                       \
     template<class Integral> inline typename std::enable_if<std::is_integral<Integral>::value, Type<Integral>>::type operator^(const Type<Integral>& a, const Math::Vector<size, Integral>& b) { \
-        return static_cast<const Math::Vector<size, Integral>&>(a) ^ b;           \
+        return static_cast<const Math::Vector<size, Integral>&>(a) ^ b;     \
     }                                                                       \
     template<class Integral> inline typename std::enable_if<std::is_integral<Integral>::value, Type<Integral>&>::type operator<<=(Type<Integral>& vector, typename std::common_type<Integral>::type shift) { \
-        static_cast<Math::Vector<size, Integral>&>(vector) <<= shift;             \
+        static_cast<Math::Vector<size, Integral>&>(vector) <<= shift;       \
         return vector;                                                      \
     }                                                                       \
     template<class Integral> inline typename std::enable_if<std::is_integral<Integral>::value, Type<Integral>>::type operator<<(const Type<Integral>& vector, typename std::common_type<Integral>::type shift) { \
         return static_cast<const Math::Vector<size, Integral>&>(vector) << shift; \
     }                                                                       \
     template<class Integral> inline typename std::enable_if<std::is_integral<Integral>::value, Type<Integral>&>::type operator>>=(Type<Integral>& vector, typename std::common_type<Integral>::type shift) { \
-        static_cast<Math::Vector<size, Integral>&>(vector) >>= shift;             \
+        static_cast<Math::Vector<size, Integral>&>(vector) >>= shift;       \
         return vector;                                                      \
     }                                                                       \
     template<class Integral> inline typename std::enable_if<std::is_integral<Integral>::value, Type<Integral>>::type operator>>(const Type<Integral>& vector, typename std::common_type<Integral>::type shift) { \
         return static_cast<const Math::Vector<size, Integral>&>(vector) >> shift; \
     }                                                                       \
     template<class Integral, class FloatingPoint> inline typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type<Integral>&>::type operator*=(Type<Integral>& vector, FloatingPoint number) { \
-        static_cast<Math::Vector<size, Integral>&>(vector) *= number;             \
+        static_cast<Math::Vector<size, Integral>&>(vector) *= number;       \
         return vector;                                                      \
     }                                                                       \
     template<class Integral, class FloatingPoint> inline typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type<Integral>>::type operator*(const Type<Integral>& vector, FloatingPoint number) { \
-        return static_cast<const Math::Vector<size, Integral>&>(vector)*number;   \
+        return static_cast<const Math::Vector<size, Integral>&>(vector)*number; \
     }                                                                       \
     template<class FloatingPoint, class Integral> inline typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type<Integral>>::type operator*(FloatingPoint number, const Type<Integral>& vector) { \
-        return number*static_cast<const Math::Vector<size, Integral>&>(vector);   \
+        return number*static_cast<const Math::Vector<size, Integral>&>(vector); \
     }                                                                       \
     template<class Integral, class FloatingPoint> inline typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type<Integral>&>::type operator/=(Type<Integral>& vector, FloatingPoint number) { \
-        static_cast<Math::Vector<size, Integral>&>(vector) /= number;             \
+        static_cast<Math::Vector<size, Integral>&>(vector) /= number;       \
         return vector;                                                      \
     }                                                                       \
     template<class Integral, class FloatingPoint> inline typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type<Integral>>::type operator/(const Type<Integral>& vector, FloatingPoint number) { \
-        return static_cast<const Math::Vector<size, Integral>&>(vector)/number;   \
+        return static_cast<const Math::Vector<size, Integral>&>(vector)/number; \
     }                                                                       \
                                                                             \
     template<class Integral, class FloatingPoint> inline typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type<Integral>&>::type operator*=(Type<Integral>& a, const Math::Vector<size, FloatingPoint>& b) { \
-        static_cast<Math::Vector<size, Integral>&>(a) *= b;                       \
+        static_cast<Math::Vector<size, Integral>&>(a) *= b;                 \
         return a;                                                           \
     }                                                                       \
     template<class Integral, class FloatingPoint> inline typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type<Integral>>::type operator*(const Type<Integral>& a, const Math::Vector<size, FloatingPoint>& b) { \
-        return static_cast<const Math::Vector<size, Integral>&>(a)*b;             \
+        return static_cast<const Math::Vector<size, Integral>&>(a)*b;       \
     }                                                                       \
     template<class FloatingPoint, class Integral> inline typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type<Integral>>::type operator*(const Math::Vector<size, FloatingPoint>& a, const Type<Integral>& b) { \
-        return a*static_cast<const Math::Vector<size, Integral>&>(b);             \
+        return a*static_cast<const Math::Vector<size, Integral>&>(b);       \
     }                                                                       \
     template<class Integral, class FloatingPoint> inline typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type<Integral>&>::type operator/=(Type<Integral>& a, const Math::Vector<size, FloatingPoint>& b) { \
-        static_cast<Math::Vector<size, Integral>&>(a) /= b;                       \
+        static_cast<Math::Vector<size, Integral>&>(a) /= b;                 \
         return a;                                                           \
     }                                                                       \
     template<class Integral, class FloatingPoint> inline typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type<Integral>>::type operator/(const Type<Integral>& a, const Math::Vector<size, FloatingPoint>& b) { \
-        return static_cast<const Math::Vector<size, Integral>&>(a)/b;             \
+        return static_cast<const Math::Vector<size, Integral>&>(a)/b;       \
     }
 #endif