[allocator.adaptor] - C++14 → C++17

Files changed (1) hide show

tmp/tmpamcipx1x/{from.md → to.md} +173 -107

tmp/tmpamcipx1x/{from.md → to.md} RENAMED Viewed

@@ -29,41 +29,44 @@ allocator is the outer allocator for use by the container, the second
 allocator is passed to the constructors of the container’s elements,
 and, if the elements themselves are containers, the third allocator is
 passed to the elements’ elements, and so on. If containers are nested to
 a depth greater than the number of allocators, the last allocator is
 used repeatedly, as in the single-allocator case, for any remaining
-recursions. The `scoped_allocator_adaptor` is derived from the outer
 allocator type so it can be substituted for the outer allocator type in
-most expressions.
 ``` cpp
 namespace std {
   template <class OuterAlloc, class... InnerAllocs>
     class scoped_allocator_adaptor : public OuterAlloc {
   private:
- typedef allocator_traits<OuterAlloc> OuterTraits; // exposition only
     scoped_allocator_adaptor<InnerAllocs...> inner;   // exposition only
   public:
- typedef OuterAlloc outer_allocator_type;
- typedef see below inner_allocator_type;
- typedef typename OuterTraits::value_type value_type;
- typedef typename OuterTraits::size_type size_type;
- typedef typename OuterTraits::difference_type difference_type;
- typedef typename OuterTraits::pointer pointer;
- typedef typename OuterTraits::const_pointer const_pointer;
- typedef typename OuterTraits::void_pointer void_pointer;
- typedef typename OuterTraits::const_void_pointer const_void_pointer;
- typedef see below propagate_on_container_copy_assignment;
- typedef see below propagate_on_container_move_assignment;
- typedef see below propagate_on_container_swap;
     template <class Tp>
       struct rebind {
- typedef scoped_allocator_adaptor<
-          OuterTraits::template rebind_alloc<Tp>, InnerAllocs...> other;
       };
     scoped_allocator_adaptor();
     template <class OuterA2>
       scoped_allocator_adaptor(OuterA2&& outerAlloc,
@@ -77,10 +80,13 @@ namespace std {
         const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& other) noexcept;
     template <class OuterA2>
       scoped_allocator_adaptor(
         scoped_allocator_adaptor<OuterA2, InnerAllocs...>&& other) noexcept;
     ~scoped_allocator_adaptor();
     inner_allocator_type& inner_allocator() noexcept;
     const inner_allocator_type& inner_allocator() const noexcept;
     outer_allocator_type& outer_allocator() noexcept;
@@ -109,10 +115,14 @@ namespace std {
       void destroy(T* p);
     scoped_allocator_adaptor select_on_container_copy_construction() const;
   };
   template <class OuterA1, class OuterA2, class... InnerAllocs>
     bool operator==(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
                     const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept;
   template <class OuterA1, class OuterA2, class... InnerAllocs>
     bool operator!=(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
@@ -121,113 +131,124 @@ namespace std {
 ```
 ### Scoped allocator adaptor member types <a id="allocator.adaptor.types">[[allocator.adaptor.types]]</a>
 ``` cpp
-typedef see below inner_allocator_type;
 ```
 *Type:* `scoped_allocator_adaptor<OuterAlloc>` if
 `sizeof...(InnerAllocs)` is zero; otherwise,
 `scoped_allocator_adaptor<InnerAllocs...>`.
 ``` cpp
-typedef see below propagate_on_container_copy_assignment;
 ```
 *Type:* `true_type` if
 `allocator_traits<A>::propagate_on_container_copy_assignment::value` is
 `true` for any `A` in the set of `OuterAlloc` and `InnerAllocs...`;
 otherwise, `false_type`.
 ``` cpp
-typedef see below propagate_on_container_move_assignment;
 ```
 *Type:* `true_type` if
 `allocator_traits<A>::propagate_on_container_move_assignment::value` is
 `true` for any `A` in the set of `OuterAlloc` and `InnerAllocs...`;
 otherwise, `false_type`.
 ``` cpp
-typedef see below propagate_on_container_swap;
 ```
 *Type:* `true_type` if
 `allocator_traits<A>::propagate_on_container_swap::value` is `true` for
 any `A` in the set of `OuterAlloc` and `InnerAllocs...`; otherwise,
 `false_type`.
 ### Scoped allocator adaptor constructors <a id="allocator.adaptor.cnstr">[[allocator.adaptor.cnstr]]</a>
 ``` cpp
 scoped_allocator_adaptor();
 ```
-*Effects:* value-initializes the `OuterAlloc` base class and the `inner`
 allocator object.
 ``` cpp
 template <class OuterA2>
   scoped_allocator_adaptor(OuterA2&& outerAlloc,
                            const InnerAllocs&... innerAllocs) noexcept;
 ```
-*Requires:* `OuterAlloc` shall be constructible from `OuterA2`.
-*Effects:* initializes the `OuterAlloc` base class with
 `std::forward<OuterA2>(outerAlloc)` and `inner` with `innerAllocs...`
 (hence recursively initializing each allocator within the adaptor with
 the corresponding allocator from the argument list).
 ``` cpp
 scoped_allocator_adaptor(const scoped_allocator_adaptor& other) noexcept;
 ```
-*Effects:* initializes each allocator within the adaptor with the
 corresponding allocator from `other`.
 ``` cpp
 scoped_allocator_adaptor(scoped_allocator_adaptor&& other) noexcept;
 ```
-*Effects:* move constructs each allocator within the adaptor with the
 corresponding allocator from `other`.
 ``` cpp
 template <class OuterA2>
   scoped_allocator_adaptor(const scoped_allocator_adaptor<OuterA2,
                                                           InnerAllocs...>& other) noexcept;
 ```
-*Requires:* `OuterAlloc` shall be constructible from `OuterA2`.
-*Effects:* initializes each allocator within the adaptor with the
 corresponding allocator from `other`.
 ``` cpp
 template <class OuterA2>
   scoped_allocator_adaptor(scoped_allocator_adaptor<OuterA2,
                                                     InnerAllocs...>&& other) noexcept;
 ```
-*Requires:* `OuterAlloc` shall be constructible from `OuterA2`.
-*Effects:* initializes each allocator within the adaptor with the
 corresponding allocator rvalue from `other`.
 ### Scoped allocator adaptor members <a id="allocator.adaptor.members">[[allocator.adaptor.members]]</a>
-In the `construct` member functions, *OUTERMOST(x)* is `x` if `x` does
 not have an `outer_allocator()` member function and
-*OUTERMOST(x.outer_allocator())* otherwise; *OUTERMOST_ALLOC_TRAITS(x)*
-is
-`allocator_traits<decltype(OUTERMOST(x))>`. *OUTERMOST*(x) and
-*OUTERMOST_ALLOC_TRAITS*(x) are recursive operations. It is incumbent
-upon the definition of `outer_allocator()` to ensure that the recursion
-terminates. It will terminate for all instantiations of
-`scoped_allocator_adaptor`.
 ``` cpp
 inner_allocator_type& inner_allocator() noexcept;
 const inner_allocator_type& inner_allocator() const noexcept;
 ```
@@ -263,12 +284,12 @@ pointer allocate(size_type n, const_void_pointer hint);
 ``` cpp
 void deallocate(pointer p, size_type n) noexcept;
 ```
-*Effects:*
-`allocator_traits<OuterAlloc>::deallocate(outer_allocator(), p, n)`;
 ``` cpp
 size_type max_size() const;
 ```
@@ -279,124 +300,162 @@ template <class T, class... Args>
   void construct(T* p, Args&&... args);
 ```
 *Effects:*
-- If `uses_allocator<T, inner_allocator_type>::value` is `false` and
-  `is_constructible<T, Args...>::value` is `true`, calls
- *OUTERMOST_ALLOC_TRAITS*(`*this`)`::construct(`
- *`OUTERMOST`*`(*this), p, std::forward<Args>(args)...)`.
-- Otherwise, if `uses_allocator<T, inner_allocator_type>::value` is
-  `true` and
-  `is_constructible<T, allocator_arg_t, inner_allocator_type, Args...>::value`
- is `true`, calls
- *OUTERMOST_ALLOC_TRAITS*(`*this`)`::construct(`*`OUTERMOST`*`(*this), p, allocator_arg,`
-  `inner_allocator(), std::forward<Args>(args)...)`.
-- Otherwise, if `uses_allocator<T, inner_allocator_type>::value` is
-  `true` and `is_constructible<T, Args..., inner_allocator_type>::value`
- is `true`, calls *OUTERMOST_ALLOC_TRAITS*(\*this)::
-  `construct(`*`OUTERMOST`*`(*this), p, std::forward<Args>(args)...,`
-  `inner_allocator())`.
-- Otherwise, the program is ill-formed. An error will result if
-  `uses_allocator` evaluates to true but the specific constructor does
- not take an allocator. This definition prevents a silent failure to
- pass an inner allocator to a contained element.
 ``` cpp
 template <class T1, class T2, class... Args1, class... Args2>
   void construct(pair<T1, T2>* p, piecewise_construct_t,
                  tuple<Args1...> x, tuple<Args2...> y);
 ```
 *Requires:* all of the types in `Args1` and `Args2` shall be
-`CopyConstructible` (Table  [[copyconstructible]]).
 *Effects:* Constructs a `tuple` object `xprime` from `x` by the
 following rules:
-- If `uses_allocator<T1, inner_allocator_type>::value` is `false` and
-  `is_constructible<T1, Args1...>::value` is `true`, then `xprime` is
-  `x`.
-- Otherwise, if `uses_allocator<T1, inner_allocator_type>::value` is
- `true` and
-  `is_constructible<T1, allocator_arg_t, inner_allocator_type, Args1...>::value`
-  is `true`, then `xprime` is
-  `tuple_cat(tuple<allocator_arg_t, inner_allocator_type&>( allocator_arg, inner_allocator()), std::move(x))`.
-- Otherwise, if `uses_allocator<T1, inner_allocator_type>::value` is
-  `true` and
-  `is_constructible<T1, Args1..., inner_allocator_type>::value` is
-  `true`, then `xprime` is
-  `tuple_cat(std::move(x), tuple<inner_allocator_type&>(inner_allocator()))`.
 - Otherwise, the program is ill-formed.
 and constructs a `tuple` object `yprime` from `y` by the following
 rules:
-- If `uses_allocator<T2, inner_allocator_type>::value` is `false` and
-  `is_constructible<T2, Args2...>::value` is `true`, then `yprime` is
-  `y`.
-- Otherwise, if `uses_allocator<T2, inner_allocator_type>::value` is
- `true` and
-  `is_constructible<T2, allocator_arg_t, inner_allocator_type, Args2...>::value`
-  is `true`, then `yprime` is
-  `tuple_cat(tuple<allocator_arg_t, inner_allocator_type&>( allocator_arg, inner_allocator()), std::move(y))`.
-- Otherwise, if `uses_allocator<T2, inner_allocator_type>::value` is
-  `true` and
-  `is_constructible<T2, Args2..., inner_allocator_type>::value` is
-  `true`, then `yprime` is
-  `tuple_cat(std::move(y), tuple<inner_allocator_type&>(inner_allocator()))`.
 - Otherwise, the program is ill-formed.
-then calls
-*`OUTERMOST_ALLOC_TRAITS`*`(*this)::construct(`*`OUTERMOST`*`(*this), p,`
-`piecewise_construct, std::move(xprime), std::move(yprime))`.
 ``` cpp
 template <class T1, class T2>
   void construct(pair<T1, T2>* p);
 ```
-*Effects:* Equivalent to
-`this->construct(p, piecewise_construct, tuple<>(), tuple<>())`.
 ``` cpp
 template <class T1, class T2, class U, class V>
   void construct(pair<T1, T2>* p, U&& x, V&& y);
 ```
-*Effects:* Equivalent to
-`this->construct(p, piecewise_construct, forward_as_tuple(std::forward<U>(x)), forward_as_tuple(std::forward<V>(y)))`.
 ``` cpp
 template <class T1, class T2, class U, class V>
   void construct(pair<T1, T2>* p, const pair<U, V>& x);
 ```
-*Effects:* Equivalent to
-`this->construct(p, piecewise_construct, forward_as_tuple(x.first), forward_as_tuple(x.second))`.
 ``` cpp
 template <class T1, class T2, class U, class V>
   void construct(pair<T1, T2>* p, pair<U, V>&& x);
 ```
-*Effects:* Equivalent to
-`this->construct(p, piecewise_construct, forward_as_tuple(std::forward<U>(x.first)), forward_as_tuple(std::forward<V>(x.second)))`.
 ``` cpp
 template <class T>
   void destroy(T* p);
 ```
-*Effects:* calls
-*`OUTERMOST_ALLOC_TRAITS`*`(*this)::destroy(`*`OUTERMOST`*`(*this), p)`.
 ``` cpp
 scoped_allocator_adaptor select_on_container_copy_construction() const;
 ```
-*Returns:* A new scoped_allocator_adaptor object where each allocator
 `A` in the adaptor is initialized from the result of calling
 `allocator_traits<A>::select_on_container_copy_construction()` on the
 corresponding allocator in `*this`.
 ### Scoped allocator operators <a id="scoped.adaptor.operators">[[scoped.adaptor.operators]]</a>
@@ -405,14 +464,21 @@ corresponding allocator in `*this`.
 template <class OuterA1, class OuterA2, class... InnerAllocs>
   bool operator==(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
                   const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept;
 ```
-*Returns:* `a.outer_allocator() == b.outer_allocator()` if
-`sizeof...(InnerAllocs)` is zero; otherwise,
-`a.outer_allocator() == b.outer_allocator()` `&&`
-`a.inner_allocator() == b.inner_allocator()`.
 ``` cpp
 template <class OuterA1, class OuterA2, class... InnerAllocs>
   bool operator!=(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
                   const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept;

 allocator is passed to the constructors of the container’s elements,
 and, if the elements themselves are containers, the third allocator is
 passed to the elements’ elements, and so on. If containers are nested to
 a depth greater than the number of allocators, the last allocator is
 used repeatedly, as in the single-allocator case, for any remaining
+recursions.
+[*Note 1*: The `scoped_allocator_adaptor` is derived from the outer
 allocator type so it can be substituted for the outer allocator type in
+most expressions. — *end note*]
 ``` cpp
 namespace std {
   template <class OuterAlloc, class... InnerAllocs>
     class scoped_allocator_adaptor : public OuterAlloc {
   private:
+ using OuterTraits = allocator_traits<OuterAlloc>; // exposition only
     scoped_allocator_adaptor<InnerAllocs...> inner;   // exposition only
   public:
+ using outer_allocator_type = OuterAlloc;
+ using inner_allocator_type = see below;
+ using value_type           = typename OuterTraits::value_type;
+ using size_type            = typename OuterTraits::size_type;
+ using difference_type      = typename OuterTraits::difference_type;
+ using pointer              = typename OuterTraits::pointer;
+ using const_pointer        = typename OuterTraits::const_pointer;
+ using void_pointer         = typename OuterTraits::void_pointer;
+ using const_void_pointer   = typename OuterTraits::const_void_pointer;
+ using propagate_on_container_copy_assignment = see below;
+ using propagate_on_container_move_assignment = see below;
+ using propagate_on_container_swap            = see below;
+    using is_always_equal                        = see below;
     template <class Tp>
       struct rebind {
+ using other = scoped_allocator_adaptor<
+          OuterTraits::template rebind_alloc<Tp>, InnerAllocs...>;
       };
     scoped_allocator_adaptor();
     template <class OuterA2>
       scoped_allocator_adaptor(OuterA2&& outerAlloc,
         const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& other) noexcept;
     template <class OuterA2>
       scoped_allocator_adaptor(
         scoped_allocator_adaptor<OuterA2, InnerAllocs...>&& other) noexcept;
+    scoped_allocator_adaptor& operator=(const scoped_allocator_adaptor&) = default;
+    scoped_allocator_adaptor& operator=(scoped_allocator_adaptor&&) = default;
     ~scoped_allocator_adaptor();
     inner_allocator_type& inner_allocator() noexcept;
     const inner_allocator_type& inner_allocator() const noexcept;
     outer_allocator_type& outer_allocator() noexcept;
       void destroy(T* p);
     scoped_allocator_adaptor select_on_container_copy_construction() const;
   };
+  template<class OuterAlloc, class... InnerAllocs>
+    scoped_allocator_adaptor(OuterAlloc, InnerAllocs...)
+      -> scoped_allocator_adaptor<OuterAlloc, InnerAllocs...>;
   template <class OuterA1, class OuterA2, class... InnerAllocs>
     bool operator==(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
                     const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept;
   template <class OuterA1, class OuterA2, class... InnerAllocs>
     bool operator!=(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
 ```
 ### Scoped allocator adaptor member types <a id="allocator.adaptor.types">[[allocator.adaptor.types]]</a>
 ``` cpp
+using inner_allocator_type = see below;
 ```
 *Type:* `scoped_allocator_adaptor<OuterAlloc>` if
 `sizeof...(InnerAllocs)` is zero; otherwise,
 `scoped_allocator_adaptor<InnerAllocs...>`.
 ``` cpp
+using propagate_on_container_copy_assignment = see below;
 ```
 *Type:* `true_type` if
 `allocator_traits<A>::propagate_on_container_copy_assignment::value` is
 `true` for any `A` in the set of `OuterAlloc` and `InnerAllocs...`;
 otherwise, `false_type`.
 ``` cpp
+using propagate_on_container_move_assignment = see below;
 ```
 *Type:* `true_type` if
 `allocator_traits<A>::propagate_on_container_move_assignment::value` is
 `true` for any `A` in the set of `OuterAlloc` and `InnerAllocs...`;
 otherwise, `false_type`.
 ``` cpp
+using propagate_on_container_swap = see below;
 ```
 *Type:* `true_type` if
 `allocator_traits<A>::propagate_on_container_swap::value` is `true` for
 any `A` in the set of `OuterAlloc` and `InnerAllocs...`; otherwise,
 `false_type`.
+``` cpp
+using is_always_equal = see below;
+```
+*Type:* `true_type` if `allocator_traits<A>::is_always_equal::value` is
+`true` for every `A` in the set of `OuterAlloc` and `InnerAllocs...`;
+otherwise, `false_type`.
 ### Scoped allocator adaptor constructors <a id="allocator.adaptor.cnstr">[[allocator.adaptor.cnstr]]</a>
 ``` cpp
 scoped_allocator_adaptor();
 ```
+*Effects:* Value-initializes the `OuterAlloc` base class and the `inner`
 allocator object.
 ``` cpp
 template <class OuterA2>
   scoped_allocator_adaptor(OuterA2&& outerAlloc,
                            const InnerAllocs&... innerAllocs) noexcept;
 ```
+*Effects:* Initializes the `OuterAlloc` base class with
 `std::forward<OuterA2>(outerAlloc)` and `inner` with `innerAllocs...`
 (hence recursively initializing each allocator within the adaptor with
 the corresponding allocator from the argument list).
+*Remarks:* This constructor shall not participate in overload resolution
+unless `is_constructible_v<OuterAlloc, OuterA2>` is `true`.
 ``` cpp
 scoped_allocator_adaptor(const scoped_allocator_adaptor& other) noexcept;
 ```
+*Effects:* Initializes each allocator within the adaptor with the
 corresponding allocator from `other`.
 ``` cpp
 scoped_allocator_adaptor(scoped_allocator_adaptor&& other) noexcept;
 ```
+*Effects:* Move constructs each allocator within the adaptor with the
 corresponding allocator from `other`.
 ``` cpp
 template <class OuterA2>
   scoped_allocator_adaptor(const scoped_allocator_adaptor<OuterA2,
                                                           InnerAllocs...>& other) noexcept;
 ```
+*Effects:* Initializes each allocator within the adaptor with the
 corresponding allocator from `other`.
+*Remarks:* This constructor shall not participate in overload resolution
+unless `is_constructible_v<OuterAlloc, const OuterA2&>` is `true`.
 ``` cpp
 template <class OuterA2>
   scoped_allocator_adaptor(scoped_allocator_adaptor<OuterA2,
                                                     InnerAllocs...>&& other) noexcept;
 ```
+*Effects:* Initializes each allocator within the adaptor with the
 corresponding allocator rvalue from `other`.
+*Remarks:* This constructor shall not participate in overload resolution
+unless `is_constructible_v<OuterAlloc, OuterA2>` is `true`.
 ### Scoped allocator adaptor members <a id="allocator.adaptor.members">[[allocator.adaptor.members]]</a>
+In the `construct` member functions, `OUTERMOST(x)` is `x` if `x` does
 not have an `outer_allocator()` member function and
+`OUTERMOST(x.outer_allocator())` otherwise; `OUTERMOST_ALLOC_TRAITS(x)`
+is `allocator_traits<decltype(OUTERMOST(x))>`.
+[*Note 1*: `OUTERMOST(x)` and `OUTERMOST_ALLOC_TRAITS(x)` are recursive
+operations. It is incumbent upon the definition of `outer_allocator()`
+to ensure that the recursion terminates. It will terminate for all
+instantiations of `scoped_allocator_adaptor`. — *end note*]
 ``` cpp
 inner_allocator_type& inner_allocator() noexcept;
 const inner_allocator_type& inner_allocator() const noexcept;
 ```
 ``` cpp
 void deallocate(pointer p, size_type n) noexcept;
 ```
+*Effects:* As if by:
+`allocator_traits<OuterAlloc>::deallocate(outer_allocator(), p, n);`
 ``` cpp
 size_type max_size() const;
 ```
   void construct(T* p, Args&&... args);
 ```
 *Effects:*
+- If `uses_allocator_v<T, inner_allocator_type>` is `false` and
+  `is_constructible_v<T,`
+  `Args...>` is `true`, calls:
+  ``` cpp
+  OUTERMOST_ALLOC_TRAITS(*this)::construct(
+      OUTERMOST(*this), p, std::forward<Args>(args)...)
+  ```
+- Otherwise, if `uses_allocator_v<T, inner_allocator_type>` is `true`
+ and
+  `is_constructible_v<T, allocator_arg_t, inner_allocator_type&, Args...>`
+  is `true`, calls:
+  ``` cpp
+  OUTERMOST_ALLOC_TRAITS(*this)::construct(
+ OUTERMOST(*this), p, allocator_arg, inner_allocator(), std::forward<Args>(args)...)
+  ```
+- Otherwise, if `uses_allocator_v<T, inner_allocator_type>` is `true`
+ and `is_constructible_v<T, Args..., inner_allocator_type&>` is `true`,
+ calls:
+ ``` cpp
+  OUTERMOST_ALLOC_TRAITS(*this)::construct(
+      OUTERMOST(*this), p, std::forward<Args>(args)..., inner_allocator())
+  ```
+- Otherwise, the program is ill-formed. \[*Note 2*: An error will result
+  if `uses_allocator` evaluates to `true` but the specific constructor
+  does not take an allocator. This definition prevents a silent failure
+  to pass an inner allocator to a contained element. — *end note*]
 ``` cpp
 template <class T1, class T2, class... Args1, class... Args2>
   void construct(pair<T1, T2>* p, piecewise_construct_t,
                  tuple<Args1...> x, tuple<Args2...> y);
 ```
 *Requires:* all of the types in `Args1` and `Args2` shall be
+`CopyConstructible` (Table  [[tab:copyconstructible]]).
 *Effects:* Constructs a `tuple` object `xprime` from `x` by the
 following rules:
+- If `uses_allocator_v<T1, inner_allocator_type>` is `false` and
+  `is_constructible_v<T1,`
+  `Args1...>` is `true`, then `xprime` is `x`.
+- Otherwise, if `uses_allocator_v<T1, inner_allocator_type>` is `true`
+  and
+  `is_constructible_v<T1, allocator_arg_t, inner_allocator_type&, Args1...>`
+  is `true`, then `xprime` is:
+  ``` cpp
+  tuple_cat(
+      tuple<allocator_arg_t, inner_allocator_type&>(allocator_arg, inner_allocator()),
+      std::move(x))
+  ```
+- Otherwise, if `uses_allocator_v<T1, inner_allocator_type>` is `true`
+  and `is_constructible_v<T1, Args1..., inner_allocator_type&>` is
+  `true`, then `xprime` is:
+  ``` cpp
+  tuple_cat(std::move(x), tuple<inner_allocator_type&>(inner_allocator()))
+  ```
 - Otherwise, the program is ill-formed.
 and constructs a `tuple` object `yprime` from `y` by the following
 rules:
+- If `uses_allocator_v<T2, inner_allocator_type>` is `false` and
+  `is_constructible_v<T2,`
+  `Args2...>` is `true`, then `yprime` is `y`.
+- Otherwise, if `uses_allocator_v<T2, inner_allocator_type>` is `true`
+  and
+  `is_constructible_v<T2, allocator_arg_t, inner_allocator_type&, Args2...>`
+  is `true`, then `yprime` is:
+  ``` cpp
+  tuple_cat(
+      tuple<allocator_arg_t, inner_allocator_type&>(allocator_arg, inner_allocator()),
+      std::move(y))
+  ```
+- Otherwise, if `uses_allocator_v<T2, inner_allocator_type>` is `true`
+  and `is_constructible_v<T2, Args2..., inner_allocator_type&>` is
+  `true`, then `yprime` is:
+  ``` cpp
+  tuple_cat(std::move(y), tuple<inner_allocator_type&>(inner_allocator()))
+  ```
 - Otherwise, the program is ill-formed.
+then calls:
+``` cpp
+OUTERMOST_ALLOC_TRAITS(*this)::construct(
+    OUTERMOST(*this), p, piecewise_construct, std::move(xprime), std::move(yprime))
+```
 ``` cpp
 template <class T1, class T2>
   void construct(pair<T1, T2>* p);
 ```
+*Effects:* Equivalent to:
+``` cpp
+construct(p, piecewise_construct, tuple<>(), tuple<>());
+```
 ``` cpp
 template <class T1, class T2, class U, class V>
   void construct(pair<T1, T2>* p, U&& x, V&& y);
 ```
+*Effects:* Equivalent to:
+``` cpp
+construct(p, piecewise_construct,
+          forward_as_tuple(std::forward<U>(x)),
+          forward_as_tuple(std::forward<V>(y)));
+```
 ``` cpp
 template <class T1, class T2, class U, class V>
   void construct(pair<T1, T2>* p, const pair<U, V>& x);
 ```
+*Effects:* Equivalent to:
+``` cpp
+construct(p, piecewise_construct,
+          forward_as_tuple(x.first),
+          forward_as_tuple(x.second));
+```
 ``` cpp
 template <class T1, class T2, class U, class V>
   void construct(pair<T1, T2>* p, pair<U, V>&& x);
 ```
+*Effects:* Equivalent to:
+``` cpp
+construct(p, piecewise_construct,
+          forward_as_tuple(std::forward<U>(x.first)),
+          forward_as_tuple(std::forward<V>(x.second)));
+```
 ``` cpp
 template <class T>
   void destroy(T* p);
 ```
+*Effects:* Calls
+*OUTERMOST_ALLOC_TRAITS*(\*this)::destroy(*OUTERMOST*(\*this), p).
 ``` cpp
 scoped_allocator_adaptor select_on_container_copy_construction() const;
 ```
+*Returns:* A new `scoped_allocator_adaptor` object where each allocator
 `A` in the adaptor is initialized from the result of calling
 `allocator_traits<A>::select_on_container_copy_construction()` on the
 corresponding allocator in `*this`.
 ### Scoped allocator operators <a id="scoped.adaptor.operators">[[scoped.adaptor.operators]]</a>
 template <class OuterA1, class OuterA2, class... InnerAllocs>
   bool operator==(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
                   const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept;
 ```
+*Returns:* If `sizeof...(InnerAllocs)` is zero,
+``` cpp
+a.outer_allocator() == b.outer_allocator()
+```
+otherwise
+``` cpp
+a.outer_allocator() == b.outer_allocator() && a.inner_allocator() == b.inner_allocator()
+```
 ``` cpp
 template <class OuterA1, class OuterA2, class... InnerAllocs>
   bool operator!=(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
                   const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept;

Diff to HTML by rtfpessoa