[lib] Harmonize spacing for template headers.

Use 'template<class T>'.
Also remove space between two closing template brackets.

Author: jensmaurer

source/algorithms.tex

@@ -1890,7 +1890,7 @@
                   ForwardIterator2 first2, ForwardIterator2 last2);
 
 template<class InputIterator, class ForwardIterator,
-          class BinaryPredicate>
+         class BinaryPredicate>
   constexpr InputIterator
     find_first_of(InputIterator first1, InputIterator last1,
                   ForwardIterator first2, ForwardIterator last2,

source/atomics.tex

@@ -33,7 +33,7 @@
 namespace std {
   // \ref{atomics.order}, order and consistency
   enum class memory_order : @\unspec@;
-  template <class T>
+  template<class T>
     T kill_dependency(T y) noexcept;
 
   // \ref{atomics.lockfree}, lock-free property
@@ -127,54 +127,54 @@
                                                  typename atomic<T>::value_type,
                                                  memory_order, memory_order) noexcept;
 
-  template <class T>
+  template<class T>
     T atomic_fetch_add(volatile atomic<T>*, typename atomic<T>::difference_type) noexcept;
-  template <class T>
+  template<class T>
     T atomic_fetch_add(atomic<T>*, typename atomic<T>::difference_type) noexcept;
-  template <class T>
+  template<class T>
     T atomic_fetch_add_explicit(volatile atomic<T>*, typename atomic<T>::difference_type,
                                 memory_order) noexcept;
-  template <class T>
+  template<class T>
     T atomic_fetch_add_explicit(atomic<T>*, typename atomic<T>::difference_type,
                                 memory_order) noexcept;
-  template <class T>
+  template<class T>
     T atomic_fetch_sub(volatile atomic<T>*, typename atomic<T>::difference_type) noexcept;
-  template <class T>
+  template<class T>
     T atomic_fetch_sub(atomic<T>*, typename atomic<T>::difference_type) noexcept;
-  template <class T>
+  template<class T>
     T atomic_fetch_sub_explicit(volatile atomic<T>*, typename atomic<T>::difference_type,
                                 memory_order) noexcept;
-  template <class T>
+  template<class T>
     T atomic_fetch_sub_explicit(atomic<T>*, typename atomic<T>::difference_type,
                                 memory_order) noexcept;
-  template <class T>
+  template<class T>
     T atomic_fetch_and(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
-  template <class T>
+  template<class T>
     T atomic_fetch_and(atomic<T>*, typename atomic<T>::value_type) noexcept;
-  template <class T>
+  template<class T>
     T atomic_fetch_and_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
                                 memory_order) noexcept;
-  template <class T>
+  template<class T>
     T atomic_fetch_and_explicit(atomic<T>*, typename atomic<T>::value_type,
                                 memory_order) noexcept;
-  template <class T>
+  template<class T>
     T atomic_fetch_or(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
-  template <class T>
+  template<class T>
     T atomic_fetch_or(atomic<T>*, typename atomic<T>::value_type) noexcept;
-  template <class T>
+  template<class T>
     T atomic_fetch_or_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
                                memory_order) noexcept;
-  template <class T>
+  template<class T>
     T atomic_fetch_or_explicit(atomic<T>*, typename atomic<T>::value_type,
                                memory_order) noexcept;
-  template <class T>
+  template<class T>
     T atomic_fetch_xor(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
-  template <class T>
+  template<class T>
     T atomic_fetch_xor(atomic<T>*, typename atomic<T>::value_type) noexcept;
-  template <class T>
+  template<class T>
     T atomic_fetch_xor_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
                                 memory_order) noexcept;
-  template <class T>
+  template<class T>
     T atomic_fetch_xor_explicit(atomic<T>*, typename atomic<T>::value_type,
                                 memory_order) noexcept;
 
@@ -493,7 +493,7 @@
 
 \indexlibrary{\idxcode{kill_dependency}}%
 \begin{itemdecl}
-template <class T>
+template<class T>
   T kill_dependency(T y) noexcept;
 \end{itemdecl}
 
@@ -565,7 +565,7 @@
 \indexlibrarymember{value_type}{atomic}%
 \begin{codeblock}
 namespace std {
-  template <class T> struct atomic {
+  template<class T> struct atomic {
     using value_type = T;
     static constexpr bool is_always_lock_free = @\impdefx{whether a given \tcode{atomic} type's operations are always lock free}@;
     bool is_lock_free() const volatile noexcept;
@@ -963,7 +963,7 @@
 
 \begin{codeblock}
 namespace std {
-  template <> struct atomic<@\placeholder{integral}@> {
+  template<> struct atomic<@\placeholder{integral}@> {
     using value_type = @\placeholder{integral}@;
     using difference_type = value_type;
     static constexpr bool is_always_lock_free = @\impdefx{whether a given \tcode{atomic} type's operations are always lock free}@;
@@ -1278,7 +1278,7 @@
 
 \begin{codeblock}
 namespace std {
-  template <class T> struct atomic<T*> {
+  template<class T> struct atomic<T*> {
     using value_type = T*;
     using difference_type = ptrdiff_t;
     static constexpr bool is_always_lock_free = @\impdefx{whether a given \tcode{atomic} type's operations are always lock free}@;