Update docs

doc/unordered/changes.adoc

@@ -6,6 +6,10 @@
 :github-pr-url: https://github.com/boostorg/unordered/pull
 :cpp: C++
 
+== Release 1.86.0
+
+* Added container `pmr` aliases when header `<memory_resource>` is available. The alias `boost::unordered::pmr::[container]` refers to `boost::unordered::[container]` with a `std::pmr::polymorphic_allocator` allocator type.
+
 == Release 1.85.0
 
 * Optimized `emplace()` for a `value_type` or `init_type` (if applicable) argument to bypass creating an intermediate object. The argument is already the same type as the would-be intermediate object.

doc/unordered/concurrent_flat_map.adoc

@@ -299,6 +299,17 @@ namespace boost {
   template<class K, class T, class H, class P, class A, class Predicate>
     typename concurrent_flat_map<K, T, H, P, A>::size_type
        xref:#concurrent_flat_map_erase_if_2[erase_if](concurrent_flat_map<K, T, H, P, A>& c, Predicate pred);
+
+  // Pmr aliases (C++17 and up)
+  namespace unordered::pmr {
+    template<class Key,
+             class T,
+             class Hash = boost::hash<Key>,
+             class Pred = std::equal_to<Key>>
+    using concurrent_flat_map =
+      boost::concurrent_flat_map<Key, T, Hash, Pred,
+        std::pmr::polymorphic_allocator<std::pair<const Key, T>>>;
+  }
 }
 -----
 

doc/unordered/concurrent_flat_set.adoc

@@ -254,6 +254,16 @@ namespace boost {
   template<class K, class H, class P, class A, class Predicate>
     typename concurrent_flat_set<K, H, P, A>::size_type
        xref:#concurrent_flat_set_erase_if_2[erase_if](concurrent_flat_set<K, H, P, A>& c, Predicate pred);
+
+  // Pmr aliases (C++17 and up)
+  namespace unordered::pmr {
+    template<class Key,
+             class Hash = boost::hash<Key>,
+             class Pred = std::equal_to<Key>>
+    using concurrent_flat_set =
+      boost::concurrent_flat_set<Key, Hash, Pred,
+        std::pmr::polymorphic_allocator<Key>>;
+  }
 }
 -----
 

doc/unordered/unordered_flat_map.adoc

@@ -285,6 +285,17 @@ namespace boost {
   template<class K, class T, class H, class P, class A, class Predicate>
     typename unordered_flat_map<K, T, H, P, A>::size_type
        xref:#unordered_flat_map_erase_if[erase_if](unordered_flat_map<K, T, H, P, A>& c, Predicate pred);
+
+  // Pmr aliases (C++17 and up)
+  namespace unordered::pmr {
+    template<class Key,
+             class T,
+             class Hash = boost::hash<Key>,
+             class Pred = std::equal_to<Key>>
+    using unordered_flat_map =
+      boost::unordered_flat_map<Key, T, Hash, Pred,
+        std::pmr::polymorphic_allocator<std::pair<const Key, T>>>;
+  }
 }
 -----
 

doc/unordered/unordered_flat_set.adoc

@@ -238,6 +238,16 @@ namespace boost {
   template<class K, class T, class H, class P, class A, class Predicate>
     typename unordered_flat_set<K, T, H, P, A>::size_type
        xref:#unordered_flat_set_erase_if[erase_if](unordered_flat_set<K, T, H, P, A>& c, Predicate pred);
+
+  // Pmr aliases (C++17 and up)
+  namespace unordered::pmr {
+    template<class Key,
+             class Hash = boost::hash<Key>,
+             class Pred = std::equal_to<Key>>
+    using unordered_flat_set =
+      boost::unordered_flat_set<Key, Hash, Pred,
+        std::pmr::polymorphic_allocator<Key>>;
+  }
 }
 -----
 

doc/unordered/unordered_map.adoc

@@ -290,6 +290,17 @@ namespace boost {
   template<class K, class T, class H, class P, class A, class Predicate>
     typename unordered_map<K, T, H, P, A>::size_type
        xref:#unordered_map_erase_if[erase_if](unordered_map<K, T, H, P, A>& c, Predicate pred);
+
+  // Pmr aliases (C++17 and up)
+  namespace unordered::pmr {
+    template<class Key,
+             class T,
+             class Hash = boost::hash<Key>,
+             class Pred = std::equal_to<Key>>
+    using unordered_map =
+      boost::unordered_map<Key, T, Hash, Pred,
+        std::pmr::polymorphic_allocator<std::pair<const Key, T>>>;
+  }
 }
 -----
 

doc/unordered/unordered_multimap.adoc

@@ -257,6 +257,17 @@ namespace boost {
   template<class K, class T, class H, class P, class A, class Predicate>
     typename unordered_multimap<K, T, H, P, A>::size_type
       xref:#unordered_multimap_erase_if[erase_if](unordered_multimap<K, T, H, P, A>& c, Predicate pred);
+
+  // Pmr aliases (C++17 and up)
+  namespace unordered::pmr {
+    template<class Key,
+             class T,
+             class Hash = boost::hash<Key>,
+             class Pred = std::equal_to<Key>>
+    using unordered_multimap =
+      boost::unordered_multimap<Key, T, Hash, Pred,
+        std::pmr::polymorphic_allocator<std::pair<const Key, T>>>;
+  }
 }
 -----
 

doc/unordered/unordered_multiset.adoc

@@ -248,6 +248,16 @@ namespace boost {
   template<class K, class H, class P, class A, class Predicate>
     typename unordered_multiset<K, H, P, A>::size_type
       xref:#unordered_multiset_erase_if[erase_if](unordered_multiset<K, H, P, A>& c, Predicate pred);
+      
+  // Pmr aliases (C++17 and up)
+  namespace unordered::pmr {
+    template<class Key,
+             class Hash = boost::hash<Key>,
+             class Pred = std::equal_to<Key>>
+    using unordered_multiset =
+      boost::unordered_multiset<Key, Hash, Pred,
+        std::pmr::polymorphic_allocator<Key>>;
+  }
 }
 -----
 

doc/unordered/unordered_node_map.adoc

@@ -288,6 +288,17 @@ namespace boost {
   template<class K, class T, class H, class P, class A, class Predicate>
     typename unordered_node_map<K, T, H, P, A>::size_type
        xref:#unordered_node_map_erase_if[erase_if](unordered_node_map<K, T, H, P, A>& c, Predicate pred);
+
+  // Pmr aliases (C++17 and up)
+  namespace unordered::pmr {
+    template<class Key,
+             class T,
+             class Hash = boost::hash<Key>,
+             class Pred = std::equal_to<Key>>
+    using unordered_node_map =
+      boost::unordered_node_map<Key, T, Hash, Pred,
+        std::pmr::polymorphic_allocator<std::pair<const Key, T>>>;
+  }
 }
 -----
 

doc/unordered/unordered_node_set.adoc

@@ -242,6 +242,16 @@ namespace boost {
   template<class K, class T, class H, class P, class A, class Predicate>
     typename unordered_node_set<K, T, H, P, A>::size_type
        xref:#unordered_node_set_erase_if[erase_if](unordered_node_set<K, T, H, P, A>& c, Predicate pred);
+
+  // Pmr aliases (C++17 and up)
+  namespace unordered::pmr {
+    template<class Key,
+             class Hash = boost::hash<Key>,
+             class Pred = std::equal_to<Key>>
+    using unordered_node_set =
+      boost::unordered_node_set<Key, Hash, Pred,
+        std::pmr::polymorphic_allocator<Key>>;
+  }
 }
 -----
 

doc/unordered/unordered_set.adoc

@@ -249,6 +249,16 @@ namespace boost {
   template<class K, class H, class P, class A, class Predicate>
     typename unordered_set<K, H, P, A>::size_type
       xref:#unordered_set_erase_if[erase_if](unordered_set<K, H, P, A>& c, Predicate pred);
+
+  // Pmr aliases (C++17 and up)
+  namespace unordered::pmr {
+    template<class Key,
+             class Hash = boost::hash<Key>,
+             class Pred = std::equal_to<Key>>
+    using unordered_set =
+      boost::unordered_set<Key, Hash, Pred,
+        std::pmr::polymorphic_allocator<Key>>;
+  }
 }
 -----