Whitespace

source/app/maths/line.h

@@ -24,7 +24,7 @@
 
 #include <utility>
 
-template <typename Vector> class Line
+template<typename Vector> class Line
 {
 private:
     Vector _start;

source/shared/utils/container_combine.h

@@ -6,20 +6,20 @@
 
 namespace u
 {
-template <typename... Containers>
+template<typename... Containers>
 class combine
 {
 private:
-    template <typename T>
+    template<typename T>
     using ContainerIterator = decltype(std::cbegin(std::declval<T&>()));
 
-    template <typename T>
+    template<typename T>
     using ContainerIteratorPair = std::pair<ContainerIterator<T>, ContainerIterator<T>>;
 
-    template <typename>
+    template<typename>
     struct iterator_pairs {};
 
-    template <typename... Ts>
+    template<typename... Ts>
     struct iterator_pairs<std::tuple<Ts...>>
     {
         using type = std::tuple<ContainerIteratorPair<Ts>...>;

source/shared/utils/function_traits.h

@@ -24,13 +24,13 @@
 
 // http://stackoverflow.com/questions/7943525/
 
-template <typename T>
+template<typename T>
 struct function_traits
     : public function_traits<decltype(&T::operator())>
 {};
 // For generic types, directly use the result of the signature of its 'operator()'
 
-template <typename ReturnType, typename... Args>
+template<typename ReturnType, typename... Args>
 struct _function_traits
 // we specialize for pointers to member function
 {
@@ -39,7 +39,7 @@ struct _function_traits
 
     using result_type = ReturnType;
 
-    template <size_t i>
+    template<size_t i>
     struct arg
     {
         using type = typename std::tuple_element<i, std::tuple<Args...>>::type;
@@ -48,12 +48,12 @@ struct _function_traits
     };
 };
 
-template <typename ClassType, typename ReturnType, typename... Args>
+template<typename ClassType, typename ReturnType, typename... Args>
 struct function_traits<ReturnType(ClassType::*)(Args...) const> :
     public _function_traits<ReturnType, Args...>
 {};
 
-template <typename ClassType, typename ReturnType, typename... Args>
+template<typename ClassType, typename ReturnType, typename... Args>
 struct function_traits<ReturnType(ClassType::*)(Args...)> :
     public _function_traits<ReturnType, Args...>
 {};

source/shared/utils/is_detected.h

@@ -25,14 +25,14 @@ namespace std::experimental{ // NOLINT cert-dcl58-cpp
 
 // Copy and pasted from https://en.cppreference.com/w/cpp/experimental/is_detected
 namespace detail {
-template <class Default, class AlwaysVoid,
+template<class Default, class AlwaysVoid,
           template<class...> class Op, class... Args>
 struct detector {
   using value_t = std::false_type;
   using type = Default;
 };
 
-template <class Default, template<class...> class Op, class... Args>
+template<class Default, template<class...> class Op, class... Args>
 struct detector<Default, std::void_t<Op<Args...>>, Op, Args...> {
   // Note that std::void_t is a C++17 feature
   using value_t = std::true_type;
@@ -47,13 +47,13 @@ struct nonesuch {
     void operator=(nonesuch const&) = delete;
 };
 
-template <template<class...> class Op, class... Args>
+template<template<class...> class Op, class... Args>
 using is_detected = typename detail::detector<nonesuch, void, Op, Args...>::value_t;
 
-template <template<class...> class Op, class... Args>
+template<template<class...> class Op, class... Args>
 using detected_t = typename detail::detector<nonesuch, void, Op, Args...>::type;
 
-template <class Default, template<class...> class Op, class... Args>
+template<class Default, template<class...> class Op, class... Args>
 using detected_or = detail::detector<Default, void, Op, Args...>;
 
 template< template<class...> class Op, class... Args >
@@ -62,16 +62,16 @@ constexpr bool is_detected_v = is_detected<Op, Args...>::value;
 template< class Default, template<class...> class Op, class... Args >
 using detected_or_t = typename detected_or<Default, Op, Args...>::type;
 
-template <class Expected, template<class...> class Op, class... Args>
+template<class Expected, template<class...> class Op, class... Args>
 using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
 
-template <class Expected, template<class...> class Op, class... Args>
+template<class Expected, template<class...> class Op, class... Args>
 constexpr bool is_detected_exact_v = is_detected_exact<Expected, Op, Args...>::value;
 
-template <class To, template<class...> class Op, class... Args>
+template<class To, template<class...> class Op, class... Args>
 using is_detected_convertible = std::is_convertible<detected_t<Op, Args...>, To>;
 
-template <class To, template<class...> class Op, class... Args>
+template<class To, template<class...> class Op, class... Args>
 constexpr bool is_detected_convertible_v = is_detected_convertible<To, Op, Args...>::value;
 
 } // namespace std::experimental

source/shared/utils/movablepointer.h

@@ -27,7 +27,7 @@
 template<typename T> class MovablePointer : private std::unique_ptr<T>
 {
 public:
-    template <typename... Args> explicit MovablePointer(Args... args) :
+    template<typename... Args> explicit MovablePointer(Args... args) :
         std::unique_ptr<T>(std::make_unique<T>(std::forward<Args>(args)...))
     {}
 

source/shared/utils/namedbool.h

@@ -21,7 +21,7 @@
 
 #include <cstddef>
 
-template <std::size_t N>
+template<std::size_t N>
 struct String
 {
     char _data[N] = {0};
@@ -34,7 +34,7 @@ struct String
     }
 };
 
-template <String string>
+template<String string>
 class NamedBool
 {
 private:
@@ -50,25 +50,25 @@ class NamedBool
     constexpr explicit operator bool() const { return _value; }
 };
 
-template <String string>
+template<String string>
 consteval auto operator""_true()
 {
     return NamedBool<string>(true);
 }
 
-template <String string>
+template<String string>
 consteval auto operator""_false()
 {
     return NamedBool<string>(false);
 }
 
-template <String string>
+template<String string>
 consteval auto operator""_yes()
 {
     return NamedBool<string>(true);
 }
 
-template <String string>
+template<String string>
 consteval auto operator""_no()
 {
     return NamedBool<string>(false);

source/shared/utils/scope_exit.h

@@ -25,7 +25,7 @@
 
 // modeled slightly after Andrescu’s talk and article(s)
 namespace std::experimental{ // NOLINT cert-dcl58-cpp
-template <typename EF>
+template<typename EF>
 struct scope_exit {
     // construction
     explicit
@@ -53,7 +53,7 @@ struct scope_exit {
     EF exit_function;
     bool execute_on_destruction = false; // exposition only
 };
-template <typename EF>
+template<typename EF>
 auto make_scope_exit(EF &&exit_function) noexcept {
     return scope_exit<std::remove_reference_t<EF>>(std::forward<EF>(exit_function));
 }