P0220R1: memory resources (section 8), except for section 8.2 (shared_ptr and weak_ptr changes)

Author: zygoloid

source/containers.tex

@@ -2479,6 +2479,11 @@
   template <class T, class Allocator>
     void swap(deque<T, Allocator>& x, deque<T, Allocator>& y)
       noexcept(noexcept(x.swap(y)));
+
+  namespace pmr {
+    template <class T>
+      using deque = std::deque<T,polymorphic_allocator<T>>;
+  }
 }
 \end{codeblock}
 
@@ -2507,6 +2512,11 @@
   template <class T, class Allocator>
     void swap(forward_list<T, Allocator>& x, forward_list<T, Allocator>& y)
       noexcept(noexcept(x.swap(y)));
+
+  namespace pmr {
+    template <class T>
+      using forward_list = std::forward_list<T,polymorphic_allocator<T>>;
+  }
 }
 \end{codeblock}
 
@@ -2535,6 +2545,11 @@
   template <class T, class Allocator>
     void swap(list<T, Allocator>& x, list<T, Allocator>& y)
       noexcept(noexcept(x.swap(y)));
+
+  namespace pmr {
+    template <class T>
+      using list = std::list<T,polymorphic_allocator<T>>;
+  }
 }
 \end{codeblock}
 
@@ -2570,6 +2585,11 @@
   // hash support
   template <class T> struct hash;
   template <class Allocator> struct hash<vector<bool, Allocator>>;
+
+  namespace pmr {
+    template <class T>
+      using vector = std::vector<T,polymorphic_allocator<T>>;
+  }
 }
 \end{codeblock}
 
@@ -5390,6 +5410,16 @@
     void swap(multimap<Key, T, Compare, Allocator>& x,
               multimap<Key, T, Compare, Allocator>& y)
       noexcept(noexcept(x.swap(y)));
+
+  namespace pmr {
+    template <class Key, class T, class Compare = less<Key>>
+      using map = std::map<Key, T, Compare,
+                           polymorphic_allocator<pair<const Key,T>>>;
+
+    template <class Key, class T, class Compare = less<Key>>
+      using multimap = std::multimap<Key, T, Compare,
+                                     polymorphic_allocator<pair<const Key,T>>>;
+  }
 }
 \end{codeblock}
 
@@ -5453,6 +5483,16 @@
     void swap(multiset<Key, Compare, Allocator>& x,
               multiset<Key, Compare, Allocator>& y)
       noexcept(noexcept(x.swap(y)));
+
+  namespace pmr {
+    template <class Key, class Compare = less<Key>>
+      using set = std::set<Key, Compare,
+                           polymorphic_allocator<Key>>;
+
+    template <class Key, class Compare = less<Key>>
+      using multiset = std::multiset<Key, Compare,
+                                     polymorphic_allocator<Key>>;
+  }
 }
 \end{codeblock}
 
@@ -6847,6 +6887,24 @@
   template <class Key, class T, class Hash, class Pred, class Alloc>
     bool operator!=(const unordered_multimap<Key, T, Hash, Pred, Alloc>& a,
                     const unordered_multimap<Key, T, Hash, Pred, Alloc>& b);
+
+  namespace pmr {
+    template <class Key,
+              class T,
+              class Hash = hash<Key>,
+              class Pred = equal_to<Key>>
+      using unordered_map =
+        std::unordered_map<Key, T, Hash, Pred,
+                           polymorphic_allocator<pair<const Key,T>>>;
+    template <class Key,
+              class T,
+              class Hash = hash<Key>,
+              class Pred = equal_to<Key>>
+      using unordered_multimap =
+        std::unordered_multimap<Key, T, Hash, Pred,
+                                polymorphic_allocator<pair<const Key,T>>>;
+
+  }
 }
 \end{codeblock}
 
@@ -6894,6 +6952,20 @@
   template <class Key, class Hash, class Pred, class Alloc>
     bool operator!=(const unordered_multiset<Key, Hash, Pred, Alloc>& a,
                     const unordered_multiset<Key, Hash, Pred, Alloc>& b);
+
+  namespace pmr {
+    template <class Key,
+              class Hash = hash<Key>,
+              class Pred = equal_to<Key>>
+      using unordered_set = std::unordered_set<Key, Hash, Pred,
+                                               polymorphic_allocator<Key>>;
+
+    template <class Key,
+              class Hash = hash<Key>,
+              class Pred = equal_to<Key>>
+      using unordered_multiset = std::unordered_multiset<Key, Hash, Pred,
+                                                         polymorphic_allocator<Key>>;
+  }
 }
 \end{codeblock}
 

source/regex.tex

@@ -635,6 +635,18 @@
   typedef regex_token_iterator<const wchar_t*>          wcregex_token_iterator;
   typedef regex_token_iterator<string::const_iterator>  sregex_token_iterator;
   typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
+
+  namespace pmr {
+    template <class BidirectionalIterator>
+      using match_results =
+        std::match_results<BidirectionalIterator,
+                           polymorphic_allocator<sub_match<BidirectionalIterator>>>;
+
+    typedef match_results<const char*> cmatch;
+    typedef match_results<const wchar_t*> wcmatch;
+    typedef match_results<string::const_iterator> smatch;
+    typedef match_results<wstring::const_iterator> wsmatch;
+  }
 }
 \end{codeblock}
 

source/strings.tex

@@ -801,17 +801,28 @@
   template <> struct hash<u32string>;
   template <> struct hash<wstring>;
 
-inline namespace literals {
-inline namespace string_literals {
-
-  // \ref{basic.string.literals}, suffix for basic_string literals:
-  string    operator "" s(const char* str, size_t len);
-  u16string operator "" s(const char16_t* str, size_t len);
-  u32string operator "" s(const char32_t* str, size_t len);
-  wstring   operator "" s(const wchar_t* str, size_t len);
-
-}
-}
+  namespace pmr {
+    template <class charT, class traits = char_traits<charT>>
+      using basic_string =
+        std::basic_string<charT, traits, polymorphic_allocator<charT>>;
+
+    typedef basic_string<char> string;
+    typedef basic_string<char16_t> u16string;
+    typedef basic_string<char32_t> u32string;
+    typedef basic_string<wchar_t> wstring;
+  }
+
+  inline namespace literals {
+  inline namespace string_literals {
+
+    // \ref{basic.string.literals}, suffix for basic_string literals:
+    string    operator "" s(const char* str, size_t len);
+    u16string operator "" s(const char16_t* str, size_t len);
+    u32string operator "" s(const char32_t* str, size_t len);
+    wstring   operator "" s(const wchar_t* str, size_t len);
+
+  }
+  }
 }
 \end{codeblock}