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

Files changed (1) hide show

tmp/tmpz47qoczo/{from.md → to.md} +68 -46

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

@@ -1,30 +1,33 @@
 ### Allocator traits <a id="allocator.traits">[[allocator.traits]]</a>
 The class template `allocator_traits` supplies a uniform interface to
 all allocator types. An allocator cannot be a non-class type, however,
-even if `allocator_traits` supplies the entire required interface. Thus,
-it is always possible to create a derived class from an allocator.
 ``` cpp
 namespace std {
   template <class Alloc> struct allocator_traits {
- typedef Alloc allocator_type;
- typedef typename Alloc::value_type value_type;
- typedef see below pointer;
- typedef see below const_pointer;
- typedef see below void_pointer;
- typedef see below const_void_pointer;
- typedef see below difference_type;
- typedef see below size_type;
- 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 T> using rebind_alloc = see below;
     template <class T> using rebind_traits = allocator_traits<rebind_alloc<T>>;
     static pointer allocate(Alloc& a, size_type n);
@@ -46,80 +49,99 @@ namespace std {
 ```
 #### Allocator traits member types <a id="allocator.traits.types">[[allocator.traits.types]]</a>
 ``` cpp
-typedef see below pointer;
 ```
-*Type:* `Alloc::pointer` if such a type exists; otherwise,
-`value_type*`.
 ``` cpp
-typedef see below const_pointer;
 ```
-*Type:* `Alloc::const_pointer` if such a type exists; otherwise,
-`pointer_traits<pointer>::rebind<const value_type>`.
 ``` cpp
-typedef see below void_pointer;
 ```
-*Type:* `Alloc::void_pointer` if such a type exists; otherwise,
-`pointer_traits<pointer>::rebind<void>`.
 ``` cpp
-typedef see below const_void_pointer;
 ```
-*Type:* `Alloc::const_void_pointer` if such a type exists; otherwise,
 `pointer_traits<pointer>::rebind<const void>`.
 ``` cpp
-typedef see below difference_type;
 ```
-*Type:* `Alloc::difference_type` if such a type exists; otherwise,
-`pointer_traits<pointer>::difference_type`.
 ``` cpp
-typedef see below size_type;
 ```
-*Type:* `Alloc::size_type` if such a type exists; otherwise,
 `make_unsigned_t<difference_type>`.
 ``` cpp
-typedef see below propagate_on_container_copy_assignment;
 ```
-*Type:* `Alloc::propagate_on_container_copy_assignment` if such a type
-exists, otherwise `false_type`.
 ``` cpp
-typedef see below propagate_on_container_move_assignment;
 ```
-*Type:* `Alloc::propagate_on_container_move_assignment` if such a type
-exists, otherwise `false_type`.
 ``` cpp
-typedef see below propagate_on_container_swap;
 ```
-*Type:* `Alloc::propagate_on_container_swap` if such a type exists,
-otherwise `false_type`.
 ``` cpp
 template <class T> using rebind_alloc = see below;
 ```
-*Alias template:* `Alloc::rebind<T>::other` if such a type exists;
-otherwise, `Alloc<T, Args>` if `Alloc` is a class template instantiation
-of the form `Alloc<U, Args>`, where `Args` is zero or more type
-arguments; otherwise, the instantiation of `rebind_alloc` is ill-formed.
 #### Allocator traits static member functions <a id="allocator.traits.members">[[allocator.traits.members]]</a>
 ``` cpp
 static pointer allocate(Alloc& a, size_type n);
@@ -136,37 +158,37 @@ otherwise, `a.allocate(n)`.
 ``` cpp
 static void deallocate(Alloc& a, pointer p, size_type n);
 ```
-*Effects:* calls `a.deallocate(p, n)`.
 *Throws:* Nothing.
 ``` cpp
 template <class T, class... Args>
   static void construct(Alloc& a, T* p, Args&&... args);
 ```
-*Effects:* calls `a.construct(p, std::forward<Args>(args)...)` if that
 call is well-formed; otherwise, invokes
 `::new (static_cast<void*>(p)) T(std::forward<Args>(args)...)`.
 ``` cpp
 template <class T>
   static void destroy(Alloc& a, T* p);
 ```
-*Effects:* calls `a.destroy(p)` if that call is well-formed; otherwise,
 invokes `p->~T()`.
 ``` cpp
 static size_type max_size(const Alloc& a) noexcept;
 ```
 *Returns:* `a.max_size()` if that expression is well-formed; otherwise,
-`numeric_limits<size_type>::max()`.
 ``` cpp
 static Alloc select_on_container_copy_construction(const Alloc& rhs);
 ```

 ### Allocator traits <a id="allocator.traits">[[allocator.traits]]</a>
 The class template `allocator_traits` supplies a uniform interface to
 all allocator types. An allocator cannot be a non-class type, however,
+even if `allocator_traits` supplies the entire required interface.
+[*Note 1*: Thus, it is always possible to create a derived class from
+an allocator. — *end note*]
 ``` cpp
 namespace std {
   template <class Alloc> struct allocator_traits {
+ using allocator_type     = Alloc;
+ using value_type         = typename Alloc::value_type;
+ using pointer            = see below;
+ using const_pointer      = see below;
+ using void_pointer       = see below;
+ using const_void_pointer = see below;
+ using difference_type    = see below;
+ using size_type          = see below;
+ 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 T> using rebind_alloc = see below;
     template <class T> using rebind_traits = allocator_traits<rebind_alloc<T>>;
     static pointer allocate(Alloc& a, size_type n);
 ```
 #### Allocator traits member types <a id="allocator.traits.types">[[allocator.traits.types]]</a>
 ``` cpp
+using pointer = see below;
 ```
+*Type:* `Alloc::pointer` if the *qualified-id* `Alloc::pointer` is valid
+and denotes a type ([[temp.deduct]]); otherwise, `value_type*`.
 ``` cpp
+using const_pointer = see below;
 ```
+*Type:* `Alloc::const_pointer` if the *qualified-id*
+`Alloc::const_pointer` is valid and denotes a type ([[temp.deduct]]);
+otherwise, `pointer_traits<pointer>::rebind<const value_type>`.
 ``` cpp
+using void_pointer = see below;
 ```
+*Type:* `Alloc::void_pointer` if the *qualified-id*
+`Alloc::void_pointer` is valid and denotes a type ([[temp.deduct]]);
+otherwise, `pointer_traits<pointer>::rebind<void>`.
 ``` cpp
+using const_void_pointer = see below;
 ```
+*Type:* `Alloc::const_void_pointer` if the *qualified-id*
+`Alloc::const_void_pointer` is valid and denotes a
+type ([[temp.deduct]]); otherwise,
 `pointer_traits<pointer>::rebind<const void>`.
 ``` cpp
+using difference_type = see below;
 ```
+*Type:* `Alloc::difference_type` if the *qualified-id*
+`Alloc::difference_type` is valid and denotes a type ([[temp.deduct]]);
+otherwise, `pointer_traits<pointer>::difference_type`.
 ``` cpp
+using size_type = see below;
 ```
+*Type:* `Alloc::size_type` if the *qualified-id* `Alloc::size_type` is
+valid and denotes a type ([[temp.deduct]]); otherwise,
 `make_unsigned_t<difference_type>`.
 ``` cpp
+using propagate_on_container_copy_assignment = see below;
 ```
+*Type:* `Alloc::propagate_on_container_copy_assignment` if the
+*qualified-id* `Alloc::propagate_on_container_copy_assignment` is valid
+and denotes a type ([[temp.deduct]]); otherwise `false_type`.
 ``` cpp
+using propagate_on_container_move_assignment = see below;
 ```
+*Type:* `Alloc::propagate_on_container_move_assignment` if the
+*qualified-id* `Alloc::propagate_on_container_move_assignment` is valid
+and denotes a type ([[temp.deduct]]); otherwise `false_type`.
 ``` cpp
+using propagate_on_container_swap = see below;
 ```
+*Type:* `Alloc::propagate_on_container_swap` if the *qualified-id*
+`Alloc::propagate_on_container_swap` is valid and denotes a
+type ([[temp.deduct]]); otherwise `false_type`.
+``` cpp
+using is_always_equal = see below;
+```
+*Type:* `Alloc::is_always_equal` if the *qualified-id*
+`Alloc::is_always_equal` is valid and denotes a type ([[temp.deduct]]);
+otherwise `is_empty<Alloc>::type`.
 ``` cpp
 template <class T> using rebind_alloc = see below;
 ```
+*Alias template:* `Alloc::rebind<T>::other` if the *qualified-id*
+`Alloc::rebind<T>::other` is valid and denotes a
+type ([[temp.deduct]]); otherwise, `Alloc<T, Args>` if `Alloc` is a
+class template instantiation of the form `Alloc<U, Args>`, where `Args`
+is zero or more type arguments; otherwise, the instantiation of
+`rebind_alloc` is ill-formed.
 #### Allocator traits static member functions <a id="allocator.traits.members">[[allocator.traits.members]]</a>
 ``` cpp
 static pointer allocate(Alloc& a, size_type n);
 ``` cpp
 static void deallocate(Alloc& a, pointer p, size_type n);
 ```
+*Effects:* Calls `a.deallocate(p, n)`.
 *Throws:* Nothing.
 ``` cpp
 template <class T, class... Args>
   static void construct(Alloc& a, T* p, Args&&... args);
 ```
+*Effects:* Calls `a.construct(p, std::forward<Args>(args)...)` if that
 call is well-formed; otherwise, invokes
 `::new (static_cast<void*>(p)) T(std::forward<Args>(args)...)`.
 ``` cpp
 template <class T>
   static void destroy(Alloc& a, T* p);
 ```
+*Effects:* Calls `a.destroy(p)` if that call is well-formed; otherwise,
 invokes `p->~T()`.
 ``` cpp
 static size_type max_size(const Alloc& a) noexcept;
 ```
 *Returns:* `a.max_size()` if that expression is well-formed; otherwise,
+`numeric_limits<size_type>::max()/sizeof(value_type)`.
 ``` cpp
 static Alloc select_on_container_copy_construction(const Alloc& rhs);
 ```

Diff to HTML by rtfpessoa