added header synopses to the reference

doc/modules/ROOT/nav.adoc

@@ -10,20 +10,42 @@
 * xref:benchmarks.adoc[]
 * xref:rationale.adoc[]
 * xref:ref.adoc[]
-** xref:reference/unordered_map.adoc[unordered_map]
-** xref:reference/unordered_multimap.adoc[unordered_multimap]
-** xref:reference/unordered_set.adoc[unordered_set]
-** xref:reference/unordered_multiset.adoc[unordered_multiset]
-** xref:reference/hash_traits.adoc[hash_traits]
+** xref:reference/header_unordered_map_fwd.adoc[`<boost/unordered/unordered_map_fwd.hpp>`]
+** xref:reference/header_unordered_map_top.adoc[`<boost/unordered_map.hpp>`]
+** xref:reference/header_unordered_map.adoc[`<boost/unordered/unordered_map.hpp>`]
+** xref:reference/unordered_map.adoc[`unordered_map`]
+** xref:reference/unordered_multimap.adoc[`unordered_multimap`]
+** xref:reference/header_unordered_set_fwd.adoc[`<boost/unordered/unordered_set_fwd.hpp>`]
+** xref:reference/header_unordered_set_top.adoc[`<boost/unordered_set.hpp>`]
+** xref:reference/header_unordered_set.adoc[`<boost/unordered/unordered_set.hpp>`]
+** xref:reference/unordered_set.adoc[`unordered_set`]
+** xref:reference/unordered_multiset.adoc[`unordered_multiset`]
+** xref:reference/hash_traits.adoc[Hash Traits]
 ** xref:reference/stats.adoc[Statistics]
-** xref:reference/unordered_flat_map.adoc[unordered_flat_map]
-** xref:reference/unordered_flat_set.adoc[unordered_flat_set]
-** xref:reference/unordered_node_map.adoc[unordered_node_map]
-** xref:reference/unordered_node_set.adoc[unordered_node_set]
-** xref:reference/concurrent_flat_map.adoc[concurrent_flat_map]
-** xref:reference/concurrent_flat_set.adoc[concurrent_flat_set]
-** xref:reference/concurrent_node_map.adoc[concurrent_node_map]
-** xref:reference/concurrent_node_set.adoc[concurrent_node_set]
+** xref:reference/header_unordered_flat_map_fwd.adoc[`<boost/unordered/unordered_flat_map_fwd.hpp>`]
+** xref:reference/header_unordered_flat_map.adoc[`<boost/unordered/unordered_flat_map.hpp>`]
+** xref:reference/unordered_flat_map.adoc[`unordered_flat_map`]
+** xref:reference/header_unordered_flat_set_fwd.adoc[`<boost/unordered/unordered_flat_set_fwd.hpp>`]
+** xref:reference/header_unordered_flat_set.adoc[`<boost/unordered/unordered_flat_set.hpp>`]
+** xref:reference/unordered_flat_set.adoc[`unordered_flat_set`]
+** xref:reference/header_unordered_node_map_fwd.adoc[`<boost/unordered/unordered_node_map_fwd.hpp>`]
+** xref:reference/header_unordered_node_map.adoc[`<boost/unordered/unordered_node_map.hpp>`]
+** xref:reference/unordered_node_map.adoc[`unordered_node_map`]
+** xref:reference/header_unordered_node_set_fwd.adoc[`<boost/unordered/unordered_node_set_fwd.hpp>`]
+** xref:reference/header_unordered_node_set.adoc[`<boost/unordered/unordered_node_set.hpp>`]
+** xref:reference/unordered_node_set.adoc[`unordered_node_set`]
+** xref:reference/header_concurrent_flat_map_fwd.adoc[`<boost/unordered/concurrent_flat_map_fwd.hpp>`]
+** xref:reference/header_concurrent_flat_map.adoc[`<boost/unordered/concurrent_flat_map.hpp>`]
+** xref:reference/concurrent_flat_map.adoc[`concurrent_flat_map`]
+** xref:reference/header_concurrent_flat_set_fwd.adoc[`<boost/unordered/concurrent_flat_set_fwd.hpp>`]
+** xref:reference/header_concurrent_flat_set.adoc[`<boost/unordered/concurrent_flat_set.hpp>`]
+** xref:reference/concurrent_flat_set.adoc[`concurrent_flat_set`]
+** xref:reference/header_concurrent_node_map_fwd.adoc[`<boost/unordered/concurrent_node_map_fwd.hpp>`]
+** xref:reference/header_concurrent_node_map.adoc[`<boost/unordered/concurrent_node_map.hpp>`]
+** xref:reference/concurrent_node_map.adoc[`concurrent_node_map`]
+** xref:reference/header_concurrent_node_set_fwd.adoc[`<boost/unordered/concurrent_node_set_fwd.hpp>`]
+** xref:reference/header_concurrent_node_set.adoc[`<boost/unordered/concurrent_node_set.hpp>`]
+** xref:reference/concurrent_node_set.adoc[`concurrent_node_set`]
 * xref:changes.adoc[]
 * xref:bibliography.adoc[]
 * xref:copyright.adoc[]

doc/modules/ROOT/pages/changes.adoc

@@ -6,6 +6,10 @@
 :github-pr-url: https://github.com/boostorg/unordered/pull
 :cpp: C++
 
+== Release 1.88.0
+
+* Migrated the documentation to a multipage format using Antora.
+
 == Release 1.87.0 - Major update
 
 * Added concurrent, node-based containers `boost::concurrent_node_map` and `boost::concurrent_node_set`.

doc/modules/ROOT/pages/copyright.adoc

@@ -9,9 +9,9 @@ Copyright (C) 2003, 2004 Jeremy B. Maitin-Shepard
 
 Copyright (C) 2005-2008 Daniel James
 
-Copyright (C) 2022-2023 Christian Mazakas
+Copyright (C) 2022-2025 Christian Mazakas
 
-Copyright (C) 2022-2024 Joaquín M López Muñoz
+Copyright (C) 2022-2025 Joaquín M López Muñoz
 
 Copyright (C) 2022-2023 Peter Dimov
 

doc/modules/ROOT/pages/ref.adoc

@@ -1,17 +1,39 @@
 [#reference]
 = Reference
 
-* xref:reference/unordered_map.adoc[unordered_map]
-* xref:reference/unordered_multimap.adoc[unordered_multimap]
-* xref:reference/unordered_set.adoc[unordered_set]
-* xref:reference/unordered_multiset.adoc[unordered_multiset]
-* xref:reference/hash_traits.adoc[hash_traits]
+* xref:reference/header_unordered_map_fwd.adoc[`<boost/unordered/unordered_map_fwd.hpp>` Synopsis]
+* xref:reference/header_unordered_map_top.adoc[`<boost/unordered_map.hpp>` Synopsis]
+* xref:reference/header_unordered_map.adoc[`<boost/unordered/unordered_map.hpp>` Synopsis]
+* xref:reference/unordered_map.adoc[Class Template `unordered_map`]
+* xref:reference/unordered_multimap.adoc[Class Template `unordered_multimap`]
+* xref:reference/header_unordered_set_fwd.adoc[`<boost/unordered/unordered_set_fwd.hpp>` Synopsis]
+* xref:reference/header_unordered_set_top.adoc[`<boost/unordered_set.hpp>` Synopsis]
+* xref:reference/header_unordered_set.adoc[`<boost/unordered/unordered_set.hpp>` Synopsis]
+* xref:reference/unordered_set.adoc[Class Template `unordered_set`]
+* xref:reference/unordered_multiset.adoc[Class Template `unordered_multiset`]
+* xref:reference/hash_traits.adoc[Hash Traits]
 * xref:reference/stats.adoc[Statistics]
-* xref:reference/unordered_flat_map.adoc[unordered_flat_map]
-* xref:reference/unordered_flat_set.adoc[unordered_flat_set]
-* xref:reference/unordered_node_map.adoc[unordered_node_map]
-* xref:reference/unordered_node_set.adoc[unordered_node_set]
-* xref:reference/concurrent_flat_map.adoc[concurrent_flat_map]
-* xref:reference/concurrent_flat_set.adoc[concurrent_flat_set]
-* xref:reference/concurrent_node_map.adoc[concurrent_node_map]
-* xref:reference/concurrent_node_set.adoc[concurrent_node_set]
+* xref:reference/header_unordered_flat_map_fwd.adoc[`<boost/unordered/unordered_flat_map_fwd.hpp>` Synopsis]
+* xref:reference/header_unordered_flat_map.adoc[`<boost/unordered/unordered_flat_map.hpp>` Synopsis]
+* xref:reference/unordered_flat_map.adoc[Class Template `unordered_flat_map`]
+* xref:reference/header_unordered_flat_set_fwd.adoc[`<boost/unordered/unordered_flat_set_fwd.hpp>` Synopsis]
+* xref:reference/header_unordered_flat_set.adoc[`<boost/unordered/unordered_flat_set.hpp>` Synopsis]
+* xref:reference/unordered_flat_set.adoc[Class Template `unordered_flat_set`]
+* xref:reference/header_unordered_node_map_fwd.adoc[`<boost/unordered/unordered_node_map_fwd.hpp>` Synopsis]
+* xref:reference/header_unordered_node_map.adoc[`<boost/unordered/unordered_node_map.hpp>` Synopsis]
+* xref:reference/unordered_node_map.adoc[Class Template `unordered_node_map`]
+* xref:reference/header_unordered_node_set_fwd.adoc[`<boost/unordered/unordered_node_set_fwd.hpp>` Synopsis]
+* xref:reference/header_unordered_node_set.adoc[`<boost/unordered/unordered_node_set.hpp>` Synopsis]
+* xref:reference/unordered_node_set.adoc[Class Template `unordered_node_set`]
+* xref:reference/header_concurrent_flat_map_fwd.adoc[`<boost/unordered/concurrent_flat_map_fwd.hpp>` Synopsis]
+* xref:reference/header_concurrent_flat_map.adoc[`<boost/unordered/concurrent_flat_map.hpp>` Synopsis]
+* xref:reference/concurrent_flat_map.adoc[Class Template `concurrent_flat_map`]
+* xref:reference/header_concurrent_flat_set_fwd.adoc[`<boost/unordered/concurrent_flat_set_fwd.hpp>` Synopsis]
+* xref:reference/header_concurrent_flat_set.adoc[`<boost/unordered/concurrent_flat_set.hpp>` Synopsis]
+* xref:reference/concurrent_flat_set.adoc[Class Template `concurrent_flat_set`]
+* xref:reference/header_concurrent_node_map_fwd.adoc[`<boost/unordered/concurrent_node_map_fwd.hpp>` Synopsis]
+* xref:reference/header_concurrent_node_map.adoc[`<boost/unordered/concurrent_node_map.hpp>` Synopsis]
+* xref:reference/concurrent_node_map.adoc[Class Template `concurrent_node_map`]
+* xref:reference/header_concurrent_node_set_fwd.adoc[`<boost/unordered/concurrent_node_set_fwd.hpp>` Synopsis]
+* xref:reference/header_concurrent_node_set.adoc[`<boost/unordered/concurrent_node_set.hpp>` Synopsis]
+* xref:reference/concurrent_node_set.adoc[Class Template `concurrent_node_set`]

doc/modules/ROOT/pages/reference/concurrent_flat_map.adoc

@@ -22,9 +22,11 @@ The internal data structure of `boost::concurrent_flat_map` is similar to that o
 
 [listing,subs="+macros,+quotes"]
 -----
-// #include <boost/unordered/concurrent_flat_map.hpp>
+// #include xref:reference/header_concurrent_flat_map.adoc[`<boost/unordered/concurrent_flat_map.hpp>`]
 
 namespace boost {
+namespace unordered {
+
   template<class Key,
            class T,
            class Hash = boost::hash<Key>,
@@ -320,37 +322,8 @@ namespace boost {
                         Hash, Allocator)
       -> concurrent_flat_map<Key, T, Hash, std::equal_to<Key>, Allocator>;
 
-  // Equality Comparisons
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    bool xref:#concurrent_flat_map_operator[operator==](const concurrent_flat_map<Key, T, Hash, Pred, Alloc>& x,
-                    const concurrent_flat_map<Key, T, Hash, Pred, Alloc>& y);
-
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    bool xref:#concurrent_flat_map_operator_2[operator!=](const concurrent_flat_map<Key, T, Hash, Pred, Alloc>& x,
-                    const concurrent_flat_map<Key, T, Hash, Pred, Alloc>& y);
-
-  // swap
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    void xref:#concurrent_flat_map_swap_2[swap](concurrent_flat_map<Key, T, Hash, Pred, Alloc>& x,
-              concurrent_flat_map<Key, T, Hash, Pred, Alloc>& y)
-      noexcept(noexcept(x.swap(y)));
-
-  // Erasure
-  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>>>;
-  }
-}
+} // namespace unordered
+} // namespace boost
 -----
 
 ---

doc/modules/ROOT/pages/reference/concurrent_flat_set.adoc

@@ -22,9 +22,11 @@ The internal data structure of `boost::concurrent_flat_set` is similar to that o
 
 [listing,subs="+macros,+quotes"]
 -----
-// #include <boost/unordered/concurrent_flat_set.hpp>
+// #include xref:reference/header_concurrent_flat_set.adoc[`<boost/unordered/concurrent_flat_set.hpp>`]
 
 namespace boost {
+namespace unordered {
+
   template<class Key,
            class Hash = boost::hash<Key>,
            class Pred = std::equal_to<Key>,
@@ -270,36 +272,8 @@ namespace boost {
     concurrent_flat_set(std::initializer_list<T>, typename xref:#concurrent_flat_set_deduction_guides[__see below__]::size_type, Hash, Allocator)
       -> concurrent_flat_set<T, Hash, std::equal_to<T>, Allocator>;
 
-  // Equality Comparisons
-  template<class Key, class Hash, class Pred, class Alloc>
-    bool xref:#concurrent_flat_set_operator[operator==](const concurrent_flat_set<Key, Hash, Pred, Alloc>& x,
-                    const concurrent_flat_set<Key, Hash, Pred, Alloc>& y);
-
-  template<class Key, class Hash, class Pred, class Alloc>
-    bool xref:#concurrent_flat_set_operator_2[operator!=](const concurrent_flat_set<Key, Hash, Pred, Alloc>& x,
-                    const concurrent_flat_set<Key, Hash, Pred, Alloc>& y);
-
-  // swap
-  template<class Key, class Hash, class Pred, class Alloc>
-    void xref:#concurrent_flat_set_swap_2[swap](concurrent_flat_set<Key, Hash, Pred, Alloc>& x,
-              concurrent_flat_set<Key, Hash, Pred, Alloc>& y)
-      noexcept(noexcept(x.swap(y)));
-
-  // Erasure
-  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>>;
-  }
-}
+} // namespace unordered
+} // namespace boost
 -----
 
 ---

doc/modules/ROOT/pages/reference/concurrent_node_map.adoc

@@ -22,9 +22,11 @@ node handling functionalities are provided, at the expense of potentially lower
 
 [listing,subs="+macros,+quotes"]
 -----
-// #include <boost/unordered/concurrent_node_map.hpp>
+// #include xref:reference/header_concurrent_node_map.adoc[`<boost/unordered/concurrent_node_map.hpp>`]
 
 namespace boost {
+namespace unordered {
+
   template<class Key,
            class T,
            class Hash = boost::hash<Key>,
@@ -338,37 +340,8 @@ namespace boost {
                         Hash, Allocator)
       -> concurrent_node_map<Key, T, Hash, std::equal_to<Key>, Allocator>;
 
-  // Equality Comparisons
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    bool xref:#concurrent_node_map_operator[operator==](const concurrent_node_map<Key, T, Hash, Pred, Alloc>& x,
-                    const concurrent_node_map<Key, T, Hash, Pred, Alloc>& y);
-
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    bool xref:#concurrent_node_map_operator_2[operator!=](const concurrent_node_map<Key, T, Hash, Pred, Alloc>& x,
-                    const concurrent_node_map<Key, T, Hash, Pred, Alloc>& y);
-
-  // swap
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    void xref:#concurrent_node_map_swap_2[swap](concurrent_node_map<Key, T, Hash, Pred, Alloc>& x,
-              concurrent_node_map<Key, T, Hash, Pred, Alloc>& y)
-      noexcept(noexcept(x.swap(y)));
-
-  // Erasure
-  template<class K, class T, class H, class P, class A, class Predicate>
-    typename concurrent_node_map<K, T, H, P, A>::size_type
-       xref:#concurrent_node_map_erase_if_2[erase_if](concurrent_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 concurrent_node_map =
-      boost::concurrent_node_map<Key, T, Hash, Pred,
-        std::pmr::polymorphic_allocator<std::pair<const Key, T>>>;
-  }
-}
+} // namespace unordered
+} // namespace boost
 -----
 
 ---

doc/modules/ROOT/pages/reference/concurrent_node_set.adoc

@@ -22,9 +22,11 @@ node handling functionalities are provided, at the expense of potentially lower
 
 [listing,subs="+macros,+quotes"]
 -----
-// #include <boost/unordered/concurrent_node_set.hpp>
+// #include xref:reference/header_concurrent_node_set.adoc[`<boost/unordered/concurrent_node_set.hpp>`]
 
 namespace boost {
+namespace unordered {
+
   template<class Key,
            class Hash = boost::hash<Key>,
            class Pred = std::equal_to<Key>,
@@ -287,36 +289,8 @@ namespace boost {
     concurrent_node_set(std::initializer_list<T>, typename xref:#concurrent_node_set_deduction_guides[__see below__]::size_type, Hash, Allocator)
       -> concurrent_node_set<T, Hash, std::equal_to<T>, Allocator>;
 
-  // Equality Comparisons
-  template<class Key, class Hash, class Pred, class Alloc>
-    bool xref:#concurrent_node_set_operator[operator==](const concurrent_node_set<Key, Hash, Pred, Alloc>& x,
-                    const concurrent_node_set<Key, Hash, Pred, Alloc>& y);
-
-  template<class Key, class Hash, class Pred, class Alloc>
-    bool xref:#concurrent_node_set_operator_2[operator!=](const concurrent_node_set<Key, Hash, Pred, Alloc>& x,
-                    const concurrent_node_set<Key, Hash, Pred, Alloc>& y);
-
-  // swap
-  template<class Key, class Hash, class Pred, class Alloc>
-    void xref:#concurrent_node_set_swap_2[swap](concurrent_node_set<Key, Hash, Pred, Alloc>& x,
-              concurrent_node_set<Key, Hash, Pred, Alloc>& y)
-      noexcept(noexcept(x.swap(y)));
-
-  // Erasure
-  template<class K, class H, class P, class A, class Predicate>
-    typename concurrent_node_set<K, H, P, A>::size_type
-       xref:#concurrent_node_set_erase_if_2[erase_if](concurrent_node_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_node_set =
-      boost::concurrent_node_set<Key, Hash, Pred,
-        std::pmr::polymorphic_allocator<Key>>;
-  }
-}
+} // namespace unordered
+} // namespace boost
 -----
 
 ---

doc/modules/ROOT/pages/reference/hash_traits.adoc

@@ -1,14 +1,12 @@
 [#hash_traits]
-== Hash traits
+== Hash Traits
 
 :idprefix: hash_traits_
 
-=== Synopsis
+=== `<boost/unordered/hash_traits.hpp>` Synopsis
 
 [listing,subs="+macros,+quotes"]
 -----
-// #include <boost/unordered/hash_traits.hpp>
-
 namespace boost {
 namespace unordered {