[flat.multiset] P2767R0 section 3 as seen by LWG

Modified to resolve the merge conflict with LWG3884 (03da5ba).

Author: Quuxplusone

source/containers.tex

@@ -17620,83 +17620,85 @@
     // \ref{flat.multiset.cons}, constructors
     flat_multiset() : flat_multiset(key_compare()) { }
 
-    template<class Allocator>
-      flat_multiset(const flat_multiset&, const Allocator& a);
-    template<class Allocator>
-      flat_multiset(flat_multiset&&, const Allocator& a);
-
     explicit flat_multiset(container_type cont, const key_compare& comp = key_compare());
-    template<class Allocator>
-      flat_multiset(const container_type& cont, const Allocator& a);
-    template<class Allocator>
-      flat_multiset(const container_type& cont, const key_compare& comp, const Allocator& a);
 
     flat_multiset(sorted_equivalent_t, container_type cont,
                   const key_compare& comp = key_compare())
       : @\exposid{c}@(std::move(cont)), @\exposid{compare}@(comp) { }
-    template<class Allocator>
-      flat_multiset(sorted_equivalent_t, const container_type& cont, const Allocator& a);
-    template<class Allocator>
-      flat_multiset(sorted_equivalent_t, const container_type& cont,
-                    const key_compare& comp, const Allocator& a);
 
     explicit flat_multiset(const key_compare& comp)
       : @\exposid{c}@(), @\exposid{compare}@(comp) { }
-    template<class Allocator>
-      flat_multiset(const key_compare& comp, const Allocator& a);
-    template<class Allocator>
-      explicit flat_multiset(const Allocator& a);
 
     template<class InputIterator>
       flat_multiset(InputIterator first, InputIterator last,
                     const key_compare& comp = key_compare())
         : @\exposid{c}@(), @\exposid{compare}@(comp)
         { insert(first, last); }
-    template<class InputIterator, class Allocator>
-      flat_multiset(InputIterator first, InputIterator last,
-                    const key_compare& comp, const Allocator& a);
-    template<class InputIterator, class Allocator>
-      flat_multiset(InputIterator first, InputIterator last, const Allocator& a);
 
     template<@\exposconcept{container-compatible-range}@<value_type> R>
       flat_multiset(from_range_t fr, R&& rg)
         : flat_multiset(fr, std::forward<R>(rg), key_compare()) { }
-    template<@\exposconcept{container-compatible-range}@<value_type> R, class Allocator>
-      flat_multiset(from_range_t, R&& rg, const Allocator& a);
     template<@\exposconcept{container-compatible-range}@<value_type> R>
       flat_multiset(from_range_t, R&& rg, const key_compare& comp)
         : flat_multiset(comp)
         { insert_range(std::forward<R>(rg)); }
-    template<@\exposconcept{container-compatible-range}@<value_type> R, class Allocator>
-      flat_multiset(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
 
     template<class InputIterator>
       flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
                     const key_compare& comp = key_compare())
         : @\exposid{c}@(first, last), @\exposid{compare}@(comp) { }
-    template<class InputIterator, class Allocator>
-      flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
-                    const key_compare& comp, const Allocator& a);
-    template<class InputIterator, class Allocator>
-      flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
-                    const Allocator& a);
 
     flat_multiset(initializer_list<value_type> il, const key_compare& comp = key_compare())
       : flat_multiset(il.begin(), il.end(), comp) { }
-    template<class Allocator>
-      flat_multiset(initializer_list<value_type> il, const key_compare& comp,
-                    const Allocator& a);
-    template<class Allocator>
-      flat_multiset(initializer_list<value_type> il, const Allocator& a);
 
     flat_multiset(sorted_equivalent_t s, initializer_list<value_type> il,
                   const key_compare& comp = key_compare())
         : flat_multiset(s, il.begin(), il.end(), comp) { }
-    template<class Allocator>
+
+    // \ref{flat.multiset.cons.alloc}, constructors with allocators
+
+    template<class Alloc>
+      flat_multiset(const flat_multiset&, const Alloc& a);
+    template<class Alloc>
+      flat_multiset(flat_multiset&&, const Alloc& a);
+    template<class Alloc>
+      flat_multiset(const container_type& cont, const Alloc& a);
+    template<class Alloc>
+      flat_multiset(const container_type& cont, const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      flat_multiset(sorted_equivalent_t, const container_type&, const Alloc& a);
+    template<class Alloc>
+      flat_multiset(sorted_equivalent_t, const container_type& cont,
+                    const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      flat_multiset(const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      explicit flat_multiset(const Alloc& a);
+    template<class InputIterator, class Alloc>
+      flat_multiset(InputIterator first, InputIterator last,
+                    const key_compare& comp, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      flat_multiset(InputIterator first, InputIterator last, const Alloc& a);
+    template<@\exposconcept{container-compatible-range}@<value_type> R, class Alloc>
+      flat_multiset(from_range_t, R&& rg, const Alloc& a);
+    template<@\exposconcept{container-compatible-range}@<value_type> R, class Alloc>
+      flat_multiset(from_range_t, R&& rg, const key_compare& comp, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
+                    const key_compare& comp, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
+                    const Alloc& a);
+    template<class Alloc>
+      flat_multiset(initializer_list<value_type> il, const key_compare& comp,
+                    const Alloc& a);
+    template<class Alloc>
+      flat_multiset(initializer_list<value_type> il, const Alloc& a);
+    template<class Alloc>
       flat_multiset(sorted_equivalent_t, initializer_list<value_type> il,
-                    const key_compare& comp, const Allocator& a);
-    template<class Allocator>
-      flat_multiset(sorted_equivalent_t, initializer_list<value_type> il, const Allocator& a);
+                    const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      flat_multiset(sorted_equivalent_t, initializer_list<value_type> il, const Alloc& a);
 
     flat_multiset& operator=(initializer_list<value_type>);
 
@@ -17878,23 +17880,25 @@
 
 \pnum
 \complexity
-Linear in $N$ if \tcode{cont} is sorted with respect to \exposid{compare} and
+Linear in $N$ if \tcode{cont} is already sorted with respect to \exposid{compare} and
 otherwise $N \log N$, where $N$ is the value of \tcode{cont.size()} before this call.
 \end{itemdescr}
 
+\rSec3[flat.multiset.cons.alloc]{Constructors with allocators}
+
+\pnum
+The constructors in this subclause shall not participate in overload resolution
+unless \tcode{uses_allocator_v<container_type, Alloc>} is \tcode{true}.
+
 \indexlibraryctor{flat_multiset}%
 \begin{itemdecl}
-template<class Allocator>
-  flat_multiset(const container_type& cont, const Allocator& a);
-template<class Allocator>
-  flat_multiset(const container_type& cont, const key_compare& comp, const Allocator& a);
+template<class Alloc>
+  flat_multiset(const container_type& cont, const Alloc& a);
+template<class Alloc>
+  flat_multiset(const container_type& cont, const key_compare& comp, const Alloc& a);
 \end{itemdecl}
 
 \begin{itemdescr}
-\pnum
-\constraints
-\tcode{uses_allocator_v<container_type, Allocator>} is \tcode{true}.
-
 \pnum
 \effects
 Equivalent to \tcode{flat_multiset(cont)} and
@@ -17910,18 +17914,14 @@
 
 \indexlibraryctor{flat_multiset}%
 \begin{itemdecl}
-template<class Allocator>
-  flat_multiset(sorted_equivalent_t s, const container_type& cont, const Allocator& a);
-template<class Allocator>
+template<class Alloc>
+  flat_multiset(sorted_equivalent_t s, const container_type& cont, const Alloc& a);
+template<class Alloc>
   flat_multiset(sorted_equivalent_t s, const container_type& cont,
                 const key_compare& comp, const Allocator& a);
 \end{itemdecl}
 
 \begin{itemdescr}
-\pnum
-\constraints
-\tcode{uses_allocator_v<container_type, Allocator>} is \tcode{true}.
-
 \pnum
 \effects
 Equivalent to \tcode{flat_multiset(s, cont)} and
@@ -17936,44 +17936,40 @@
 
 \indexlibraryctor{flat_multiset}%
 \begin{itemdecl}
-template<class Allocator>
-  flat_multiset(const flat_multiset&, const Allocator& a);
-template<class Allocator>
-  flat_multiset(flat_multiset&&, const Allocator& a);
-template<class Allocator>
-  flat_multiset(const key_compare& comp, const Allocator& a);
-template<class Allocator>
-  explicit flat_multiset(const Allocator& a);
-template<class InputIterator, class Allocator>
+template<class Alloc>
+  flat_multiset(const flat_multiset&, const Alloc& a);
+template<class Alloc>
+  flat_multiset(flat_multiset&&, const Alloc& a);
+template<class Alloc>
+  flat_multiset(const key_compare& comp, const Alloc& a);
+template<class Alloc>
+  explicit flat_multiset(const Alloc& a);
+template<class InputIterator, class Alloc>
   flat_multiset(InputIterator first, InputIterator last,
-                const key_compare& comp, const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_multiset(InputIterator first, InputIterator last, const Allocator& a);
-template<@\exposconcept{container-compatible-range}@<value_type> R, class Allocator>
-  flat_multiset(from_range_t, R&& rg, const Allocator& a);
-template<@\exposconcept{container-compatible-range}@<value_type> R, class Allocator>
-  flat_multiset(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
-template<class InputIterator, class Allocator>
+                const key_compare& comp, const Alloc& a);
+template<class InputIterator, class Alloc>
+  flat_multiset(InputIterator first, InputIterator last, const Alloc& a);
+template<@\exposconcept{container-compatible-range}@<value_type> R, class Alloc>
+  flat_multiset(from_range_t, R&& rg, const Alloc& a);
+template<@\exposconcept{container-compatible-range}@<value_type> R, class Alloc>
+  flat_multiset(from_range_t, R&& rg, const key_compare& comp, const Alloc& a);
+template<class InputIterator, class Alloc>
   flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
-                const key_compare& comp, const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last, const Allocator& a);
-template<class Allocator>
-  flat_multiset(initializer_list<value_type> il, const key_compare& comp, const Allocator& a);
-template<class Allocator>
-  flat_multiset(initializer_list<value_type> il, const Allocator& a);
-template<class Allocator>
+                const key_compare& comp, const Alloc& a);
+template<class InputIterator, class Alloc>
+  flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last, const Alloc& a);
+template<class Alloc>
+  flat_multiset(initializer_list<value_type> il, const key_compare& comp, const Alloc& a);
+template<class Alloc>
+  flat_multiset(initializer_list<value_type> il, const Alloc& a);
+template<class Alloc>
   flat_multiset(sorted_equivalent_t, initializer_list<value_type> il,
-                const key_compare& comp, const Allocator& a);
-template<class Allocator>
-  flat_multiset(sorted_equivalent_t, initializer_list<value_type> il, const Allocator& a);
+                const key_compare& comp, const Alloc& a);
+template<class Alloc>
+  flat_multiset(sorted_equivalent_t, initializer_list<value_type> il, const Alloc& a);
 \end{itemdecl}
 
 \begin{itemdescr}
-\pnum
-\constraints
-\tcode{uses_allocator_v<container_type, Allocator>} is \tcode{true}.
-
 \pnum
 \effects
 Equivalent to the corresponding non-allocator constructors