Skip to content

Commit 87d9299

Browse files
joaquintidesjoaquintides
authored
added header synopses to the reference (#303)
* added header synopses to the reference * disabled font color override for in-link code portions * relinked bundle
1 parent 17ab97d commit 87d9299

40 files changed

Lines changed: 871 additions & 413 deletions

‎doc/modules/ROOT/nav.adoc‎

Lines changed: 35 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -10,20 +10,42 @@
1010
* xref:benchmarks.adoc[]
1111
* xref:rationale.adoc[]
1212
* xref:ref.adoc[]
13-
** xref:reference/unordered_map.adoc[unordered_map]
14-
** xref:reference/unordered_multimap.adoc[unordered_multimap]
15-
** xref:reference/unordered_set.adoc[unordered_set]
16-
** xref:reference/unordered_multiset.adoc[unordered_multiset]
17-
** xref:reference/hash_traits.adoc[hash_traits]
13+
** xref:reference/header_unordered_map_fwd.adoc[`<boost/unordered/unordered_map_fwd.hpp>`]
14+
** xref:reference/header_unordered_map_top.adoc[`<boost/unordered_map.hpp>`]
15+
** xref:reference/header_unordered_map.adoc[`<boost/unordered/unordered_map.hpp>`]
16+
** xref:reference/unordered_map.adoc[`unordered_map`]
17+
** xref:reference/unordered_multimap.adoc[`unordered_multimap`]
18+
** xref:reference/header_unordered_set_fwd.adoc[`<boost/unordered/unordered_set_fwd.hpp>`]
19+
** xref:reference/header_unordered_set_top.adoc[`<boost/unordered_set.hpp>`]
20+
** xref:reference/header_unordered_set.adoc[`<boost/unordered/unordered_set.hpp>`]
21+
** xref:reference/unordered_set.adoc[`unordered_set`]
22+
** xref:reference/unordered_multiset.adoc[`unordered_multiset`]
23+
** xref:reference/hash_traits.adoc[Hash Traits]
1824
** xref:reference/stats.adoc[Statistics]
19-
** xref:reference/unordered_flat_map.adoc[unordered_flat_map]
20-
** xref:reference/unordered_flat_set.adoc[unordered_flat_set]
21-
** xref:reference/unordered_node_map.adoc[unordered_node_map]
22-
** xref:reference/unordered_node_set.adoc[unordered_node_set]
23-
** xref:reference/concurrent_flat_map.adoc[concurrent_flat_map]
24-
** xref:reference/concurrent_flat_set.adoc[concurrent_flat_set]
25-
** xref:reference/concurrent_node_map.adoc[concurrent_node_map]
26-
** xref:reference/concurrent_node_set.adoc[concurrent_node_set]
25+
** xref:reference/header_unordered_flat_map_fwd.adoc[`<boost/unordered/unordered_flat_map_fwd.hpp>`]
26+
** xref:reference/header_unordered_flat_map.adoc[`<boost/unordered/unordered_flat_map.hpp>`]
27+
** xref:reference/unordered_flat_map.adoc[`unordered_flat_map`]
28+
** xref:reference/header_unordered_flat_set_fwd.adoc[`<boost/unordered/unordered_flat_set_fwd.hpp>`]
29+
** xref:reference/header_unordered_flat_set.adoc[`<boost/unordered/unordered_flat_set.hpp>`]
30+
** xref:reference/unordered_flat_set.adoc[`unordered_flat_set`]
31+
** xref:reference/header_unordered_node_map_fwd.adoc[`<boost/unordered/unordered_node_map_fwd.hpp>`]
32+
** xref:reference/header_unordered_node_map.adoc[`<boost/unordered/unordered_node_map.hpp>`]
33+
** xref:reference/unordered_node_map.adoc[`unordered_node_map`]
34+
** xref:reference/header_unordered_node_set_fwd.adoc[`<boost/unordered/unordered_node_set_fwd.hpp>`]
35+
** xref:reference/header_unordered_node_set.adoc[`<boost/unordered/unordered_node_set.hpp>`]
36+
** xref:reference/unordered_node_set.adoc[`unordered_node_set`]
37+
** xref:reference/header_concurrent_flat_map_fwd.adoc[`<boost/unordered/concurrent_flat_map_fwd.hpp>`]
38+
** xref:reference/header_concurrent_flat_map.adoc[`<boost/unordered/concurrent_flat_map.hpp>`]
39+
** xref:reference/concurrent_flat_map.adoc[`concurrent_flat_map`]
40+
** xref:reference/header_concurrent_flat_set_fwd.adoc[`<boost/unordered/concurrent_flat_set_fwd.hpp>`]
41+
** xref:reference/header_concurrent_flat_set.adoc[`<boost/unordered/concurrent_flat_set.hpp>`]
42+
** xref:reference/concurrent_flat_set.adoc[`concurrent_flat_set`]
43+
** xref:reference/header_concurrent_node_map_fwd.adoc[`<boost/unordered/concurrent_node_map_fwd.hpp>`]
44+
** xref:reference/header_concurrent_node_map.adoc[`<boost/unordered/concurrent_node_map.hpp>`]
45+
** xref:reference/concurrent_node_map.adoc[`concurrent_node_map`]
46+
** xref:reference/header_concurrent_node_set_fwd.adoc[`<boost/unordered/concurrent_node_set_fwd.hpp>`]
47+
** xref:reference/header_concurrent_node_set.adoc[`<boost/unordered/concurrent_node_set.hpp>`]
48+
** xref:reference/concurrent_node_set.adoc[`concurrent_node_set`]
2749
* xref:changes.adoc[]
2850
* xref:bibliography.adoc[]
2951
* xref:copyright.adoc[]

‎doc/modules/ROOT/pages/changes.adoc‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,10 @@
66
:github-pr-url: https://github.com/boostorg/unordered/pull
77
:cpp: C++
88

9+
== Release 1.88.0
10+
11+
* Migrated the documentation to a multipage format using Antora.
12+
913
== Release 1.87.0 - Major update
1014

1115
* Added concurrent, node-based containers `boost::concurrent_node_map` and `boost::concurrent_node_set`.

‎doc/modules/ROOT/pages/copyright.adoc‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -9,9 +9,9 @@ Copyright (C) 2003, 2004 Jeremy B. Maitin-Shepard
99

1010
Copyright (C) 2005-2008 Daniel James
1111

12-
Copyright (C) 2022-2023 Christian Mazakas
12+
Copyright (C) 2022-2025 Christian Mazakas
1313

14-
Copyright (C) 2022-2024 Joaqu&iacute;n M L&oacute;pez Mu&ntilde;oz
14+
Copyright (C) 2022-2025 Joaqu&iacute;n M L&oacute;pez Mu&ntilde;oz
1515

1616
Copyright (C) 2022-2023 Peter Dimov
1717

‎doc/modules/ROOT/pages/ref.adoc‎

Lines changed: 35 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -1,17 +1,39 @@
11
[#reference]
22
= Reference
33

4-
* xref:reference/unordered_map.adoc[unordered_map]
5-
* xref:reference/unordered_multimap.adoc[unordered_multimap]
6-
* xref:reference/unordered_set.adoc[unordered_set]
7-
* xref:reference/unordered_multiset.adoc[unordered_multiset]
8-
* xref:reference/hash_traits.adoc[hash_traits]
4+
* xref:reference/header_unordered_map_fwd.adoc[+++<code style="color: inherit;">+++<boost/unordered/unordered_map_fwd.hpp>+++</code>+++ Synopsis]
5+
* xref:reference/header_unordered_map_top.adoc[+++<code style="color: inherit;">+++<boost/unordered_map.hpp>+++</code>+++ Synopsis]
6+
* xref:reference/header_unordered_map.adoc[+++<code style="color: inherit;">+++<boost/unordered/unordered_map.hpp>+++</code>+++ Synopsis]
7+
* xref:reference/unordered_map.adoc[Class Template +++<code style="color: inherit;">+++unordered_map+++</code>+++]
8+
* xref:reference/unordered_multimap.adoc[Class Template +++<code style="color: inherit;">+++unordered_multimap+++</code>+++]
9+
* xref:reference/header_unordered_set_fwd.adoc[+++<code style="color: inherit;">+++<boost/unordered/unordered_set_fwd.hpp>+++</code>+++ Synopsis]
10+
* xref:reference/header_unordered_set_top.adoc[+++<code style="color: inherit;">+++<boost/unordered_set.hpp>+++</code>+++ Synopsis]
11+
* xref:reference/header_unordered_set.adoc[+++<code style="color: inherit;">+++<boost/unordered/unordered_set.hpp>+++</code>+++ Synopsis]
12+
* xref:reference/unordered_set.adoc[Class Template +++<code style="color: inherit;">+++unordered_set+++</code>+++]
13+
* xref:reference/unordered_multiset.adoc[Class Template +++<code style="color: inherit;">+++unordered_multiset+++</code>+++]
14+
* xref:reference/hash_traits.adoc[Hash Traits]
915
* xref:reference/stats.adoc[Statistics]
10-
* xref:reference/unordered_flat_map.adoc[unordered_flat_map]
11-
* xref:reference/unordered_flat_set.adoc[unordered_flat_set]
12-
* xref:reference/unordered_node_map.adoc[unordered_node_map]
13-
* xref:reference/unordered_node_set.adoc[unordered_node_set]
14-
* xref:reference/concurrent_flat_map.adoc[concurrent_flat_map]
15-
* xref:reference/concurrent_flat_set.adoc[concurrent_flat_set]
16-
* xref:reference/concurrent_node_map.adoc[concurrent_node_map]
17-
* xref:reference/concurrent_node_set.adoc[concurrent_node_set]
16+
* xref:reference/header_unordered_flat_map_fwd.adoc[+++<code style="color: inherit;">+++<boost/unordered/unordered_flat_map_fwd.hpp>+++</code>+++ Synopsis]
17+
* xref:reference/header_unordered_flat_map.adoc[+++<code style="color: inherit;">+++<boost/unordered/unordered_flat_map.hpp>+++</code>+++ Synopsis]
18+
* xref:reference/unordered_flat_map.adoc[Class Template +++<code style="color: inherit;">+++unordered_flat_map+++</code>+++]
19+
* xref:reference/header_unordered_flat_set_fwd.adoc[+++<code style="color: inherit;">+++<boost/unordered/unordered_flat_set_fwd.hpp>+++</code>+++ Synopsis]
20+
* xref:reference/header_unordered_flat_set.adoc[+++<code style="color: inherit;">+++<boost/unordered/unordered_flat_set.hpp>+++</code>+++ Synopsis]
21+
* xref:reference/unordered_flat_set.adoc[Class Template +++<code style="color: inherit;">+++unordered_flat_set+++</code>+++]
22+
* xref:reference/header_unordered_node_map_fwd.adoc[+++<code style="color: inherit;">+++<boost/unordered/unordered_node_map_fwd.hpp>+++</code>+++ Synopsis]
23+
* xref:reference/header_unordered_node_map.adoc[+++<code style="color: inherit;">+++<boost/unordered/unordered_node_map.hpp>+++</code>+++ Synopsis]
24+
* xref:reference/unordered_node_map.adoc[Class Template +++<code style="color: inherit;">+++unordered_node_map+++</code>+++]
25+
* xref:reference/header_unordered_node_set_fwd.adoc[+++<code style="color: inherit;">+++<boost/unordered/unordered_node_set_fwd.hpp>+++</code>+++ Synopsis]
26+
* xref:reference/header_unordered_node_set.adoc[+++<code style="color: inherit;">+++<boost/unordered/unordered_node_set.hpp>+++</code>+++ Synopsis]
27+
* xref:reference/unordered_node_set.adoc[Class Template +++<code style="color: inherit;">+++unordered_node_set+++</code>+++]
28+
* xref:reference/header_concurrent_flat_map_fwd.adoc[+++<code style="color: inherit;">+++<boost/unordered/concurrent_flat_map_fwd.hpp>+++</code>+++ Synopsis]
29+
* xref:reference/header_concurrent_flat_map.adoc[+++<code style="color: inherit;">+++<boost/unordered/concurrent_flat_map.hpp>+++</code>+++ Synopsis]
30+
* xref:reference/concurrent_flat_map.adoc[Class Template +++<code style="color: inherit;">+++concurrent_flat_map+++</code>+++]
31+
* xref:reference/header_concurrent_flat_set_fwd.adoc[+++<code style="color: inherit;">+++<boost/unordered/concurrent_flat_set_fwd.hpp>+++</code>+++ Synopsis]
32+
* xref:reference/header_concurrent_flat_set.adoc[+++<code style="color: inherit;">+++<boost/unordered/concurrent_flat_set.hpp>+++</code>+++ Synopsis]
33+
* xref:reference/concurrent_flat_set.adoc[Class Template +++<code style="color: inherit;">+++concurrent_flat_set+++</code>+++]
34+
* xref:reference/header_concurrent_node_map_fwd.adoc[+++<code style="color: inherit;">+++<boost/unordered/concurrent_node_map_fwd.hpp>+++</code>+++ Synopsis]
35+
* xref:reference/header_concurrent_node_map.adoc[+++<code style="color: inherit;">+++<boost/unordered/concurrent_node_map.hpp>+++</code>+++ Synopsis]
36+
* xref:reference/concurrent_node_map.adoc[Class Template +++<code style="color: inherit;">+++concurrent_node_map+++</code>+++]
37+
* xref:reference/header_concurrent_node_set_fwd.adoc[+++<code style="color: inherit;">+++<boost/unordered/concurrent_node_set_fwd.hpp>+++</code>+++ Synopsis]
38+
* xref:reference/header_concurrent_node_set.adoc[+++<code style="color: inherit;">+++<boost/unordered/concurrent_node_set.hpp>+++</code>+++ Synopsis]
39+
* xref:reference/concurrent_node_set.adoc[Class Template +++<code style="color: inherit;">+++concurrent_node_set+++</code>+++]

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

Lines changed: 5 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -22,9 +22,11 @@ The internal data structure of `boost::concurrent_flat_map` is similar to that o
2222

2323
[listing,subs="+macros,+quotes"]
2424
-----
25-
// #include <boost/unordered/concurrent_flat_map.hpp>
25+
// #include xref:reference/header_concurrent_flat_map.adoc[`<boost/unordered/concurrent_flat_map.hpp>`]
2626
2727
namespace boost {
28+
namespace unordered {
29+
2830
template<class Key,
2931
class T,
3032
class Hash = boost::hash<Key>,
@@ -320,37 +322,8 @@ namespace boost {
320322
Hash, Allocator)
321323
-> concurrent_flat_map<Key, T, Hash, std::equal_to<Key>, Allocator>;
322324
323-
// Equality Comparisons
324-
template<class Key, class T, class Hash, class Pred, class Alloc>
325-
bool xref:#concurrent_flat_map_operator[operator==](const concurrent_flat_map<Key, T, Hash, Pred, Alloc>& x,
326-
const concurrent_flat_map<Key, T, Hash, Pred, Alloc>& y);
327-
328-
template<class Key, class T, class Hash, class Pred, class Alloc>
329-
bool xref:#concurrent_flat_map_operator_2[operator!=](const concurrent_flat_map<Key, T, Hash, Pred, Alloc>& x,
330-
const concurrent_flat_map<Key, T, Hash, Pred, Alloc>& y);
331-
332-
// swap
333-
template<class Key, class T, class Hash, class Pred, class Alloc>
334-
void xref:#concurrent_flat_map_swap_2[swap](concurrent_flat_map<Key, T, Hash, Pred, Alloc>& x,
335-
concurrent_flat_map<Key, T, Hash, Pred, Alloc>& y)
336-
noexcept(noexcept(x.swap(y)));
337-
338-
// Erasure
339-
template<class K, class T, class H, class P, class A, class Predicate>
340-
typename concurrent_flat_map<K, T, H, P, A>::size_type
341-
xref:#concurrent_flat_map_erase_if_2[erase_if](concurrent_flat_map<K, T, H, P, A>& c, Predicate pred);
342-
343-
// Pmr aliases (C++17 and up)
344-
namespace unordered::pmr {
345-
template<class Key,
346-
class T,
347-
class Hash = boost::hash<Key>,
348-
class Pred = std::equal_to<Key>>
349-
using concurrent_flat_map =
350-
boost::concurrent_flat_map<Key, T, Hash, Pred,
351-
std::pmr::polymorphic_allocator<std::pair<const Key, T>>>;
352-
}
353-
}
325+
} // namespace unordered
326+
} // namespace boost
354327
-----
355328

356329
---

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

Lines changed: 5 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -22,9 +22,11 @@ The internal data structure of `boost::concurrent_flat_set` is similar to that o
2222

2323
[listing,subs="+macros,+quotes"]
2424
-----
25-
// #include <boost/unordered/concurrent_flat_set.hpp>
25+
// #include xref:reference/header_concurrent_flat_set.adoc[`<boost/unordered/concurrent_flat_set.hpp>`]
2626
2727
namespace boost {
28+
namespace unordered {
29+
2830
template<class Key,
2931
class Hash = boost::hash<Key>,
3032
class Pred = std::equal_to<Key>,
@@ -270,36 +272,8 @@ namespace boost {
270272
concurrent_flat_set(std::initializer_list<T>, typename xref:#concurrent_flat_set_deduction_guides[__see below__]::size_type, Hash, Allocator)
271273
-> concurrent_flat_set<T, Hash, std::equal_to<T>, Allocator>;
272274
273-
// Equality Comparisons
274-
template<class Key, class Hash, class Pred, class Alloc>
275-
bool xref:#concurrent_flat_set_operator[operator==](const concurrent_flat_set<Key, Hash, Pred, Alloc>& x,
276-
const concurrent_flat_set<Key, Hash, Pred, Alloc>& y);
277-
278-
template<class Key, class Hash, class Pred, class Alloc>
279-
bool xref:#concurrent_flat_set_operator_2[operator!=](const concurrent_flat_set<Key, Hash, Pred, Alloc>& x,
280-
const concurrent_flat_set<Key, Hash, Pred, Alloc>& y);
281-
282-
// swap
283-
template<class Key, class Hash, class Pred, class Alloc>
284-
void xref:#concurrent_flat_set_swap_2[swap](concurrent_flat_set<Key, Hash, Pred, Alloc>& x,
285-
concurrent_flat_set<Key, Hash, Pred, Alloc>& y)
286-
noexcept(noexcept(x.swap(y)));
287-
288-
// Erasure
289-
template<class K, class H, class P, class A, class Predicate>
290-
typename concurrent_flat_set<K, H, P, A>::size_type
291-
xref:#concurrent_flat_set_erase_if_2[erase_if](concurrent_flat_set<K, H, P, A>& c, Predicate pred);
292-
293-
// Pmr aliases (C++17 and up)
294-
namespace unordered::pmr {
295-
template<class Key,
296-
class Hash = boost::hash<Key>,
297-
class Pred = std::equal_to<Key>>
298-
using concurrent_flat_set =
299-
boost::concurrent_flat_set<Key, Hash, Pred,
300-
std::pmr::polymorphic_allocator<Key>>;
301-
}
302-
}
275+
} // namespace unordered
276+
} // namespace boost
303277
-----
304278

305279
---

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

Lines changed: 5 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -22,9 +22,11 @@ node handling functionalities are provided, at the expense of potentially lower
2222

2323
[listing,subs="+macros,+quotes"]
2424
-----
25-
// #include <boost/unordered/concurrent_node_map.hpp>
25+
// #include xref:reference/header_concurrent_node_map.adoc[`<boost/unordered/concurrent_node_map.hpp>`]
2626
2727
namespace boost {
28+
namespace unordered {
29+
2830
template<class Key,
2931
class T,
3032
class Hash = boost::hash<Key>,
@@ -338,37 +340,8 @@ namespace boost {
338340
Hash, Allocator)
339341
-> concurrent_node_map<Key, T, Hash, std::equal_to<Key>, Allocator>;
340342
341-
// Equality Comparisons
342-
template<class Key, class T, class Hash, class Pred, class Alloc>
343-
bool xref:#concurrent_node_map_operator[operator==](const concurrent_node_map<Key, T, Hash, Pred, Alloc>& x,
344-
const concurrent_node_map<Key, T, Hash, Pred, Alloc>& y);
345-
346-
template<class Key, class T, class Hash, class Pred, class Alloc>
347-
bool xref:#concurrent_node_map_operator_2[operator!=](const concurrent_node_map<Key, T, Hash, Pred, Alloc>& x,
348-
const concurrent_node_map<Key, T, Hash, Pred, Alloc>& y);
349-
350-
// swap
351-
template<class Key, class T, class Hash, class Pred, class Alloc>
352-
void xref:#concurrent_node_map_swap_2[swap](concurrent_node_map<Key, T, Hash, Pred, Alloc>& x,
353-
concurrent_node_map<Key, T, Hash, Pred, Alloc>& y)
354-
noexcept(noexcept(x.swap(y)));
355-
356-
// Erasure
357-
template<class K, class T, class H, class P, class A, class Predicate>
358-
typename concurrent_node_map<K, T, H, P, A>::size_type
359-
xref:#concurrent_node_map_erase_if_2[erase_if](concurrent_node_map<K, T, H, P, A>& c, Predicate pred);
360-
361-
// Pmr aliases (C++17 and up)
362-
namespace unordered::pmr {
363-
template<class Key,
364-
class T,
365-
class Hash = boost::hash<Key>,
366-
class Pred = std::equal_to<Key>>
367-
using concurrent_node_map =
368-
boost::concurrent_node_map<Key, T, Hash, Pred,
369-
std::pmr::polymorphic_allocator<std::pair<const Key, T>>>;
370-
}
371-
}
343+
} // namespace unordered
344+
} // namespace boost
372345
-----
373346

374347
---

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

Lines changed: 5 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -22,9 +22,11 @@ node handling functionalities are provided, at the expense of potentially lower
2222

2323
[listing,subs="+macros,+quotes"]
2424
-----
25-
// #include <boost/unordered/concurrent_node_set.hpp>
25+
// #include xref:reference/header_concurrent_node_set.adoc[`<boost/unordered/concurrent_node_set.hpp>`]
2626
2727
namespace boost {
28+
namespace unordered {
29+
2830
template<class Key,
2931
class Hash = boost::hash<Key>,
3032
class Pred = std::equal_to<Key>,
@@ -287,36 +289,8 @@ namespace boost {
287289
concurrent_node_set(std::initializer_list<T>, typename xref:#concurrent_node_set_deduction_guides[__see below__]::size_type, Hash, Allocator)
288290
-> concurrent_node_set<T, Hash, std::equal_to<T>, Allocator>;
289291
290-
// Equality Comparisons
291-
template<class Key, class Hash, class Pred, class Alloc>
292-
bool xref:#concurrent_node_set_operator[operator==](const concurrent_node_set<Key, Hash, Pred, Alloc>& x,
293-
const concurrent_node_set<Key, Hash, Pred, Alloc>& y);
294-
295-
template<class Key, class Hash, class Pred, class Alloc>
296-
bool xref:#concurrent_node_set_operator_2[operator!=](const concurrent_node_set<Key, Hash, Pred, Alloc>& x,
297-
const concurrent_node_set<Key, Hash, Pred, Alloc>& y);
298-
299-
// swap
300-
template<class Key, class Hash, class Pred, class Alloc>
301-
void xref:#concurrent_node_set_swap_2[swap](concurrent_node_set<Key, Hash, Pred, Alloc>& x,
302-
concurrent_node_set<Key, Hash, Pred, Alloc>& y)
303-
noexcept(noexcept(x.swap(y)));
304-
305-
// Erasure
306-
template<class K, class H, class P, class A, class Predicate>
307-
typename concurrent_node_set<K, H, P, A>::size_type
308-
xref:#concurrent_node_set_erase_if_2[erase_if](concurrent_node_set<K, H, P, A>& c, Predicate pred);
309-
310-
// Pmr aliases (C++17 and up)
311-
namespace unordered::pmr {
312-
template<class Key,
313-
class Hash = boost::hash<Key>,
314-
class Pred = std::equal_to<Key>>
315-
using concurrent_node_set =
316-
boost::concurrent_node_set<Key, Hash, Pred,
317-
std::pmr::polymorphic_allocator<Key>>;
318-
}
319-
}
292+
} // namespace unordered
293+
} // namespace boost
320294
-----
321295

322296
---

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

Lines changed: 2 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,12 @@
11
[#hash_traits]
2-
== Hash traits
2+
== Hash Traits
33

44
:idprefix: hash_traits_
55

6-
=== Synopsis
6+
=== `<boost/unordered/hash_traits.hpp>` Synopsis
77

88
[listing,subs="+macros,+quotes"]
99
-----
10-
// #include <boost/unordered/hash_traits.hpp>
11-
1210
namespace boost {
1311
namespace unordered {
1412

0 commit comments

Comments
 (0)