[allocator.adaptor.members]

Files changed (1) hide show

tmp/tmpmnq9yiwd/{from.md → to.md} +14 -143

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

@@ -1,11 +1,11 @@
-### 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*]
@@ -29,18 +29,18 @@ const outer_allocator_type& outer_allocator() const noexcept;
 ```
 *Returns:* `static_cast<const OuterAlloc&>(*this)`.
 ``` cpp
-pointer allocate(size_type n);
 ```
 *Returns:*
 `allocator_traits<OuterAlloc>::allocate(outer_allocator(), n)`.
 ``` cpp
-pointer allocate(size_type n, const_void_pointer hint);
 ```
 *Returns:*
 `allocator_traits<OuterAlloc>::allocate(outer_allocator(), n, hint)`.
@@ -60,149 +60,20 @@ size_type max_size() const;
 ``` cpp
 template<class T, class... Args>
   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);

+### Members <a id="allocator.adaptor.members">[[allocator.adaptor.members]]</a>
+In the `construct` member functions, `OUTERMOST(x)` is
+`OUTERMOST(x.outer_allocator())` if the expression `x.outer_allocator()`
+is valid  [[temp.deduct]] and `x` otherwise; `OUTERMOST_ALLOC_TRAITS(x)`
+is `allocator_traits<remove_reference_t<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*]
 ```
 *Returns:* `static_cast<const OuterAlloc&>(*this)`.
 ``` cpp
+[[nodiscard]] pointer allocate(size_type n);
 ```
 *Returns:*
 `allocator_traits<OuterAlloc>::allocate(outer_allocator(), n)`.
 ``` cpp
+[[nodiscard]] pointer allocate(size_type n, const_void_pointer hint);
 ```
 *Returns:*
 `allocator_traits<OuterAlloc>::allocate(outer_allocator(), n, hint)`.
 ``` cpp
 template<class T, class... Args>
   void construct(T* p, Args&&... args);
 ```
 *Effects:* Equivalent to:
 ``` cpp
+apply([p, this](auto&&... newargs) {
+        OUTERMOST_ALLOC_TRAITS(*this)::construct(
+ OUTERMOST(*this), p,
+          std::forward<decltype(newargs)>(newargs)...);
+      },
+      uses_allocator_construction_args<T>(inner_allocator(),
+                                          std::forward<Args>(args)...));
 ```
 ``` cpp
 template<class T>
   void destroy(T* p);

Diff to HTML by rtfpessoa