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

documented ctors added in #160

Browse Source
This commit is contained in:
joaquintides
2022-11-05 12:38:03 +01:00
parent 3e4546465b
commit 0d8c02ba0e
6 changed files with 178 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
doc/unordered/unordered_flat_map.adoc
View File

@ -73,6 +73,8 @@ namespace boost {
const allocator_type& a = allocator_type());
xref:#unordered_flat_map_copy_constructor[unordered_flat_map](const unordered_flat_map& other);
xref:#unordered_flat_map_move_constructor[unordered_flat_map](unordered_flat_map&& other);
template<class InputIterator>
xref:#unordered_flat_map_iterator_range_constructor_with_allocator[unordered_flat_map](InputIterator f, InputIterator l, const allocator_type& a);
explicit xref:#unordered_flat_map_allocator_constructor[unordered_flat_map](const Allocator& a);
xref:#unordered_flat_map_copy_constructor_with_allocator[unordered_flat_map](const unordered_flat_map& other, const Allocator& a);
xref:#unordered_flat_map_move_constructor_with_allocator[unordered_flat_map](unordered_flat_map&& other, const Allocator& a);
@ -88,6 +90,7 @@ namespace boost {
template<class InputIterator>
xref:#unordered_flat_map_iterator_range_constructor_with_bucket_count_and_hasher[unordered_flat_map](InputIterator f, InputIterator l, size_type n, const hasher& hf,
const allocator_type& a);
xref:#unordered_flat_map_initializer_list_constructor_with_allocator[unordered_flat_map](std::initializer_list<value_type> il, const allocator_type& a);
xref:#unordered_flat_map_initializer_list_constructor_with_bucket_count_and_allocator[unordered_flat_map](std::initializer_list<value_type> il, size_type n,
const allocator_type& a);
xref:#unordered_flat_map_initializer_list_constructor_with_bucket_count_and_hasher_and_allocator[unordered_flat_map](std::initializer_list<value_type> il, size_type n, const hasher& hf,
@ -368,6 +371,19 @@ The hash function, predicate and allocator are moved-constructed from `other`.
---
==== Iterator Range Constructor with Allocator
```c++
template<class InputIterator>
unordered_flat_map(InputIterator f, InputIterator l, const allocator_type& a);
```
Constructs an empty container using `a` as the allocator, with the default hash function and key equality predicate and inserts the elements from `[f, l)` into it.
[horizontal]
Requires:;; `hasher`, `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
---
==== Allocator Constructor
```c++
explicit unordered_flat_map(Allocator const& a);
@ -469,6 +485,19 @@ Requires:;; `key_equal` needs to be https://en.cppreference.com/w/cpp/named_req/
---
==== initializer_list Constructor with Allocator
```c++
unordered_flat_map(std::initializer_list<value_type> il, const allocator_type& a);
```
Constructs an empty container using `a` and default hash function and key equality predicate, and inserts the elements from `il` into it.
[horizontal]
Requires:;; `hasher` and `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
---
==== initializer_list Constructor with Bucket Count and Allocator
```c++

29
doc/unordered/unordered_flat_set.adoc
View File

@ -68,6 +68,8 @@ namespace boost {
const allocator_type& a = allocator_type());
xref:#unordered_flat_set_copy_constructor[unordered_flat_set](const unordered_flat_set& other);
xref:#unordered_flat_set_move_constructor[unordered_flat_set](unordered_flat_set&& other);
template<class InputIterator>
xref:#unordered_flat_set_iterator_range_constructor_with_allocator[unordered_flat_set](InputIterator f, InputIterator l, const allocator_type& a);
explicit xref:#unordered_flat_set_allocator_constructor[unordered_flat_set](const Allocator& a);
xref:#unordered_flat_set_copy_constructor_with_allocator[unordered_flat_set](const unordered_flat_set& other, const Allocator& a);
xref:#unordered_flat_set_move_constructor_with_allocator[unordered_flat_set](unordered_flat_set&& other, const Allocator& a);
@ -83,6 +85,7 @@ namespace boost {
template<class InputIterator>
xref:#unordered_flat_set_iterator_range_constructor_with_bucket_count_and_hasher[unordered_flat_set](InputIterator f, InputIterator l, size_type n, const hasher& hf,
const allocator_type& a);
xref:#unordered_flat_set_initializer_list_constructor_with_allocator[unordered_flat_set](std::initializer_list<value_type> il, const allocator_type& a);
xref:#unordered_flat_set_initializer_list_constructor_with_bucket_count_and_allocator[unordered_flat_set](std::initializer_list<value_type> il, size_type n,
const allocator_type& a);
xref:#unordered_flat_set_initializer_list_constructor_with_bucket_count_and_hasher_and_allocator[unordered_flat_set](std::initializer_list<value_type> il, size_type n, const hasher& hf,
@ -332,6 +335,19 @@ The hash function, predicate and allocator are moved-constructed from `other`.
---
==== Iterator Range Constructor with Allocator
```c++
template<class InputIterator>
unordered_flat_set(InputIterator f, InputIterator l, const allocator_type& a);
```
Constructs an empty container using `a` as the allocator, with the default hash function and key equality predicate and inserts the elements from `[f, l)` into it.
[horizontal]
Requires:;; `hasher`, `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
---
==== Allocator Constructor
```c++
explicit unordered_flat_set(Allocator const& a);
@ -433,6 +449,19 @@ Requires:;; `key_equal` needs to be https://en.cppreference.com/w/cpp/named_req/
---
==== initializer_list Constructor with Allocator
```c++
unordered_flat_set(std::initializer_list<value_type> il, const allocator_type& a);
```
Constructs an empty container using `a` and default hash function and key equality predicate, and inserts the elements from `il` into it.
[horizontal]
Requires:;; `hasher` and `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
---
==== initializer_list Constructor with Bucket Count and Allocator
```c++

29
doc/unordered/unordered_map.adoc
View File

@ -54,6 +54,8 @@ namespace boost {
const allocator_type& a = allocator_type());
xref:#unordered_map_copy_constructor[unordered_map](const unordered_map& other);
xref:#unordered_map_move_constructor[unordered_map](unordered_map&& other);
template<class InputIterator>
xref:#unordered_map_iterator_range_constructor_with_allocator[unordered_map](InputIterator f, InputIterator l, const allocator_type& 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_move_constructor_with_allocator[unordered_map](unordered_map&& other, const Allocator& a);
@ -69,6 +71,7 @@ namespace boost {
template<class InputIterator>
xref:#unordered_map_iterator_range_constructor_with_bucket_count_and_hasher[unordered_map](InputIterator f, InputIterator l, size_type n, const hasher& hf,
const allocator_type& a);
xref:#unordered_map_initializer_list_constructor_with_allocator[unordered_map](std::initializer_list<value_type> il, const allocator_type& a);
xref:#unordered_map_initializer_list_constructor_with_bucket_count_and_allocator[unordered_map](std::initializer_list<value_type> il, size_type n, const allocator_type& a);
xref:#unordered_map_initializer_list_constructor_with_bucket_count_and_hasher_and_allocator[unordered_map](std::initializer_list<value_type> il, size_type n, const hasher& hf,
const allocator_type& a);
@ -450,6 +453,19 @@ So, for example, you can't return the container from a function.
---
==== Iterator Range Constructor with Allocator
```c++
template<class InputIterator>
unordered_map(InputIterator f, InputIterator l, const allocator_type& a);
```
Constructs an empty container using `a` as the allocator, with the default hash function and key equality predicate and a maximum load factor of `1.0` and inserts the elements from `[f, l)` into it.
[horizontal]
Requires:;; `hasher`, `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
---
==== Allocator Constructor
```c++
explicit unordered_map(Allocator const& a);
@ -553,6 +569,19 @@ Requires:;; `key_equal` needs to be https://en.cppreference.com/w/cpp/named_req/
---
==== initializer_list Constructor with Allocator
```c++
unordered_map(std::initializer_list<value_type> il, const allocator_type& a);
```
Constructs an empty container using `a` as the allocator and a maximum load factor of 1.0 and inserts the elements from `il` into it.
[horizontal]
Requires:;; `hasher` and `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
---
==== initializer_list Constructor with Bucket Count and Allocator
```c++

32
doc/unordered/unordered_multimap.adoc
View File

@ -53,6 +53,8 @@ namespace boost {
const allocator_type& a = allocator_type());
xref:#unordered_multimap_copy_constructor[unordered_multimap](const unordered_multimap& other);
xref:#unordered_multimap_move_constructor[unordered_multimap](unordered_multimap&& other);
template<class InputIterator>
xref:#unordered_multimap_iterator_range_constructor_with_allocator[unordered_multimap](InputIterator f, InputIterator l, const allocator_type& 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_move_constructor_with_allocator[unordered_multimap](unordered_multimap&& other, const Allocator& a);
@ -68,7 +70,9 @@ 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_with_bucket_count_and_allocator[unordered_multimap](std::initializer_list<value_type> il, size_type n, const allocator_type& a);
xref:#unordered_multimap_initializer_list_constructor_with_allocator[unordered_multimap](std::initializer_list<value_type> il, const allocator_type& a);
xref:#unordered_multimap_initializer_list_constructor_with_bucket_count_and_allocator[unordered_multimap](std::initializer_list<value_type> il, size_type n,
const allocator_type& a);
xref:#unordered_multimap_initializer_list_constructor_with_bucket_count_and_hasher_and_allocator[unordered_multimap](std::initializer_list<value_type> il, size_type n, const hasher& hf,
const allocator_type& a);
xref:#unordered_multimap_destructor[~unordered_multimap]();
@ -416,6 +420,19 @@ So, for example, you can't return the container from a function.
---
==== Iterator Range Constructor with Allocator
```c++
template<class InputIterator>
unordered_multimap(InputIterator f, InputIterator l, const allocator_type& a);
```
Constructs an empty container using `a` as the allocator, with the default hash function and key equality predicate and a maximum load factor of `1.0` and inserts the elements from `[f, l)` into it.
[horizontal]
Requires:;; `hasher`, `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
---
==== Allocator Constructor
```c++
explicit unordered_multimap(const Allocator& a);
@ -518,6 +535,19 @@ Requires:;; `key_equal` needs to be https://en.cppreference.com/w/cpp/named_req/
---
==== initializer_list Constructor with Allocator
```c++
unordered_multimap(std::initializer_list<value_type> il, const allocator_type& a);
```
Constructs an empty container using `a` as the allocator and a maximum load factor of 1.0 and inserts the elements from `il` into it.
[horizontal]
Requires:;; `hasher` and `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
---
==== initializer_list Constructor with Bucket Count and Allocator
```c++

32
doc/unordered/unordered_multiset.adoc
View File

@ -51,6 +51,8 @@ namespace boost {
const allocator_type& a = allocator_type());
xref:#unordered_multiset_copy_constructor[unordered_multiset](const unordered_multiset& other);
xref:#unordered_multiset_move_constructor[unordered_multiset](unordered_multiset&& other);
template<class InputIterator>
xref:#unordered_multiset_iterator_range_constructor_with_allocator[unordered_multiset](InputIterator f, InputIterator l, const allocator_type& 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_move_constructor_with_allocator[unordered_multiset](unordered_multiset&& other, const Allocator& a);
@ -66,7 +68,9 @@ namespace boost {
template<class InputIterator>
xref:#unordered_multiset_iterator_range_constructor_with_bucket_count_and_hasher[unordered_multiset](InputIterator f, InputIterator l, size_type n, const hasher& hf,
const allocator_type& a);
xref:#unordered_multiset_initializer_list_constructor_with_bucket_count_and_allocator[unordered_multiset](std::initializer_list<value_type> il, size_type n, const allocator_type& a)
xref:#unordered_multiset_initializer_list_constructor_with_allocator[unordered_multiset](std::initializer_list<value_type> il, const allocator_type& a);
xref:#unordered_multiset_initializer_list_constructor_with_bucket_count_and_allocator[unordered_multiset](std::initializer_list<value_type> il, size_type n,
const allocator_type& a)
xref:#unordered_multiset_initializer_list_constructor_with_bucket_count_and_hasher_and_allocator[unordered_multiset](std::initializer_list<value_type> il, size_type n, const hasher& hf,
const allocator_type& a);
xref:#unordered_multiset_destructor[~unordered_multiset()];
@ -409,6 +413,19 @@ So, for example, you can't return the container from a function.
---
==== Iterator Range Constructor with Allocator
```c++
template<class InputIterator>
unordered_multiset(InputIterator f, InputIterator l, const allocator_type& a);
```
Constructs an empty container using `a` as the allocator, with the default hash function and key equality predicate and a maximum load factor of `1.0` and inserts the elements from `[f, l)` into it.
[horizontal]
Requires:;; `hasher`, `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
---
==== Allocator Constructor
```c++
explicit unordered_multiset(const Allocator& a);
@ -512,6 +529,19 @@ Requires:;; `key_equal` needs to be https://en.cppreference.com/w/cpp/named_req/
---
==== initializer_list Constructor with Allocator
```c++
unordered_multiset(std::initializer_list<value_type> il, const allocator_type& a);
```
Constructs an empty container using `a` as the allocator and a maximum load factor of 1.0 and inserts the elements from `il` into it.
[horizontal]
Requires:;; `hasher` and `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
---
==== initializer_list Constructor with Bucket Count and Allocator
```c++

29
doc/unordered/unordered_set.adoc
View File

@ -52,6 +52,8 @@ namespace boost {
const allocator_type& a = allocator_type());
xref:#unordered_set_copy_constructor[unordered_set](const unordered_set& other);
xref:#unordered_set_move_constructor[unordered_set](unordered_set&& other);
template<class InputIterator>
xref:#unordered_set_iterator_range_constructor_with_allocator[unordered_set](InputIterator f, InputIterator l, const allocator_type& 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_move_constructor_with_allocator[unordered_set](unordered_set&& other, const Allocator& a);
@ -67,6 +69,7 @@ namespace boost {
template<class InputIterator>
xref:#unordered_set_iterator_range_constructor_with_bucket_count_and_hasher[unordered_set](InputIterator f, InputIterator l, size_type n, const hasher& hf,
const allocator_type& a);
xref:#unordered_set_initializer_list_constructor_with_allocator[unordered_set](std::initializer_list<value_type> il, const allocator_type& a);
xref:#unordered_set_initializer_list_constructor_with_bucket_count_and_allocator[unordered_set](std::initializer_list<value_type> il, size_type n, const allocator_type& a);
xref:#unordered_set_initializer_list_constructor_with_bucket_count_and_hasher_and_allocator[unordered_set](std::initializer_list<value_type> il, size_type n, const hasher& hf,
const allocator_type& a);
@ -420,6 +423,19 @@ So, for example, you can't return the container from a function.
---
==== Iterator Range Constructor with Allocator
```c++
template<class InputIterator>
unordered_set(InputIterator f, InputIterator l, const allocator_type& a);
```
Constructs an empty container using `a` as the allocator, with the default hash function and key equality predicate and a maximum load factor of `1.0` and inserts the elements from `[f, l)` into it.
[horizontal]
Requires:;; `hasher`, `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
---
==== Allocator Constructor
```c++
explicit unordered_set(const Allocator& a);
@ -523,6 +539,19 @@ Requires:;; `key_equal` needs to be https://en.cppreference.com/w/cpp/named_req/
---
==== initializer_list Constructor with Allocator
```c++
unordered_set(std::initializer_list<value_type> il, const allocator_type& a);
```
Constructs an empty container using `a` as the allocator and a maximum load factor of 1.0 and inserts the elements from `il` into it.
[horizontal]
Requires:;; `hasher` and `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
---
==== initializer_list Constructor with Bucket Count and Allocator
```c++