From d676ad814b1a69dc6de55753f34bdddb1a38980f Mon Sep 17 00:00:00 2001 From: Christian Mazakas Date: Tue, 1 Mar 2022 07:50:29 -0800 Subject: [PATCH 1/2] Add missing `std::` qualification to usages of `pair` in the reference docs --- doc/unordered/unordered_map.adoc | 16 ++++++++-------- doc/unordered/unordered_multimap.adoc | 16 ++++++++-------- doc/unordered/unordered_set.adoc | 18 +++++++++--------- 3 files changed, 25 insertions(+), 25 deletions(-) diff --git a/doc/unordered/unordered_map.adoc b/doc/unordered/unordered_map.adoc index ad9d71ca..91ab2a6e 100644 --- a/doc/unordered/unordered_map.adoc +++ b/doc/unordered/unordered_map.adoc @@ -154,12 +154,12 @@ namespace boost { bool xref:#unordered_map_contains[contains](const key_type& k) const; template bool xref:#unordered_map_contains[contains](const K& k) const; - pair xref:#unordered_map_equal_range[equal_range](const key_type& k); - pair xref:#unordered_map_equal_range[equal_range](const key_type& k) const; + std::pair xref:#unordered_map_equal_range[equal_range](const key_type& k); + std::pair xref:#unordered_map_equal_range[equal_range](const key_type& k) const; template - pair xref:#unordered_map_equal_range[equal_range](const K& k); + std::pair xref:#unordered_map_equal_range[equal_range](const K& k); template - pair xref:#unordered_map_equal_range[equal_range](const K& k) const; + std::pair xref:#unordered_map_equal_range[equal_range](const K& k) const; // element access mapped_type& xref:#unordered_map_operator[operator[+]+](const key_type& k); @@ -1205,12 +1205,12 @@ Notes:;; The `template ` overload only participates in overload reso ==== equal_range ```c++ -pair equal_range(const key_type& k); -pair equal_range(const key_type& k) const; +std::pair equal_range(const key_type& k); +std::pair equal_range(const key_type& k) const; template - pair equal_range(const K& k); + std::pair equal_range(const K& k); template - pair equal_range(const K& k) const; + std::pair equal_range(const K& k) const; ``` [horizontal] diff --git a/doc/unordered/unordered_multimap.adoc b/doc/unordered/unordered_multimap.adoc index be204074..edcade63 100644 --- a/doc/unordered/unordered_multimap.adoc +++ b/doc/unordered/unordered_multimap.adoc @@ -155,12 +155,12 @@ namespace boost { bool xref:#unordered_multimap_contains[contains](const key_type& k) const; template bool xref:#unordered_multimap_contains[contains](const K& k) const; - pair xref:#unordered_multimap_equal_range[equal_range](const key_type& k); - pair xref:#unordered_multimap_equal_range[equal_range](const key_type& k) const; + std::pair xref:#unordered_multimap_equal_range[equal_range](const key_type& k); + std::pair xref:#unordered_multimap_equal_range[equal_range](const key_type& k) const; template - pair xref:#unordered_multimap_equal_range[equal_range](const K& k); + std::pair xref:#unordered_multimap_equal_range[equal_range](const K& k); template - pair xref:#unordered_multimap_equal_range[equal_range](const K& k) const; + std::pair xref:#unordered_multimap_equal_range[equal_range](const K& k) const; // bucket interface size_type xref:#unordered_multimap_bucket_count[bucket_count]() const noexcept; @@ -1173,12 +1173,12 @@ Notes:;; The `template ` overload only participates in overload reso ==== equal_range ```c++ -pair equal_range(const key_type& k); -pair equal_range(const key_type& k) const; +std::pair equal_range(const key_type& k); +std::pair equal_range(const key_type& k) const; template - pair equal_range(const K& k); + std::pair equal_range(const K& k); template - pair equal_range(const K& k) const; + std::pair equal_range(const K& k) const; ``` [horizontal] diff --git a/doc/unordered/unordered_set.adoc b/doc/unordered/unordered_set.adoc index 01b6b612..e47754cc 100644 --- a/doc/unordered/unordered_set.adoc +++ b/doc/unordered/unordered_set.adoc @@ -150,12 +150,12 @@ namespace boost { bool xref:#unordered_set_contains[contains](const key_type& k) const; template bool xref:#unordered_set_contains[contains](const K& k) const; - pair xref:#unordered_set_equal_range[equal_range](const key_type& k); - pair xref:#unordered_set_equal_range[equal_range](const key_type& k) const; + std::pair xref:#unordered_set_equal_range[equal_range](const key_type& k); + std::pair xref:#unordered_set_equal_range[equal_range](const key_type& k) const; template - pair xref:#unordered_set_equal_range[equal_range](const K& k); + std::pair xref:#unordered_set_equal_range[equal_range](const K& k); template - pair xref:#unordered_set_equal_range[equal_range](const K& k) const; + std::pair xref:#unordered_set_equal_range[equal_range](const K& k) const; // bucket interface size_type xref:#unordered_set_bucket_count[bucket_count]() const noexcept; @@ -660,7 +660,7 @@ Returns:;; `size()` of the largest possible container. ==== emplace ```c++ -template pair emplace(Args&&... args); +template std::pair 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. @@ -1156,12 +1156,12 @@ Notes:;; The `template ` overload only participates in overload reso ==== equal_range ```c++ -pair equal_range(const key_type& k); -pair equal_range(const key_type& k) const; +std::pair equal_range(const key_type& k); +std::pair equal_range(const key_type& k) const; template - pair equal_range(const K& k); + std::pair equal_range(const K& k); template - pair equal_range(const K& k) const; + std::pair equal_range(const K& k) const; ``` [horizontal] From 577294105756d2c478901f8bbc04aad9b95a10cb Mon Sep 17 00:00:00 2001 From: Christian Mazakas Date: Tue, 1 Mar 2022 11:08:07 -0800 Subject: [PATCH 2/2] Add missing `std::` qualification to `initializer_list` --- doc/unordered/unordered_map.adoc | 12 ++++++------ doc/unordered/unordered_multimap.adoc | 14 +++++++------- doc/unordered/unordered_multiset.adoc | 12 ++++++------ doc/unordered/unordered_set.adoc | 12 ++++++------ 4 files changed, 25 insertions(+), 25 deletions(-) diff --git a/doc/unordered/unordered_map.adoc b/doc/unordered/unordered_map.adoc index 91ab2a6e..a8dbc658 100644 --- a/doc/unordered/unordered_map.adoc +++ b/doc/unordered/unordered_map.adoc @@ -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 il, + xref:#unordered_map_initializer_list_constructor[unordered_map](std::initializer_list 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::is_always_equal::value && boost::is_nothrow_move_assignable_v && boost::is_nothrow_move_assignable_v); - unordered_map& xref:#unordered_map_initializer_list_assignment[operator++=++](initializer_list); + unordered_map& xref:#unordered_map_initializer_list_assignment[operator++=++](std::initializer_list); 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 iterator xref:#unordered_map_emplace_insert_with_hint[insert](const_iterator hint, P&& obj); template void xref:#unordered_map_insert_iterator_range[insert](InputIterator first, InputIterator last); - void xref:#unordered_map_insert_initializer_list[insert](initializer_list); + void xref:#unordered_map_insert_initializer_list[insert](std::initializer_list); 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 il, +unordered_map(std::initializer_list 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 il); +unordered_map& operator=(std::initializer_list 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); +void insert(std::initializer_list); ``` 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. diff --git a/doc/unordered/unordered_multimap.adoc b/doc/unordered/unordered_multimap.adoc index edcade63..59dc81a7 100644 --- a/doc/unordered/unordered_multimap.adoc +++ b/doc/unordered/unordered_multimap.adoc @@ -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 il, + xref:#unordered_multimap_initializer_list_constructor[unordered_multimap](std::initializer_list il, size_type n = _implementation-defined_, const hasher& hf = hasher(), const key_equal& eql = key_equal(), @@ -68,7 +68,7 @@ namespace boost { template 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 il, size_type n, const hasher& hf, + xref:#unordered_multimap_initializer_list_constructor[unordered_multimap](std::initializer_list 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::is_always_equal::value && boost::is_nothrow_move_assignable_v && boost::is_nothrow_move_assignable_v); - unordered_multimap& xref:#unordered_multimap_initializer_list_assignment[operator++=++](initializer_list il); + unordered_multimap& xref:#unordered_multimap_initializer_list_assignment[operator++=++](std::initializer_list 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 iterator xref:#unordered_multimap_emplace_insert_with_hint[insert](const_iterator hint, P&& obj); template void xref:#unordered_multimap_insert_iterator_range[insert](InputIterator first, InputIterator last); - void xref:#unordered_multimap_insert_initializer_list[insert](initializer_list il); + void xref:#unordered_multimap_insert_initializer_list[insert](std::initializer_list 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 il, +unordered_multimap(std::initializer_list 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 il); +unordered_multimap& operator=(std::initializer_list 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 il); +void insert(std::initializer_list il); ``` Inserts a range of elements into the container. diff --git a/doc/unordered/unordered_multiset.adoc b/doc/unordered/unordered_multiset.adoc index 6325ca51..9309d32b 100644 --- a/doc/unordered/unordered_multiset.adoc +++ b/doc/unordered/unordered_multiset.adoc @@ -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 il, + xref:#unordered_multiset_initializer_list_constructor[unordered_multiset](std::initializer_list 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::is_always_equal::value && boost::is_nothrow_move_assignable_v && boost::is_nothrow_move_assignable_v); - unordered_multiset& xref:#unordered_multiset_initializer_list_assignment[operator++=++](initializer_list il); + unordered_multiset& xref:#unordered_multiset_initializer_list_assignment[operator++=++](std::initializer_list 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 void xref:#unordered_multiset_insert_iterator_range[insert](InputIterator first, InputIterator last); - void xref:#unordered_multiset_insert_initializer_list[insert](initializer_list il); + void xref:#unordered_multiset_insert_initializer_list[insert](std::initializer_list 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 il, +unordered_multiset(std::initializer_list 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 il); +unordered_multiset& operator=(std::initializer_list 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 il); +void insert(std::initializer_list 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. diff --git a/doc/unordered/unordered_set.adoc b/doc/unordered/unordered_set.adoc index e47754cc..84748351 100644 --- a/doc/unordered/unordered_set.adoc +++ b/doc/unordered/unordered_set.adoc @@ -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 il, + xref:#unordered_set_initializer_list_constructor[unordered_set](std::initializer_list 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::is_always_equal::value && boost::is_nothrow_move_assignable_v && boost::is_nothrow_move_assignable_v); - unordered_set& xref:#unordered_set_initializer_list_assignment[operator++=++](initializer_list il); + unordered_set& xref:#unordered_set_initializer_list_assignment[operator++=++](std::initializer_list 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 void xref:#unordered_set_insert_iterator_range[insert](InputIterator first, InputIterator last); - void xref:#unordered_set_insert_initializer_list[insert](initializer_list); + void xref:#unordered_set_insert_initializer_list[insert](std::initializer_list); 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 il, +unordered_set(std::initializer_list 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 il); +unordered_set& operator=(std::initializer_list 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); +void insert(std::initializer_list); ``` 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.