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); 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_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_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_ size_type n = _implementation-defined_
const hasher& hf = hasher(), const hasher& hf = hasher(),
const key_equal& eql = key_equal(), const key_equal& eql = key_equal(),
@ -75,7 +75,7 @@ namespace boost {
noexcept(boost::allocator_traits<Allocator>::is_always_equal::value && noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
boost::is_nothrow_move_assignable_v<Hash> && boost::is_nothrow_move_assignable_v<Hash> &&
boost::is_nothrow_move_assignable_v<Pred>); 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; allocator_type xref:#unordered_map_get_allocator[get_allocator]() const noexcept;
// iterators // iterators
@ -101,7 +101,7 @@ namespace boost {
iterator xref:#unordered_map_move_insert_with_hint[insert](const_iterator hint, value_type&& obj); 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 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); 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_iterator[extract](const_iterator position);
node_type xref:#unordered_map_extract_by_key[extract](const key_type& k); 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 ==== Initializer List Constructor
[source,c++,subs="+quotes"] [source,c++,subs="+quotes"]
---- ----
unordered_map(initializer_list<value_type> il, unordered_map(std::initializer_list<value_type> il,
size_type n = _implementation-defined_ size_type n = _implementation-defined_
const hasher& hf = hasher(), const hasher& hf = hasher(),
const key_equal& eql = key_equal(), const key_equal& eql = key_equal(),
@ -580,7 +580,7 @@ Requires:;; `value_type` is move constructible.
==== Initializer List Assignment ==== Initializer List Assignment
```c++ ```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. 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 ==== Insert Initializer List
```c++ ```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. 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); 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_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_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_, size_type n = _implementation-defined_,
const hasher& hf = hasher(), const hasher& hf = hasher(),
const key_equal& eql = key_equal(), const key_equal& eql = key_equal(),
@ -68,7 +68,7 @@ namespace boost {
template<class InputIterator> 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, 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); 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); const allocator_type& a);
xref:#unordered_multimap_destructor[~unordered_multimap](); xref:#unordered_multimap_destructor[~unordered_multimap]();
unordered_multimap& xref:#unordered_multimap_copy_assignment[operator++=++](const unordered_multimap& other); 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 && noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
boost::is_nothrow_move_assignable_v<Hash> && boost::is_nothrow_move_assignable_v<Hash> &&
boost::is_nothrow_move_assignable_v<Pred>); 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; allocator_type xref:#unordered_multimap_get_allocator[get_allocator]() const noexcept;
// iterators // iterators
@ -102,7 +102,7 @@ namespace boost {
iterator xref:#unordered_multimap_move_insert_with_hint[insert](const_iterator hint, value_type&& obj); 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 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); 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_iterator[extract](const_iterator position);
node_type xref:#unordered_multimap_extract_by_key[extract](const key_type& k); 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 ==== Initializer List Constructor
[source,c++,subs="+quotes"] [source,c++,subs="+quotes"]
---- ----
unordered_multimap(initializer_list<value_type> il, unordered_multimap(std::initializer_list<value_type> il,
size_type n = _implementation-defined_, size_type n = _implementation-defined_,
const hasher& hf = hasher(), const hasher& hf = hasher(),
const key_equal& eql = key_equal(), const key_equal& eql = key_equal(),
@ -564,7 +564,7 @@ Requires:;; `value_type` is move constructible.
==== Initializer List Assignment ==== Initializer List Assignment
```c++ ```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. 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 ==== Insert Initializer List
```c++ ```c++
void insert(initializer_list<value_type> il); void insert(std::initializer_list<value_type> il);
``` ```
Inserts a range of elements into the container. 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); 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_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_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_, size_type n = _implementation-defined_,
const hasher& hf = hasher(), const hasher& hf = hasher(),
const key_equal& eql = key_equal(), const key_equal& eql = key_equal(),
@ -72,7 +72,7 @@ namespace boost {
noexcept(boost::allocator_traits<Allocator>::is_always_equal::value && noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
boost::is_nothrow_move_assignable_v<Hash> && boost::is_nothrow_move_assignable_v<Hash> &&
boost::is_nothrow_move_assignable_v<Pred>); 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; allocator_type xref:#unordered_multiset_get_allocator[get_allocator]() const noexcept;
// iterators // 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_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); 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); 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_iterator[extract](const_iterator position);
node_type xref:#unordered_multiset_extract_by_value[extract](const key_type& k); 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 ==== Initializer List Constructor
[source,c++,subs="+quotes"] [source,c++,subs="+quotes"]
---- ----
unordered_multiset(initializer_list<value_type> il, unordered_multiset(std::initializer_list<value_type> il,
size_type n = _implementation-defined_, size_type n = _implementation-defined_,
const hasher& hf = hasher(), const hasher& hf = hasher(),
const key_equal& eql = key_equal(), const key_equal& eql = key_equal(),
@ -556,7 +556,7 @@ Requires:;; `value_type` is move constructible.
==== Initializer List Assignment ==== Initializer List Assignment
```c++ ```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. 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 ==== Insert Initializer List
```c++ ```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. 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); 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_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_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_, size_type n = _implementation-defined_,
const hasher& hf = hasher(), const hasher& hf = hasher(),
const key_equal& eql = key_equal(), const key_equal& eql = key_equal(),
@ -73,7 +73,7 @@ namespace boost {
noexcept(boost::allocator_traits<Allocator>::is_always_equal::value && noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
boost::is_nothrow_move_assignable_v<Hash> && boost::is_nothrow_move_assignable_v<Hash> &&
boost::is_nothrow_move_assignable_v<Pred>); 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; allocator_type xref:#unordered_set_get_allocator[get_allocator]() const noexcept;
// iterators // 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_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); 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); 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_iterator[extract](const_iterator position);
node_type xref:#unordered_set_extract_by_value[extract](const key_type& k); 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 ==== Initializer List Constructor
[source,c++,subs="+quotes"] [source,c++,subs="+quotes"]
---- ----
unordered_set(initializer_list<value_type> il, unordered_set(std::initializer_list<value_type> il,
size_type n = _implementation-defined_, size_type n = _implementation-defined_,
const hasher& hf = hasher(), const hasher& hf = hasher(),
const key_equal& eql = key_equal(), const key_equal& eql = key_equal(),
@ -567,7 +567,7 @@ Requires:;; `value_type` is move constructible.
==== Initializer List Assignment ==== Initializer List Assignment
```c++ ```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. 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 ==== Insert Initializer List
```c++ ```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. 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.