feedc0de/boost_unordered
1
0
Fork 0
forked from boostorg/unordered
Code Pull Requests Activity

Add missing std:: qualification to initializer_list

Browse Source
This commit is contained in:
Christian Mazakas
2022-03-01 11:08:07 -08:00
parent d676ad814b
commit 5772941057
4 changed files with 25 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
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>);
node_type xref:#unordered_map_extract_by_iterator[extract](const_iterator position);
node_type xref:#unordered_map_extract_by_key[extract](const key_type& k);
@ -464,7 +464,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(),
@ -580,7 +580,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.
@ -852,7 +852,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.

14
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);
@ -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.

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.

12
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);
@ -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.
@ -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.