[allocator.adaptor.members]

Files changed (1) hide show

tmp/tmpodnw4e9p/{from.md → to.md} +108 -70

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

@@ -1,16 +1,16 @@
 ### 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;
 ```
@@ -46,12 +46,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;
 ```
@@ -62,123 +62,161 @@ 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 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`.

Diff to HTML by rtfpessoa