Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

added header synopses to the reference #303

Open
wants to merge 4 commits into
base: develop
Choose a base branch
from
+871 −413
Open

added header synopses to the reference #303

Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
f125ad4
added header synopses to the reference
joaquintides Jan 22, 2025
191adf4
disabled font color override for in-link code portions
joaquintides Jan 23, 2025
1eca210
relinked bundle
joaquintides Jan 23, 2025
193d5cf
Merge branch 'develop' into fix/doc_synopses
joaquintides Jan 23, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
48 changes: 35 additions & 13 deletions doc/modules/ROOT/nav.adoc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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[]
4 changes: 4 additions & 0 deletions doc/modules/ROOT/pages/changes.adoc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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`.
Expand Down
4 changes: 2 additions & 2 deletions doc/modules/ROOT/pages/copyright.adoc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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&iacute;n M L&oacute;pez Mu&ntilde;oz
Copyright (C) 2022-2025 Joaqu&iacute;n M L&oacute;pez Mu&ntilde;oz

Copyright (C) 2022-2023 Peter Dimov

Expand Down
48 changes: 35 additions & 13 deletions doc/modules/ROOT/pages/ref.adoc
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -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]
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Try putting the code backticks on the outside of the xref and tell me if you like how it looks.

image

In this image, the top two links are the updated version. The third one is the current look.

Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I can solve this in a more satisfactory way, for that I'd need for you to add this definition to the source site.css:

.inlink-code {
    font-family: Roboto Mono,monospace;
    font-size: 95%;
    color: inherit;
}

Can you do that?

Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Of course. You can do that locally yourself even.

All you gotta clone is the unordered-ui-bundle repo and then invoke gulp bundle in it. There's docs here: https://gitlab.com/antora/antora-ui-default#user-content-development-quickstart

Copy link
Member Author

@joaquintides joaquintides Jan 23, 2025 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I managed to do it without changing the CSS file: 191adf4.

* 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`]
37 changes: 5 additions & 32 deletions doc/modules/ROOT/pages/reference/concurrent_flat_map.adoc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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>,
Expand Down Expand Up @@ -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
-----

---
Expand Down
36 changes: 5 additions & 31 deletions doc/modules/ROOT/pages/reference/concurrent_flat_set.adoc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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>,
Expand Down Expand Up @@ -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
-----

---
Expand Down
37 changes: 5 additions & 32 deletions doc/modules/ROOT/pages/reference/concurrent_node_map.adoc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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>,
Expand Down Expand Up @@ -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
-----

---
Expand Down
36 changes: 5 additions & 31 deletions doc/modules/ROOT/pages/reference/concurrent_node_set.adoc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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>,
Expand Down Expand Up @@ -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
-----

---
Expand Down
6 changes: 2 additions & 4 deletions doc/modules/ROOT/pages/reference/hash_traits.adoc
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -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 {

Expand Down
Loading