[containers] Minor whitespace and ordering improvements

Author: tkoeppe

source/containers.tex

@@ -2942,7 +2942,7 @@
     iterator insert(const_iterator position, T&& x);
     iterator insert(const_iterator position, size_type n, const T& x);
     template <class InputIterator>
-      iterator insert (const_iterator position, InputIterator first, InputIterator last);
+      iterator insert(const_iterator position, InputIterator first, InputIterator last);
     iterator insert(const_iterator position, initializer_list<T>);
 
     void pop_front();
@@ -3295,7 +3295,7 @@
     const_iterator cend() const noexcept;
 
     // capacity:
-    bool empty() const noexcept;
+    bool      empty() const noexcept;
     size_type max_size() const noexcept;
 
     // \ref{forwardlist.access}, element access:
@@ -5218,7 +5218,7 @@
     void pop_back();
     template <class... Args> iterator emplace(const_iterator position, Args&&... args);
     iterator insert(const_iterator position, const bool& x);
-    iterator insert (const_iterator position, size_type n, const bool& x);
+    iterator insert(const_iterator position, size_type n, const bool& x);
     template <class InputIterator>
       iterator insert(const_iterator position,
                       InputIterator first, InputIterator last);
@@ -7029,17 +7029,17 @@
     void reserve(size_type n);
   };
 
-  template <class Key, class T, class Hash, class Pred, class Alloc>
-    void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
-              unordered_map<Key, T, Hash, Pred, Alloc>& y)
-      noexcept(noexcept(x.swap(y)));
-
   template <class Key, class T, class Hash, class Pred, class Alloc>
     bool operator==(const unordered_map<Key, T, Hash, Pred, Alloc>& a,
                     const unordered_map<Key, T, Hash, Pred, Alloc>& b);
   template <class Key, class T, class Hash, class Pred, class Alloc>
     bool operator!=(const unordered_map<Key, T, Hash, Pred, Alloc>& a,
                     const unordered_map<Key, T, Hash, Pred, Alloc>& b);
+
+  template <class Key, class T, class Hash, class Pred, class Alloc>
+    void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
+              unordered_map<Key, T, Hash, Pred, Alloc>& y)
+      noexcept(noexcept(x.swap(y)));
 }
 \end{codeblock}
 
@@ -7435,17 +7435,18 @@
     void reserve(size_type n);
   };
 
-  template <class Key, class T, class Hash, class Pred, class Alloc>
-    void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
-              unordered_multimap<Key, T, Hash, Pred, Alloc>& y)
-      noexcept(noexcept(x.swap(y)));
-
   template <class Key, class T, class Hash, class Pred, class Alloc>
     bool operator==(const unordered_multimap<Key, T, Hash, Pred, Alloc>& a,
                     const unordered_multimap<Key, T, Hash, Pred, Alloc>& b);
   template <class Key, class T, class Hash, class Pred, class Alloc>
     bool operator!=(const unordered_multimap<Key, T, Hash, Pred, Alloc>& a,
                     const unordered_multimap<Key, T, Hash, Pred, Alloc>& b);
+
+  template <class Key, class T, class Hash, class Pred, class Alloc>
+    void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
+              unordered_multimap<Key, T, Hash, Pred, Alloc>& y)
+      noexcept(noexcept(x.swap(y)));
+
 }
 \end{codeblock}
 
@@ -7716,17 +7717,17 @@
     void reserve(size_type n);
   };
 
-  template <class Key, class Hash, class Pred, class Alloc>
-    void swap(unordered_set<Key, Hash, Pred, Alloc>& x,
-              unordered_set<Key, Hash, Pred, Alloc>& y)
-      noexcept(noexcept(x.swap(y)));
-
   template <class Key, class Hash, class Pred, class Alloc>
     bool operator==(const unordered_set<Key, Hash, Pred, Alloc>& a,
                     const unordered_set<Key, Hash, Pred, Alloc>& b);
   template <class Key, class Hash, class Pred, class Alloc>
     bool operator!=(const unordered_set<Key, Hash, Pred, Alloc>& a,
                     const unordered_set<Key, Hash, Pred, Alloc>& b);
+
+  template <class Key, class Hash, class Pred, class Alloc>
+    void swap(unordered_set<Key, Hash, Pred, Alloc>& x,
+              unordered_set<Key, Hash, Pred, Alloc>& y)
+      noexcept(noexcept(x.swap(y)));
 }
 \end{codeblock}
 
@@ -7967,17 +7968,17 @@
     void reserve(size_type n);
   };
 
-  template <class Key, class Hash, class Pred, class Alloc>
-    void swap(unordered_multiset<Key, Hash, Pred, Alloc>& x,
-              unordered_multiset<Key, Hash, Pred, Alloc>& y)
-      noexcept(noexcept(x.swap(y)));
-
   template <class Key, class Hash, class Pred, class Alloc>
     bool operator==(const unordered_multiset<Key, Hash, Pred, Alloc>& a,
                     const unordered_multiset<Key, Hash, Pred, Alloc>& b);
   template <class Key, class Hash, class Pred, class Alloc>
     bool operator!=(const unordered_multiset<Key, Hash, Pred, Alloc>& a,
                     const unordered_multiset<Key, Hash, Pred, Alloc>& b);
+
+  template <class Key, class Hash, class Pred, class Alloc>
+    void swap(unordered_multiset<Key, Hash, Pred, Alloc>& x,
+              unordered_multiset<Key, Hash, Pred, Alloc>& y)
+      noexcept(noexcept(x.swap(y)));
 }
 \end{codeblock}
 
@@ -8431,10 +8432,8 @@
 
 \indexlibrary{\idxcode{priority_queue}!\idxcode{priority_queue}}%
 \begin{itemdecl}
-priority_queue(const Compare& x,
-               const Container& y);
-explicit priority_queue(const Compare& x = Compare(),
-               Container&& y = Container());
+priority_queue(const Compare& x, const Container& y);
+explicit priority_queue(const Compare& x = Compare(), Container&& y = Container());
 \end{itemdecl}
 
 \begin{itemdescr}