Merge pull request #577 from tkoeppe/space

Whitespace fixes around punctuators (library)

Author: jwakely

source/containers.tex

@@ -2440,9 +2440,9 @@
   template <class T> class tuple_size;
   template <size_t I, class T> class tuple_element;
   template <class T, size_t N>
-    struct tuple_size<array<T, N> >;
+    struct tuple_size<array<T, N>>;
   template <size_t I, class T, size_t N>
-    struct tuple_element<I, array<T, N> >;
+    struct tuple_element<I, array<T, N>>;
   template <size_t I, class T, size_t N>
     constexpr T& get(array<T, N>&) noexcept;
   template <size_t I, class T, size_t N>
@@ -2463,7 +2463,7 @@
 
 namespace std {
   // \ref{deque}, class template deque:
-  template <class T, class Allocator = allocator<T> > class deque;
+  template <class T, class Allocator = allocator<T>> class deque;
   template <class T, class Allocator>
     bool operator==(const deque<T, Allocator>& x, const deque<T, Allocator>& y);
   template <class T, class Allocator>
@@ -2491,7 +2491,7 @@
 
 namespace std {
   // \ref{forwardlist}, class template forward_list:
-  template <class T, class Allocator = allocator<T> > class forward_list;
+  template <class T, class Allocator = allocator<T>> class forward_list;
   template <class T, class Allocator>
     bool operator==(const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y);
   template <class T, class Allocator>
@@ -2519,7 +2519,7 @@
 
 namespace std {
   // \ref{list}, class template list:
-  template <class T, class Allocator = allocator<T> > class list;
+  template <class T, class Allocator = allocator<T>> class list;
   template <class T, class Allocator>
     bool operator==(const list<T, Allocator>& x, const list<T, Allocator>& y);
   template <class T, class Allocator>
@@ -2547,7 +2547,7 @@
 
 namespace std {
   // \ref{vector}, class template vector:
-  template <class T, class Allocator = allocator<T> > class vector;
+  template <class T, class Allocator = allocator<T>> class vector;
   template <class T, class Allocator>
     bool operator==(const vector<T, Allocator>& x, const vector<T, Allocator>& y);
   template <class T, class Allocator>
@@ -2569,7 +2569,7 @@
 
   // hash support
   template <class T> struct hash;
-  template <class Allocator> struct hash<vector<bool, Allocator> >;
+  template <class Allocator> struct hash<vector<bool, Allocator>>;
 }
 \end{codeblock}
 
@@ -2804,7 +2804,7 @@
 
 \indexlibrary{\idxcode{tuple_element}}%
 \begin{itemdecl}
-tuple_element<I, array<T, N> >::type
+tuple_element<I, array<T, N>>::type
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -5319,7 +5319,7 @@
 \end{itemdescr}
 
 \begin{itemdecl}
-template <class Allocator> struct hash<vector<bool, Allocator> >;
+template <class Allocator> struct hash<vector<bool, Allocator>>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -5346,7 +5346,7 @@
 namespace std {
   // \ref{map}, class template map:
   template <class Key, class T, class Compare = less<Key>,
-            class Allocator = allocator<pair<const Key, T> > >
+            class Allocator = allocator<pair<const Key, T>>>
     class map;
   template <class Key, class T, class Compare, class Allocator>
     bool operator==(const map<Key, T, Compare, Allocator>& x,
@@ -5373,7 +5373,7 @@
 
   // \ref{multimap}, class template multimap:
   template <class Key, class T, class Compare = less<Key>,
-            class Allocator = allocator<pair<const Key, T> > >
+            class Allocator = allocator<pair<const Key, T>>>
     class multimap;
   template <class Key, class T, class Compare, class Allocator>
     bool operator==(const multimap<Key, T, Compare, Allocator>& x,
@@ -5409,7 +5409,7 @@
 namespace std {
   // \ref{set}, class template set:
   template <class Key, class Compare = less<Key>,
-            class Allocator = allocator<Key> >
+            class Allocator = allocator<Key>>
     class set;
   template <class Key, class Compare, class Allocator>
     bool operator==(const set<Key, Compare, Allocator>& x,
@@ -5436,7 +5436,7 @@
 
   // \ref{set}, class template multiset:
   template <class Key, class Compare = less<Key>,
-            class Allocator = allocator<Key> >
+            class Allocator = allocator<Key>>
     class multiset;
   template <class Key, class Compare, class Allocator>
     bool operator==(const multiset<Key, Compare, Allocator>& x,
@@ -6823,15 +6823,15 @@
             class T,
             class Hash = hash<Key>,
             class Pred = std::equal_to<Key>,
-            class Alloc = std::allocator<std::pair<const Key, T> > >
+            class Alloc = std::allocator<std::pair<const Key, T>>>
     class unordered_map;
 
   // \ref{unord.multimap}, class template unordered_multimap:
   template <class Key,
             class T,
             class Hash = hash<Key>,
             class Pred = std::equal_to<Key>,
-            class Alloc = std::allocator<std::pair<const Key, T> > >
+            class Alloc = std::allocator<std::pair<const Key, T>>>
     class unordered_multimap;
 
   template <class Key, class T, class Hash, class Pred, class Alloc>
@@ -6871,14 +6871,14 @@
   template <class Key,
             class Hash = hash<Key>,
             class Pred = std::equal_to<Key>,
-            class Alloc = std::allocator<Key> >
+            class Alloc = std::allocator<Key>>
     class unordered_set;
 
   // \ref{unord.multiset}, class template unordered_multiset:
   template <class Key,
             class Hash = hash<Key>,
             class Pred = std::equal_to<Key>,
-            class Alloc = std::allocator<Key> >
+            class Alloc = std::allocator<Key>>
     class unordered_multiset;
 
   template <class Key, class Hash, class Pred, class Alloc>
@@ -8221,9 +8221,9 @@
 #include <initializer_list>
 
 namespace std {
-  template <class T, class Container = deque<T> > class queue;
+  template <class T, class Container = deque<T>> class queue;
   template <class T, class Container = vector<T>,
-            class Compare = less<typename Container::value_type> >
+            class Compare = less<typename Container::value_type>>
     class priority_queue;
 
   template <class T, class Container>
@@ -8254,7 +8254,7 @@
 #include <initializer_list>
 
 namespace std {
-  template <class T, class Container = deque<T> > class stack;
+  template <class T, class Container = deque<T>> class stack;
   template <class T, class Container>
     bool operator==(const stack<T, Container>& x, const stack<T, Container>& y);
   template <class T, class Container>

source/diagnostics.tex

@@ -1118,8 +1118,8 @@
   bool operator<(const error_code& lhs, const error_code& rhs) noexcept;
 
   template <class charT, class traits>
-    basic_ostream<charT,traits>&
-      operator<<(basic_ostream<charT,traits>& os, const error_code& ec);
+    basic_ostream<charT, traits>&
+      operator<<(basic_ostream<charT, traits>& os, const error_code& ec);
 }   // namespace std
 \end{codeblock}
 
@@ -1300,8 +1300,8 @@
 \indexlibrary{\idxcode{error_code}!\idxcode{operator\shl}}%
 \begin{itemdecl}
 template <class charT, class traits>
-  basic_ostream<charT,traits>&
-    operator<<(basic_ostream<charT,traits>& os, const error_code& ec);
+  basic_ostream<charT, traits>&
+    operator<<(basic_ostream<charT, traits>& os, const error_code& ec);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -1332,7 +1332,7 @@
 
     // \ref{syserr.errcondition.modifiers} modifiers:
     void assign(int val, const error_category& cat) noexcept;
-    template<class ErrorConditionEnum>
+    template <class ErrorConditionEnum>
         error_condition& operator=(ErrorConditionEnum e) noexcept;
     void clear() noexcept;