boost_mirror/unordered
1
0
Fork 0
mirror of https://github.com/boostorg/unordered.git synced 2025-05-11 05:23:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #110 from cmazakas/equal-range-reference-docs-fixes

Browse Source 
Add missing `std::` qualification to usages of `pair` in the reference
This commit is contained in:
Peter Dimov 2022-03-02 21:10:38 +02:00 committed by GitHub
commit bca33372c2
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 50 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
doc/unordered/unordered_map.adoc
View File

@ -57,7 +57,7 @@ namespace boost {
explicit xref:#unordered_map_allocator_constructor[unordered_map](const Allocator& a);
xref:#unordered_map_copy_constructor_with_allocator[unordered_map](const unordered_map& other, const Allocator& a);
xref:#unordered_map_move_constructor_with_allocator[unordered_map](unordered_map&& other, const Allocator& a);
xref:#unordered_map_initializer_list_constructor[unordered_map](initializer_list<value_type> il,
xref:#unordered_map_initializer_list_constructor[unordered_map](std::initializer_list<value_type> il,
size_type n = _implementation-defined_
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
@ -75,7 +75,7 @@ namespace boost {
noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
boost::is_nothrow_move_assignable_v<Hash> &&
boost::is_nothrow_move_assignable_v<Pred>);
unordered_map& xref:#unordered_map_initializer_list_assignment[operator++=++](initializer_list<value_type>);
unordered_map& xref:#unordered_map_initializer_list_assignment[operator++=++](std::initializer_list<value_type>);
allocator_type xref:#unordered_map_get_allocator[get_allocator]() const noexcept;
// iterators
@ -101,7 +101,7 @@ namespace boost {
iterator xref:#unordered_map_move_insert_with_hint[insert](const_iterator hint, value_type&& obj);
template<class P> iterator xref:#unordered_map_emplace_insert_with_hint[insert](const_iterator hint, P&& obj);
template<class InputIterator> void xref:#unordered_map_insert_iterator_range[insert](InputIterator first, InputIterator last);
void xref:#unordered_map_insert_initializer_list[insert](initializer_list<value_type>);
void xref:#unordered_map_insert_initializer_list[insert](std::initializer_list<value_type>);
template<class... Args>
std::pair<iterator, bool> xref:#unordered_map_try_emplace[try_emplace](const key_type& k, Args&&... args);
@ -171,12 +171,12 @@ namespace boost {
bool xref:#unordered_map_contains[contains](const key_type& k) const;
template<class K>
bool xref:#unordered_map_contains[contains](const K& k) const;
pair<iterator, iterator> xref:#unordered_map_equal_range[equal_range](const key_type& k);
pair<const_iterator, const_iterator> xref:#unordered_map_equal_range[equal_range](const key_type& k) const;
std::pair<iterator, iterator> xref:#unordered_map_equal_range[equal_range](const key_type& k);
std::pair<const_iterator, const_iterator> xref:#unordered_map_equal_range[equal_range](const key_type& k) const;
template<class K>
pair<iterator, iterator> xref:#unordered_map_equal_range[equal_range](const K& k);
std::pair<iterator, iterator> xref:#unordered_map_equal_range[equal_range](const K& k);
template<class K>
pair<const_iterator, const_iterator> xref:#unordered_map_equal_range[equal_range](const K& k) const;
std::pair<const_iterator, const_iterator> xref:#unordered_map_equal_range[equal_range](const K& k) const;
// element access
mapped_type& xref:#unordered_map_operator[operator[+]+](const key_type& k);
@ -481,7 +481,7 @@ Requires:;; `value_type` is move insertable.
==== Initializer List Constructor
[source,c++,subs="+quotes"]
----
unordered_map(initializer_list<value_type> il,
unordered_map(std::initializer_list<value_type> il,
size_type n = _implementation-defined_
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
@ -597,7 +597,7 @@ Requires:;; `value_type` is move constructible.
==== Initializer List Assignment
```c++
unordered_map& operator=(initializer_list<value_type> il);
unordered_map& operator=(std::initializer_list<value_type> il);
```
Assign from values in initializer list. All existing elements are either overwritten by the new elements or destroyed.
@ -869,7 +869,7 @@ Pointers and references to elements are never invalidated.
==== Insert Initializer List
```c++
void insert(initializer_list<value_type>);
void insert(std::initializer_list<value_type>);
```
Inserts a range of elements into the container. Elements are inserted if and only if there is no element in the container with an equivalent key.
@ -1364,12 +1364,12 @@ Notes:;; The `template <typename K>` overload only participates in overload reso
==== equal_range
```c++
pair<iterator, iterator> equal_range(const key_type& k);
pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
std::pair<iterator, iterator> equal_range(const key_type& k);
std::pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
template<class K>
pair<iterator, iterator> equal_range(const K& k);
std::pair<iterator, iterator> equal_range(const K& k);
template<class K>
pair<const_iterator, const_iterator> equal_range(const K& k) const;
std::pair<const_iterator, const_iterator> equal_range(const K& k) const;
```
[horizontal]

30
doc/unordered/unordered_multimap.adoc
View File

@ -56,7 +56,7 @@ namespace boost {
explicit xref:#unordered_multimap_allocator_constructor[unordered_multimap](const Allocator& a);
xref:#unordered_multimap_copy_constructor_with_allocator[unordered_multimap](const unordered_multimap& other, const Allocator& a);
xref:#unordered_multimap_move_constructor_with_allocator[unordered_multimap](unordered_multimap&& other, const Allocator& a);
xref:#unordered_multimap_initializer_list_constructor[unordered_multimap](initializer_list<value_type> il,
xref:#unordered_multimap_initializer_list_constructor[unordered_multimap](std::initializer_list<value_type> il,
size_type n = _implementation-defined_,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
@ -68,7 +68,7 @@ namespace boost {
template<class InputIterator>
xref:#unordered_multimap_iterator_range_constructor_with_bucket_count_and_hasher[unordered_multimap](InputIterator f, InputIterator l, size_type n, const hasher& hf,
const allocator_type& a);
xref:#unordered_multimap_initializer_list_constructor[unordered_multimap](initializer_list<value_type> il, size_type n, const hasher& hf,
xref:#unordered_multimap_initializer_list_constructor[unordered_multimap](std::initializer_list<value_type> il, size_type n, const hasher& hf,
const allocator_type& a);
xref:#unordered_multimap_destructor[~unordered_multimap]();
unordered_multimap& xref:#unordered_multimap_copy_assignment[operator++=++](const unordered_multimap& other);
@ -76,7 +76,7 @@ namespace boost {
noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
boost::is_nothrow_move_assignable_v<Hash> &&
boost::is_nothrow_move_assignable_v<Pred>);
unordered_multimap& xref:#unordered_multimap_initializer_list_assignment[operator++=++](initializer_list<value_type> il);
unordered_multimap& xref:#unordered_multimap_initializer_list_assignment[operator++=++](std::initializer_list<value_type> il);
allocator_type xref:#unordered_multimap_get_allocator[get_allocator]() const noexcept;
// iterators
@ -102,7 +102,7 @@ namespace boost {
iterator xref:#unordered_multimap_move_insert_with_hint[insert](const_iterator hint, value_type&& obj);
template<class P> iterator xref:#unordered_multimap_emplace_insert_with_hint[insert](const_iterator hint, P&& obj);
template<class InputIterator> void xref:#unordered_multimap_insert_iterator_range[insert](InputIterator first, InputIterator last);
void xref:#unordered_multimap_insert_initializer_list[insert](initializer_list<value_type> il);
void xref:#unordered_multimap_insert_initializer_list[insert](std::initializer_list<value_type> il);
node_type xref:#unordered_multimap_extract_by_iterator[extract](const_iterator position);
node_type xref:#unordered_multimap_extract_by_key[extract](const key_type& k);
@ -155,12 +155,12 @@ namespace boost {
bool xref:#unordered_multimap_contains[contains](const key_type& k) const;
template<class K>
bool xref:#unordered_multimap_contains[contains](const K& k) const;
pair<iterator, iterator> xref:#unordered_multimap_equal_range[equal_range](const key_type& k);
pair<const_iterator, const_iterator> xref:#unordered_multimap_equal_range[equal_range](const key_type& k) const;
std::pair<iterator, iterator> xref:#unordered_multimap_equal_range[equal_range](const key_type& k);
std::pair<const_iterator, const_iterator> xref:#unordered_multimap_equal_range[equal_range](const key_type& k) const;
template<class K>
pair<iterator, iterator> xref:#unordered_multimap_equal_range[equal_range](const K& k);
std::pair<iterator, iterator> xref:#unordered_multimap_equal_range[equal_range](const K& k);
template<class K>
pair<const_iterator, const_iterator> xref:#unordered_multimap_equal_range[equal_range](const K& k) const;
std::pair<const_iterator, const_iterator> xref:#unordered_multimap_equal_range[equal_range](const K& k) const;
// bucket interface
size_type xref:#unordered_multimap_bucket_count[bucket_count]() const noexcept;
@ -449,7 +449,7 @@ Requires:;; `value_type` is move insertable.
==== Initializer List Constructor
[source,c++,subs="+quotes"]
----
unordered_multimap(initializer_list<value_type> il,
unordered_multimap(std::initializer_list<value_type> il,
size_type n = _implementation-defined_,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
@ -564,7 +564,7 @@ Requires:;; `value_type` is move constructible.
==== Initializer List Assignment
```c++
unordered_multimap& operator=(initializer_list<value_type> il);
unordered_multimap& operator=(std::initializer_list<value_type> il);
```
Assign from values in initializer list. All existing elements are either overwritten by the new elements or destroyed.
@ -827,7 +827,7 @@ Pointers and references to elements are never invalidated.
==== Insert Initializer List
```c++
void insert(initializer_list<value_type> il);
void insert(std::initializer_list<value_type> il);
```
Inserts a range of elements into the container.
@ -1173,12 +1173,12 @@ Notes:;; The `template <typename K>` overload only participates in overload reso
==== equal_range
```c++
pair<iterator, iterator> equal_range(const key_type& k);
pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
std::pair<iterator, iterator> equal_range(const key_type& k);
std::pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
template<class K>
pair<iterator, iterator> equal_range(const K& k);
std::pair<iterator, iterator> equal_range(const K& k);
template<class K>
pair<const_iterator, const_iterator> equal_range(const K& k) const;
std::pair<const_iterator, const_iterator> equal_range(const K& k) const;
```
[horizontal]

12
doc/unordered/unordered_multiset.adoc
View File

@ -54,7 +54,7 @@ namespace boost {
explicit xref:#unordered_multiset_allocator_constructor[unordered_multiset](const Allocator& a);
xref:#unordered_multiset_copy_constructor_with_allocator[unordered_multiset](const unordered_multiset& other, const Allocator& a);
xref:#unordered_multiset_move_constructor_with_allocator[unordered_multiset](unordered_multiset&& other, const Allocator& a);
xref:#unordered_multiset_initializer_list_constructor[unordered_multiset](initializer_list<value_type> il,
xref:#unordered_multiset_initializer_list_constructor[unordered_multiset](std::initializer_list<value_type> il,
size_type n = _implementation-defined_,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
@ -72,7 +72,7 @@ namespace boost {
noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
boost::is_nothrow_move_assignable_v<Hash> &&
boost::is_nothrow_move_assignable_v<Pred>);
unordered_multiset& xref:#unordered_multiset_initializer_list_assignment[operator++=++](initializer_list<value_type> il);
unordered_multiset& xref:#unordered_multiset_initializer_list_assignment[operator++=++](std::initializer_list<value_type> il);
allocator_type xref:#unordered_multiset_get_allocator[get_allocator]() const noexcept;
// iterators
@ -96,7 +96,7 @@ namespace boost {
iterator xref:#unordered_multiset_copy_insert_with_hint[insert](const_iterator hint, const value_type& obj);
iterator xref:#unordered_multiset_move_insert_with_hint[insert](const_iterator hint, value_type&& obj);
template<class InputIterator> void xref:#unordered_multiset_insert_iterator_range[insert](InputIterator first, InputIterator last);
void xref:#unordered_multiset_insert_initializer_list[insert](initializer_list<value_type> il);
void xref:#unordered_multiset_insert_initializer_list[insert](std::initializer_list<value_type> il);
node_type xref:#unordered_multiset_extract_by_iterator[extract](const_iterator position);
node_type xref:#unordered_multiset_extract_by_value[extract](const key_type& k);
@ -440,7 +440,7 @@ Requires:;; `value_type` is move insertable.
==== Initializer List Constructor
[source,c++,subs="+quotes"]
----
unordered_multiset(initializer_list<value_type> il,
unordered_multiset(std::initializer_list<value_type> il,
size_type n = _implementation-defined_,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
@ -556,7 +556,7 @@ Requires:;; `value_type` is move constructible.
==== Initializer List Assignment
```c++
unordered_multiset& operator=(initializer_list<value_type> il);
unordered_multiset& operator=(std::initializer_list<value_type> il);
```
Assign from values in initializer list. All existing elements are either overwritten by the new elements or destroyed.
@ -787,7 +787,7 @@ Pointers and references to elements are never invalidated.
==== Insert Initializer List
```c++
void insert(initializer_list<value_type> il);
void insert(std::initializer_list<value_type> il);
```
Inserts a range of elements into the container. Elements are inserted if and only if there is no element in the container with an equivalent key.

30
doc/unordered/unordered_set.adoc
View File

@ -55,7 +55,7 @@ namespace boost {
explicit xref:#unordered_set_allocator_constructor[unordered_set](const Allocator& a);
xref:#unordered_set_copy_constructor_with_allocator[unordered_set](const unordered_set& other, const Allocator& a);
xref:#unordered_set_move_constructor_with_allocator[unordered_set](unordered_set&& other, const Allocator& a);
xref:#unordered_set_initializer_list_constructor[unordered_set](initializer_list<value_type> il,
xref:#unordered_set_initializer_list_constructor[unordered_set](std::initializer_list<value_type> il,
size_type n = _implementation-defined_,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
@ -73,7 +73,7 @@ namespace boost {
noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
boost::is_nothrow_move_assignable_v<Hash> &&
boost::is_nothrow_move_assignable_v<Pred>);
unordered_set& xref:#unordered_set_initializer_list_assignment[operator++=++](initializer_list<value_type> il);
unordered_set& xref:#unordered_set_initializer_list_assignment[operator++=++](std::initializer_list<value_type> il);
allocator_type xref:#unordered_set_get_allocator[get_allocator]() const noexcept;
// iterators
@ -97,7 +97,7 @@ namespace boost {
iterator xref:#unordered_set_copy_insert_with_hint[insert](const_iterator hint, const value_type& obj);
iterator xref:#unordered_set_move_insert_with_hint[insert](const_iterator hint, value_type&& obj);
template<class InputIterator> void xref:#unordered_set_insert_iterator_range[insert](InputIterator first, InputIterator last);
void xref:#unordered_set_insert_initializer_list[insert](initializer_list<value_type>);
void xref:#unordered_set_insert_initializer_list[insert](std::initializer_list<value_type>);
node_type xref:#unordered_set_extract_by_iterator[extract](const_iterator position);
node_type xref:#unordered_set_extract_by_value[extract](const key_type& k);
@ -150,12 +150,12 @@ namespace boost {
bool xref:#unordered_set_contains[contains](const key_type& k) const;
template<class K>
bool xref:#unordered_set_contains[contains](const K& k) const;
pair<iterator, iterator> xref:#unordered_set_equal_range[equal_range](const key_type& k);
pair<const_iterator, const_iterator> xref:#unordered_set_equal_range[equal_range](const key_type& k) const;
std::pair<iterator, iterator> xref:#unordered_set_equal_range[equal_range](const key_type& k);
std::pair<const_iterator, const_iterator> xref:#unordered_set_equal_range[equal_range](const key_type& k) const;
template<class K>
pair<iterator, iterator> xref:#unordered_set_equal_range[equal_range](const K& k);
std::pair<iterator, iterator> xref:#unordered_set_equal_range[equal_range](const K& k);
template<class K>
pair<const_iterator, const_iterator> xref:#unordered_set_equal_range[equal_range](const K& k) const;
std::pair<const_iterator, const_iterator> xref:#unordered_set_equal_range[equal_range](const K& k) const;
// bucket interface
size_type xref:#unordered_set_bucket_count[bucket_count]() const noexcept;
@ -451,7 +451,7 @@ Requires:;; `value_type` is move insertable.
==== Initializer List Constructor
[source,c++,subs="+quotes"]
----
unordered_set(initializer_list<value_type> il,
unordered_set(std::initializer_list<value_type> il,
size_type n = _implementation-defined_,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
@ -567,7 +567,7 @@ Requires:;; `value_type` is move constructible.
==== Initializer List Assignment
```c++
unordered_set& operator=(initializer_list<value_type> il);
unordered_set& operator=(std::initializer_list<value_type> il);
```
Assign from values in initializer list. All existing elements are either overwritten by the new elements or destroyed.
@ -660,7 +660,7 @@ Returns:;; `size()` of the largest possible container.
==== emplace
```c++
template<class... Args> pair<iterator, bool> emplace(Args&&... args);
template<class... Args> std::pair<iterator, bool> emplace(Args&&... args);
```
Inserts an object, constructed with the arguments `args`, in the container if and only if there is no element in the container with an equivalent value.
@ -803,7 +803,7 @@ Pointers and references to elements are never invalidated.
==== Insert Initializer List
```c++
void insert(initializer_list<value_type>);
void insert(std::initializer_list<value_type>);
```
Inserts a range of elements into the container. Elements are inserted if and only if there is no element in the container with an equivalent key.
@ -1156,12 +1156,12 @@ Notes:;; The `template <typename K>` overload only participates in overload reso
==== equal_range
```c++
pair<iterator, iterator> equal_range(const key_type& k);
pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
std::pair<iterator, iterator> equal_range(const key_type& k);
std::pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
template<class K>
pair<iterator, iterator> equal_range(const K& k);
std::pair<iterator, iterator> equal_range(const K& k);
template<class K>
pair<const_iterator, const_iterator> equal_range(const K& k) const;
std::pair<const_iterator, const_iterator> equal_range(const K& k) const;
```
[horizontal]