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

Files changed (1) hide show

tmp/tmpk9o7z6a_/{from.md → to.md} +39 -197

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

@@ -1,24 +1,25 @@
 ## Class template `scoped_allocator_adaptor` <a id="allocator.adaptor">[[allocator.adaptor]]</a>
 ### Header `<scoped_allocator>` synopsis <a id="allocator.adaptor.syn">[[allocator.adaptor.syn]]</a>
 ``` cpp
-// scoped allocator adaptor
   template<class OuterAlloc, class... InnerAlloc>
     class scoped_allocator_adaptor;
   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,
-                    const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept;
 ```
 The class template `scoped_allocator_adaptor` is an allocator template
-that specifies the memory resource (the outer allocator) to be used by a
-container (as any other allocator does) and also specifies an inner
 allocator resource to be passed to the constructor of every element
 within the container. This adaptor is instantiated with one outer and
 zero or more inner allocator types. If instantiated with only one
 allocator type, the inner allocator becomes the
 `scoped_allocator_adaptor` itself, thus using the same allocator
@@ -42,10 +43,11 @@ 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;
@@ -59,12 +61,11 @@ namespace std {
     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();
@@ -90,49 +91,31 @@ namespace std {
     inner_allocator_type& inner_allocator() noexcept;
     const inner_allocator_type& inner_allocator() const noexcept;
     outer_allocator_type& outer_allocator() noexcept;
     const outer_allocator_type& outer_allocator() const noexcept;
-    pointer allocate(size_type n);
-    pointer allocate(size_type n, const_void_pointer hint);
     void deallocate(pointer p, size_type n);
     size_type max_size() const;
     template<class T, class... Args>
       void construct(T* p, Args&&... args);
-    template <class T1, class T2, class... Args1, class... Args2>
-      void construct(pair<T1, T2>* p, piecewise_construct_t,
-                     tuple<Args1...> x, tuple<Args2...> y);
-    template <class T1, class T2>
-      void construct(pair<T1, T2>* p);
-    template <class T1, class T2, class U, class V>
-      void construct(pair<T1, T2>* p, U&& x, V&& y);
-    template <class T1, class T2, class U, class V>
-      void construct(pair<T1, T2>* p, const pair<U, V>& x);
-    template <class T1, class T2, class U, class V>
-      void construct(pair<T1, T2>* p, pair<U, V>&& x);
     template<class T>
       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,
-                    const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept;
 }
 ```
-### Scoped allocator adaptor member types <a id="allocator.adaptor.types">[[allocator.adaptor.types]]</a>
 ``` cpp
 using inner_allocator_type = see below;
 ```
@@ -173,33 +156,31 @@ 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
@@ -212,38 +193,36 @@ 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*]
@@ -267,18 +246,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)`.
@@ -298,149 +277,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);
@@ -456,11 +306,11 @@ 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>
 ``` 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;
@@ -476,13 +326,5 @@ 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;
-```
-*Returns:* `!(a == b)`.

 ## Class template `scoped_allocator_adaptor` <a id="allocator.adaptor">[[allocator.adaptor]]</a>
 ### Header `<scoped_allocator>` synopsis <a id="allocator.adaptor.syn">[[allocator.adaptor.syn]]</a>
 ``` cpp
+namespace std {
+  // class template scoped allocator adaptor
   template<class OuterAlloc, class... InnerAlloc>
     class scoped_allocator_adaptor;
+  // [scoped.adaptor.operators], scoped allocator operators
   template<class OuterA1, class OuterA2, class... InnerAllocs>
     bool operator==(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
                     const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept;
+}
 ```
 The class template `scoped_allocator_adaptor` is an allocator template
+that specifies an allocator resource (the outer allocator) to be used by
+a container (as any other allocator does) and also specifies an inner
 allocator resource to be passed to the constructor of every element
 within the container. This adaptor is instantiated with one outer and
 zero or more inner allocator types. If instantiated with only one
 allocator type, the inner allocator becomes the
 `scoped_allocator_adaptor` itself, thus using the same allocator
   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 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();
     inner_allocator_type& inner_allocator() noexcept;
     const inner_allocator_type& inner_allocator() const noexcept;
     outer_allocator_type& outer_allocator() noexcept;
     const outer_allocator_type& outer_allocator() const noexcept;
+ [[nodiscard]] pointer allocate(size_type n);
+ [[nodiscard]] pointer allocate(size_type n, const_void_pointer hint);
     void deallocate(pointer p, size_type n);
     size_type max_size() const;
     template<class T, class... Args>
       void construct(T* p, Args&&... args);
     template<class T>
       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...>;
 }
 ```
+### Member types <a id="allocator.adaptor.types">[[allocator.adaptor.types]]</a>
 ``` cpp
 using inner_allocator_type = 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`.
+### 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;
 ```
+*Constraints:* `is_constructible_v<OuterAlloc, OuterA2>` is `true`.
 *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
 *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;
 ```
+*Constraints:* `is_constructible_v<OuterAlloc, const OuterA2&>` is
+`true`.
 *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;
 ```
+*Constraints:* `is_constructible_v<OuterAlloc, OuterA2>` is `true`.
 *Effects:* Initializes each allocator within the adaptor with the
 corresponding allocator rvalue from `other`.
+### 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);
 *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`.
+### Operators <a id="scoped.adaptor.operators">[[scoped.adaptor.operators]]</a>
 ``` 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;
 ``` cpp
 a.outer_allocator() == b.outer_allocator() && a.inner_allocator() == b.inner_allocator()
 ```

Diff to HTML by rtfpessoa