boostorg/unordered
1
0
Fork 1
mirror of https://github.com/boostorg/unordered.git synced 2025-07-30 03:17:15 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #75 from cmazakas/release-notes-1.79

Browse Source 
Release Notes 1.79
This commit is contained in:
Peter Dimov
2022-01-07 21:07:07 +02:00
committed by GitHub
parent 7c2ba681e9 42190df874
commit 7fd972d669
3 changed files with 1135 additions and 358 deletions
Download Patch File Download Diff File Expand all files Collapse all files

638
doc/changes.qbk
View File

@ -10,136 +10,237 @@
[section:changes Change Log] [section:changes Change Log]
[h2 Review Version] [section Changes in 1.79.0]
Initial review version, for the review conducted from 7th December 2007 to * Improved C++20 support:
16th December 2007. * All containers have been updated to support
heterogeneous `count`, `equal_range` and `find`.
* Improved C++23 support:
* All containers have been updated to support
heterogeneous `erase` and `extract`.
* Changed behavior of `reserve` to eagerly
allocate ([@https://github.com/boostorg/unordered/pull/59 PR#59]).
* Various warning fixes in the test suite.
* Update code to internally use `boost::allocator_traits`.
[h2 1.35.0 Add-on - 31st March 2008] [endsect]
Unofficial release uploaded to vault, to be used with Boost 1.35.0. Incorporated [section Changes in 1.67.0]
many of the suggestions from the review.
* Improved portability thanks to Boost regression testing. * Improved C++17 support:
* Fix lots of typos, and clearer text in the documentation. * Add template deduction guides from the standard.
* Fix floating point to `std::size_t` conversion when calculating sizes from * Use a simple implementation of `optional` in node handles, so
the max load factor, and use `double` in the calculation for greater accuracy. that they're closer to the standard.
* Fix some errors in the examples. * Add missing `noexcept` specifications to `swap`, `operator=`
and node handles, and change the implementation to match.
Using `std::allocator_traits::is_always_equal`, or our own
implementation when not available, and
`boost::is_nothrow_swappable` in the implementation.
* Improved C++20 support:
* Use `boost::to_address`, which has the proposed C++20 semantics,
rather than the old custom implementation.
* Add `element_type` to iterators, so that `std::pointer_traits`
will work.
* Use `std::piecewise_construct` on recent versions of Visual C++,
and other uses of the Dinkumware standard library,
now using Boost.Predef to check compiler and library versions.
* Use `std::iterator_traits` rather than the boost iterator traits
in order to remove dependency on Boost.Iterator.
* Remove iterators' inheritance from `std::iterator`, which is
deprecated in C++17, thanks to Daniela Engert
([@https://github.com/boostorg/unordered/pull/7 PR#7]).
* Stop using `BOOST_DEDUCED_TYPENAME`.
* Update some Boost include paths.
* Rename some internal methods, and variables.
* Various testing improvements.
* Miscellaneous internal changes.
[h2 Boost 1.36.0] [endsect]
First official release. [section Changes in 1.66.0]
* Rearrange the internals. * Simpler move construction implementation.
* Move semantics - full support when rvalue references are available, emulated * Documentation fixes ([pull_request 6]).
using a cut down version of the Adobe move library when they are not.
* Emplace support when rvalue references and variadic template are available.
* More efficient node allocation when rvalue references and variadic template
are available.
* Added equality operators.
[h2 Boost 1.37.0] [endsect]
* Rename overload of `emplace` with hint, to `emplace_hint` as specified in [section Changes in 1.65.0]
[@http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2008/n2691.pdf n2691].
* Provide forwarding headers at `<boost/unordered/unordered_map_fwd.hpp>` and
`<boost/unordered/unordered_set_fwd.hpp>`.
* Move all the implementation inside `boost/unordered`, to assist
modularization and hopefully make it easier to track changes in subversion.
[h2 Boost 1.38.0] * Add deprecated attributes to `quick_erase` and `erase_return_void`.
I really will remove them in a future version this time.
* Small standards compliance fixes:
* `noexpect` specs for `swap` free functions.
* Add missing `insert(P&&)` methods.
* Use [@boost:/libs/core/swap.html `boost::swap`]. [endsect]
* [@https://svn.boost.org/trac/boost/ticket/2237 Ticket 2237]:
Document that the equality and inequality operators are undefined for two
objects if their equality predicates aren't equivalent. Thanks to Daniel
Krügler.
* [@https://svn.boost.org/trac/boost/ticket/1710 Ticket 1710]:
Use a larger prime number list. Thanks to Thorsten Ottosen and Hervé
Brönnimann.
* Use
[@boost:/libs/type_traits/doc/html/boost_typetraits/category/alignment.html
aligned storage] to store the types. This changes the way the allocator is
used to construct nodes. It used to construct the node with two calls to
the allocator's `construct` method - once for the pointers and once for the
value. It now constructs the node with a single call to construct and
then constructs the value using in place construction.
* Add support for C++0x initializer lists where they're available (currently
only g++ 4.4 in C++0x mode).
[h2 Boost 1.39.0] [section Changes in 1.64.0]
* [@https://svn.boost.org/trac/boost/ticket/2756 Ticket 2756]: Avoid a warning * Initial support for new C++17 member functions:
on Visual C++ 2009. `insert_or_assign` and `try_emplace` in `unordered_map`,
* Some other minor internal changes to the implementation, tests and * Initial support for `merge` and `extract`.
documentation. Does not include transferring nodes between
* Avoid an unnecessary copy in `operator[]`. `unordered_map` and `unordered_multimap` or between `unordered_set` and
* [@https://svn.boost.org/trac/boost/ticket/2975 Ticket 2975]: Fix length of `unordered_multiset` yet. That will hopefully be in the next version of
prime number list. Boost.
[h2 Boost 1.40.0] [endsect]
* [@https://svn.boost.org/trac/boost/ticket/2975 Ticket 2975]: [section Changes in 1.63.0]
Store the prime list as a preprocessor sequence - so that it will always get
the length right if it changes again in the future.
* [@https://svn.boost.org/trac/boost/ticket/1978 Ticket 1978]:
Implement `emplace` for all compilers.
* [@https://svn.boost.org/trac/boost/ticket/2908 Ticket 2908],
[@https://svn.boost.org/trac/boost/ticket/3096 Ticket 3096]:
Some workarounds for old versions of borland, including adding explicit
destructors to all containers.
* [@https://svn.boost.org/trac/boost/ticket/3082 Ticket 3082]:
Disable incorrect Visual C++ warnings.
* Better configuration for C++0x features when the headers aren't available.
* Create less buckets by default.
[h2 Boost 1.41.0 - Major update] * Check hint iterator in `insert`/`emplace_hint`.
* Fix some warnings, mostly in the tests.
* Manually write out `emplace_args` for small numbers of arguments -
should make template error messages a little more bearable.
* Remove superfluous use of `boost::forward` in emplace arguments,
which fixes emplacing string literals in old versions of Visual C++.
* Fix an exception safety issue in assignment. If bucket allocation
throws an exception, it can overwrite the hash and equality functions while
leaving the existing elements in place. This would mean that the function
objects wouldn't match the container elements, so elements might be in the
wrong bucket and equivalent elements would be incorrectly handled.
* Various reference documentation improvements.
* Better allocator support ([ticket 12459]).
* Make the no argument constructors implicit.
* Implement missing allocator aware constructors.
* Fix assigning the hash/key equality functions for empty containers.
* Remove unary/binary_function from the examples in the documentation.
They are removed in C++17.
* Support 10 constructor arguments in emplace. It was meant to support up to 10
arguments, but an off by one error in the preprocessor code meant it only
supported up to 9.
* The original version made heavy use of macros to sidestep some of the older [endsect]
compilers' poor template support. But since I no longer support those
compilers and the macro use was starting to become a maintenance burden it
has been rewritten to use templates instead of macros for the implementation
classes.
* The container object is now smaller thanks to using `boost::compressed_pair` [section Changes in 1.62.0]
for EBO and a slightly different function buffer - now using a bool instead
of a member pointer.
* Buckets are allocated lazily which means that constructing an empty container * Remove use of deprecated `boost::iterator`.
will not allocate any memory. * Remove `BOOST_NO_STD_DISTANCE` workaround.
* Remove `BOOST_UNORDERED_DEPRECATED_EQUALITY` warning.
* Simpler implementation of assignment, fixes an exception safety issue
for `unordered_multiset` and `unordered_multimap`. Might be a little slower.
* Stop using return value SFINAE which some older compilers have issues
with.
[h2 Boost 1.42.0] [endsect]
* Support instantiating the containers with incomplete value types. [section Changes in 1.58.0]
* Reduced the number of warnings (mostly in tests).
* Improved codegear compatibility.
* [@http://svn.boost.org/trac/boost/ticket/3693 Ticket 3693]:
Add `erase_return_void` as a temporary workaround for the current
`erase` which can be inefficient because it has to find the next
element to return an iterator.
* Add templated find overload for compatible keys.
* [@http://svn.boost.org/trac/boost/ticket/3773 Ticket 3773]:
Add missing `std` qualifier to `ptrdiff_t`.
* Some code formatting changes to fit almost all lines into 80 characters.
[h2 Boost 1.43.0] * Remove unnecessary template parameter from const iterators.
* Rename private `iterator` typedef in some iterator classes, as it
confuses some traits classes.
* Fix move assignment with stateful, propagate_on_container_move_assign
allocators ([ticket 10777]).
* Fix rare exception safety issue in move assignment.
* Fix potential overflow when calculating number of buckets to allocate
([@https://github.com/boostorg/unordered/pull/4 GitHub #4]).
* [@http://svn.boost.org/trac/boost/ticket/3966 Ticket 3966]: [endsect]
`erase_return_void` is now `quick_erase`, which is the
[@http://home.roadrunner.com/~hinnant/issue_review/lwg-active.html#579
current forerunner for resolving the slow erase by iterator], although
there's a strong possibility that this may change in the future. The old
method name remains for backwards compatibility but is considered deprecated
and will be removed in a future release.
* Use Boost.Exception.
* Stop using deprecated `BOOST_HAS_*` macros.
[h2 Boost 1.45.0] [section Changes in 1.57.0]
* Fix a bug when inserting into an `unordered_map` or `unordered_set` using * Fix the `pointer` typedef in iterators ([ticket 10672]).
iterators which returns `value_type` by copy. * Fix Coverity warning
([@https://github.com/boostorg/unordered/pull/2 GitHub #2]).
[h2 Boost 1.48.0 - Major update] [endsect]
[section Changes in 1.56.0]
* Fix some shadowed variable warnings ([ticket 9377]).
* Fix allocator use in documentation ([ticket 9719]).
* Always use prime number of buckets for integers. Fixes performance
regression when inserting consecutive integers, although makes other
uses slower ([ticket 9282]).
* Only construct elements using allocators, as specified in C++11 standard.
[endsect]
[section Changes in 1.55.0]
* Avoid some warnings ([ticket 8851], [ticket 8874]).
* Avoid exposing some detail functions via. ADL on the iterators.
* Follow the standard by only using the allocators' construct and destroy
methods to construct and destroy stored elements. Don't use them for internal
data like pointers.
[endsect]
[section Changes in 1.54.0]
* Mark methods specified in standard as `noexpect`. More to come in the next
release.
* If the hash function and equality predicate are known to both have nothrow
move assignment or construction then use them.
[endsect]
[section Changes in 1.53.0]
* Remove support for the old pre-standard variadic pair constructors, and
equality implementation. Both have been deprecated since Boost 1.48.
* Remove use of deprecated config macros.
* More internal implementation changes, including a much simpler
implementation of `erase`.
[endsect]
[section Changes in 1.52.0]
* Faster assign, which assigns to existing nodes where possible, rather than
creating entirely new nodes and copy constructing.
* Fixed bug in `erase_range` ([ticket 7471]).
* Reverted some of the internal changes to how nodes are created, especially
for C++11 compilers. 'construct' and 'destroy' should work a little better
for C++11 allocators.
* Simplified the implementation a bit. Hopefully more robust.
[endsect]
[section Changes in 1.51.0]
* Fix construction/destruction issue when using a C++11 compiler with a
C++03 allocator ([ticket 7100]).
* Remove a `try..catch` to support compiling without exceptions.
* Adjust SFINAE use to try to support g++ 3.4 ([ticket 7175]).
* Updated to use the new config macros.
[endsect]
[section Changes in 1.50.0]
* Fix equality for `unordered_multiset` and `unordered_multimap`.
* [@https://svn.boost.org/trac/boost/ticket/6857 Ticket 6857]:
Implement `reserve`.
* [@https://svn.boost.org/trac/boost/ticket/6771 Ticket 6771]:
Avoid gcc's `-Wfloat-equal` warning.
* [@https://svn.boost.org/trac/boost/ticket/6784 Ticket 6784]:
Fix some Sun specific code.
* [@https://svn.boost.org/trac/boost/ticket/6190 Ticket 6190]:
Avoid gcc's `-Wshadow` warning.
* [@https://svn.boost.org/trac/boost/ticket/6905 Ticket 6905]:
Make namespaces in macros compatible with `bcp` custom namespaces.
Fixed by Luke Elliott.
* Remove some of the smaller prime number of buckets, as they may make
collisions quite probable (e.g. multiples of 5 are very common because
we used base 10).
* On old versions of Visual C++, use the container library's implementation
of `allocator_traits`, as it's more likely to work.
* On machines with 64 bit std::size_t, use power of 2 buckets, with Thomas
Wang's hash function to pick which one to use. As modulus is very slow
for 64 bit values.
* Some internal changes.
[endsect]
[section Changes in 1.49.0]
* Fix warning due to accidental odd assignment.
* Slightly better error messages.
[endsect]
[section Changes in 1.48.0 - Major update]
This is major change which has been converted to use Boost.Move's move This is major change which has been converted to use Boost.Move's move
emulation, and be more compliant with the C++11 standard. See the emulation, and be more compliant with the C++11 standard. See the
@ -175,186 +276,157 @@ C++11 support has resulted in some breaking changes:
the variadic constructors define the variadic constructors define
`BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT`. `BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT`.
[h2 Boost 1.49.0] [endsect]
* Fix warning due to accidental odd assignment. [section Changes in 1.45.0]
* Slightly better error messages.
[h2 Boost 1.50.0] * Fix a bug when inserting into an `unordered_map` or `unordered_set` using
iterators which returns `value_type` by copy.
* Fix equality for `unordered_multiset` and `unordered_multimap`.
* [@https://svn.boost.org/trac/boost/ticket/6857 Ticket 6857]: [endsect]
Implement `reserve`.
* [@https://svn.boost.org/trac/boost/ticket/6771 Ticket 6771]: [section Changes in 1.43.0]
Avoid gcc's `-Wfloat-equal` warning.
* [@https://svn.boost.org/trac/boost/ticket/6784 Ticket 6784]: * [@http://svn.boost.org/trac/boost/ticket/3966 Ticket 3966]:
Fix some Sun specific code. `erase_return_void` is now `quick_erase`, which is the
* [@https://svn.boost.org/trac/boost/ticket/6190 Ticket 6190]: [@http://home.roadrunner.com/~hinnant/issue_review/lwg-active.html#579
Avoid gcc's `-Wshadow` warning. current forerunner for resolving the slow erase by iterator], although
* [@https://svn.boost.org/trac/boost/ticket/6905 Ticket 6905]: there's a strong possibility that this may change in the future. The old
Make namespaces in macros compatible with `bcp` custom namespaces. method name remains for backwards compatibility but is considered deprecated
Fixed by Luke Elliott. and will be removed in a future release.
* Remove some of the smaller prime number of buckets, as they may make * Use Boost.Exception.
collisions quite probable (e.g. multiples of 5 are very common because * Stop using deprecated `BOOST_HAS_*` macros.
we used base 10).
* On old versions of Visual C++, use the container library's implementation [endsect]
of `allocator_traits`, as it's more likely to work.
* On machines with 64 bit std::size_t, use power of 2 buckets, with Thomas [section Changes in 1.42.0]
Wang's hash function to pick which one to use. As modulus is very slow
for 64 bit values. * Support instantiating the containers with incomplete value types.
* Some internal changes. * Reduced the number of warnings (mostly in tests).
* Improved codegear compatibility.
[h2 Boost 1.51.0] * [@http://svn.boost.org/trac/boost/ticket/3693 Ticket 3693]:
Add `erase_return_void` as a temporary workaround for the current
* Fix construction/destruction issue when using a C++11 compiler with a `erase` which can be inefficient because it has to find the next
C++03 allocator ([ticket 7100]). element to return an iterator.
* Remove a `try..catch` to support compiling without exceptions. * Add templated find overload for compatible keys.
* Adjust SFINAE use to try to support g++ 3.4 ([ticket 7175]). * [@http://svn.boost.org/trac/boost/ticket/3773 Ticket 3773]:
* Updated to use the new config macros. Add missing `std` qualifier to `ptrdiff_t`.
* Some code formatting changes to fit almost all lines into 80 characters.
[h2 Boost 1.52.0]
[endsect]
* Faster assign, which assigns to existing nodes where possible, rather than
creating entirely new nodes and copy constructing. [section Changes in 1.41.0 - Major update]
* Fixed bug in `erase_range` ([ticket 7471]).
* Reverted some of the internal changes to how nodes are created, especially * The original version made heavy use of macros to sidestep some of the older
for C++11 compilers. 'construct' and 'destroy' should work a little better compilers' poor template support. But since I no longer support those
for C++11 allocators. compilers and the macro use was starting to become a maintenance burden it
* Simplified the implementation a bit. Hopefully more robust. has been rewritten to use templates instead of macros for the implementation
classes.
[h2 Boost 1.53.0]
* The container object is now smaller thanks to using `boost::compressed_pair`
* Remove support for the old pre-standard variadic pair constructors, and for EBO and a slightly different function buffer - now using a bool instead
equality implementation. Both have been deprecated since Boost 1.48. of a member pointer.
* Remove use of deprecated config macros.
* More internal implementation changes, including a much simpler * Buckets are allocated lazily which means that constructing an empty container
implementation of `erase`. will not allocate any memory.
[h2 Boost 1.54.0] [endsect]
* Mark methods specified in standard as `noexpect`. More to come in the next [section Changes in 1.40.0]
release.
* If the hash function and equality predicate are known to both have nothrow * [@https://svn.boost.org/trac/boost/ticket/2975 Ticket 2975]:
move assignment or construction then use them. Store the prime list as a preprocessor sequence - so that it will always get
the length right if it changes again in the future.
[h2 Boost 1.55.0] * [@https://svn.boost.org/trac/boost/ticket/1978 Ticket 1978]:
Implement `emplace` for all compilers.
* Avoid some warnings ([ticket 8851], [ticket 8874]). * [@https://svn.boost.org/trac/boost/ticket/2908 Ticket 2908],
* Avoid exposing some detail functions via. ADL on the iterators. [@https://svn.boost.org/trac/boost/ticket/3096 Ticket 3096]:
* Follow the standard by only using the allocators' construct and destroy Some workarounds for old versions of borland, including adding explicit
methods to construct and destroy stored elements. Don't use them for internal destructors to all containers.
data like pointers. * [@https://svn.boost.org/trac/boost/ticket/3082 Ticket 3082]:
Disable incorrect Visual C++ warnings.
[h2 Boost 1.56.0] * Better configuration for C++0x features when the headers aren't available.
* Create less buckets by default.
* Fix some shadowed variable warnings ([ticket 9377]).
* Fix allocator use in documentation ([ticket 9719]). [endsect]
* Always use prime number of buckets for integers. Fixes performance
regression when inserting consecutive integers, although makes other [section Changes in 1.39.0]
uses slower ([ticket 9282]).
* Only construct elements using allocators, as specified in C++11 standard. * [@https://svn.boost.org/trac/boost/ticket/2756 Ticket 2756]: Avoid a warning
on Visual C++ 2009.
[h2 Boost 1.57.0] * Some other minor internal changes to the implementation, tests and
documentation.
* Fix the `pointer` typedef in iterators ([ticket 10672]). * Avoid an unnecessary copy in `operator[]`.
* Fix Coverity warning * [@https://svn.boost.org/trac/boost/ticket/2975 Ticket 2975]: Fix length of
([@https://github.com/boostorg/unordered/pull/2 GitHub #2]). prime number list.
[h2 Boost 1.58.0] [endsect]
* Remove unnecessary template parameter from const iterators. [section Changes in 1.38.0]
* Rename private `iterator` typedef in some iterator classes, as it
confuses some traits classes. * Use [@boost:/libs/core/swap.html `boost::swap`].
* Fix move assignment with stateful, propagate_on_container_move_assign * [@https://svn.boost.org/trac/boost/ticket/2237 Ticket 2237]:
allocators ([ticket 10777]). Document that the equality and inequality operators are undefined for two
* Fix rare exception safety issue in move assignment. objects if their equality predicates aren't equivalent. Thanks to Daniel
* Fix potential overflow when calculating number of buckets to allocate Krügler.
([@https://github.com/boostorg/unordered/pull/4 GitHub #4]). * [@https://svn.boost.org/trac/boost/ticket/1710 Ticket 1710]:
Use a larger prime number list. Thanks to Thorsten Ottosen and Hervé
[h2 Boost 1.62.0] Brönnimann.
* Use
* Remove use of deprecated `boost::iterator`. [@boost:/libs/type_traits/doc/html/boost_typetraits/category/alignment.html
* Remove `BOOST_NO_STD_DISTANCE` workaround. aligned storage] to store the types. This changes the way the allocator is
* Remove `BOOST_UNORDERED_DEPRECATED_EQUALITY` warning. used to construct nodes. It used to construct the node with two calls to
* Simpler implementation of assignment, fixes an exception safety issue the allocator's `construct` method - once for the pointers and once for the
for `unordered_multiset` and `unordered_multimap`. Might be a little slower. value. It now constructs the node with a single call to construct and
* Stop using return value SFINAE which some older compilers have issues then constructs the value using in place construction.
with. * Add support for C++0x initializer lists where they're available (currently
only g++ 4.4 in C++0x mode).
[h2 Boost 1.63.0]
[endsect]
* Check hint iterator in `insert`/`emplace_hint`.
* Fix some warnings, mostly in the tests. [section Changes in 1.37.0]
* Manually write out `emplace_args` for small numbers of arguments -
should make template error messages a little more bearable. * Rename overload of `emplace` with hint, to `emplace_hint` as specified in
* Remove superfluous use of `boost::forward` in emplace arguments, [@http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2008/n2691.pdf n2691].
which fixes emplacing string literals in old versions of Visual C++. * Provide forwarding headers at `<boost/unordered/unordered_map_fwd.hpp>` and
* Fix an exception safety issue in assignment. If bucket allocation `<boost/unordered/unordered_set_fwd.hpp>`.
throws an exception, it can overwrite the hash and equality functions while * Move all the implementation inside `boost/unordered`, to assist
leaving the existing elements in place. This would mean that the function modularization and hopefully make it easier to track changes in subversion.
objects wouldn't match the container elements, so elements might be in the
wrong bucket and equivalent elements would be incorrectly handled. [endsect]
* Various reference documentation improvements.
* Better allocator support ([ticket 12459]). [section Changes in 1.36.0]
* Make the no argument constructors implicit.
* Implement missing allocator aware constructors. First official release.
* Fix assigning the hash/key equality functions for empty containers.
* Remove unary/binary_function from the examples in the documentation. * Rearrange the internals.
They are removed in C++17. * Move semantics - full support when rvalue references are available, emulated
* Support 10 constructor arguments in emplace. It was meant to support up to 10 using a cut down version of the Adobe move library when they are not.
arguments, but an off by one error in the preprocessor code meant it only * Emplace support when rvalue references and variadic template are available.
supported up to 9. * More efficient node allocation when rvalue references and variadic template
are available.
[h2 Boost 1.64.0] * Added equality operators.
* Initial support for new C++17 member functions:
`insert_or_assign` and `try_emplace` in `unordered_map`, [endsect]
* Initial support for `merge` and `extract`.
Does not include transferring nodes between [section 1.35.0 Add-on - 31st March 2008]
`unordered_map` and `unordered_multimap` or between `unordered_set` and
`unordered_multiset` yet. That will hopefully be in the next version of Unofficial release uploaded to vault, to be used with Boost 1.35.0. Incorporated
Boost. many of the suggestions from the review.
[h2 Boost 1.65.0] * Improved portability thanks to Boost regression testing.
* Fix lots of typos, and clearer text in the documentation.
* Add deprecated attributes to `quick_erase` and `erase_return_void`. * Fix floating point to `std::size_t` conversion when calculating sizes from
I really will remove them in a future version this time. the max load factor, and use `double` in the calculation for greater accuracy.
* Small standards compliance fixes: * Fix some errors in the examples.
* `noexpect` specs for `swap` free functions.
* Add missing `insert(P&&)` methods. [endsect]
[h2 Boost 1.66.0] [section Review Version]
* Simpler move construction implementation. Initial review version, for the review conducted from 7th December 2007 to
* Documentation fixes ([pull_request 6]). 16th December 2007.
[h2 Boost 1.67.0] [endsect]
* Improved C++17 support:
* Add template deduction guides from the standard.
* Use a simple implementation of `optional` in node handles, so
that they're closer to the standard.
* Add missing `noexcept` specifications to `swap`, `operator=`
and node handles, and change the implementation to match.
Using `std::allocator_traits::is_always_equal`, or our own
implementation when not available, and
`boost::is_nothrow_swappable` in the implementation.
* Improved C++20 support:
* Use `boost::to_address`, which has the proposed C++20 semantics,
rather than the old custom implementation.
* Add `element_type` to iterators, so that `std::pointer_traits`
will work.
* Use `std::piecewise_construct` on recent versions of Visual C++,
and other uses of the Dinkumware standard library,
now using Boost.Predef to check compiler and library versions.
* Use `std::iterator_traits` rather than the boost iterator traits
in order to remove dependency on Boost.Iterator.
* Remove iterators' inheritance from `std::iterator`, which is
deprecated in C++17, thanks to Daniela Engert
([@https://github.com/boostorg/unordered/pull/7 PR#7]).
* Stop using `BOOST_DEDUCED_TYPENAME`.
* Update some Boost include paths.
* Rename some internal methods, and variables.
* Various testing improvements.
* Miscellaneous internal changes.
[endsect] [endsect]

171
doc/ref.php
View File

@ -953,6 +953,38 @@ EOL;
</para> </para>
</notes> </notes>
</method> </method>
<method name="extract">
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K&amp;&amp;</paramtype>
</parameter>
<type>node_type</type>
<description>
<para>Removes an element with key equivalent to <code>k</code>.</para>
<para>
This overload only participates in overload resolution if <code>Hash::is_transparent</code>
and <code>Pred::is_transparent</code> are valid member typedefs and neither <code>iterator</code>
nor <code>const_iterator</code> are implicitly convertible from <code>K</code>. The library
assumes that <code>Hash</code> is callable with both <code>K</code> and <code>Key</code> and
that <code>Pred</code> is transparent. This enables heterogeneous lookup which avoids the cost of
instantiating an instance of the <code>Key</code> type.
</para>
</description>
<returns>
<para>A <code>node_type</code> owning the element if found, otherwise an empty <code>node_type</code>.</para>
</returns>
<throws>
<para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
</throws>
<notes>
<para>
In C++17 a node extracted using this method can be inserted into a compatible <code><?php echo $node_partner; ?></code>,
but that is not supported yet.
</para>
</notes>
</method>
<method name="insert"> <method name="insert">
<parameter name="nh"> <parameter name="nh">
<paramtype>node_type&amp;&amp;</paramtype> <paramtype>node_type&amp;&amp;</paramtype>
@ -1084,6 +1116,32 @@ EOL;
<para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para> <para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
</throws> </throws>
</method> </method>
<method name="erase">
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K&amp;&amp;</paramtype>
</parameter>
<type>size_type</type>
<returns>
<para>The number of elements erased.</para>
</returns>
<throws>
<para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
</throws>
<description>
<para>Erase all elements with key equivalent to <code>k</code>.</para>
<para>
This overload only participates in overload resolution if <code>Hash::is_transparent</code>
and <code>Pred::is_transparent</code> are valid member typedefs and neither <code>iterator</code>
nor <code>const_iterator</code> are implicitly convertible from <code>K</code>. The library
assumes that <code>Hash</code> is callable with both <code>K</code> and <code>Key</code> and
that <code>Pred</code> is transparent. This enables heterogeneous lookup which avoids the cost of
instantiating an instance of the <code>Key</code> type.
</para>
</description>
</method>
<method name="erase"> <method name="erase">
<parameter name="first"> <parameter name="first">
<paramtype>const_iterator</paramtype> <paramtype>const_iterator</paramtype>
@ -1272,6 +1330,24 @@ EOL;
</parameter> </parameter>
<type>const_iterator</type> <type>const_iterator</type>
</signature> </signature>
<signature>
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K const&amp;</paramtype>
</parameter>
<type>iterator</type>
</signature>
<signature cv="const">
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K const&amp;</paramtype>
</parameter>
<type>const_iterator</type>
</signature>
<signature> <signature>
<template> <template>
<template-type-parameter name="CompatibleKey"/> <template-type-parameter name="CompatibleKey"/>
@ -1309,22 +1385,58 @@ EOL;
<returns> <returns>
<para>An iterator pointing to an element with key equivalent to <code>k</code>, or <code>b.end()</code> if no such element exists.</para> <para>An iterator pointing to an element with key equivalent to <code>k</code>, or <code>b.end()</code> if no such element exists.</para>
</returns> </returns>
<notes><para> <notes>
The templated overloads are a non-standard extensions which <para>
allows you to use a compatible hash function and equality The templated overloads containing <code>CompatibleKey</code>,
predicate for a key of a different type in order to avoid <code>CompatibleHash</code> and <code>CompatiblePredicate</code>
an expensive type cast. In general, its use is not encouraged. are non-standard extensions which allow you to use a compatible
</para></notes> hash function and equality predicate for a key of a different type
</overloaded-method> in order to avoid an expensive type cast. In general, its use is
<method name="count" cv="const"> not encouraged and instead the <code>K</code> member function
<parameter name="k"> templates should be used.
<paramtype>key_type const&amp;</paramtype> </para>
</parameter> <para>
<type>size_type</type> The <code>template &lt;typename K&gt;</code> overloads only participate
in overload resolution if <code>Hash::is_transparent</code> and
<code>Pred::is_transparent</code> are valid member typedefs. The
library assumes that <code>Hash</code> is callable with both
<code>K</code> and <code>Key</code> and that <code>Pred</code> is
transparent. This enables heterogeneous lookup which avoids the cost of
instantiating an instance of the <code>Key</code> type.
</para>
</notes>
</overloaded-method>
<overloaded-method name="count">
<signature cv="const">
<parameter name="k">
<paramtype>key_type const&amp;</paramtype>
</parameter>
<type>size_type</type>
</signature>
<signature cv="const">
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K const&amp;</paramtype>
</parameter>
<type>size_type</type>
</signature>
<returns> <returns>
<para>The number of elements with key equivalent to <code>k</code>.</para> <para>The number of elements with key equivalent to <code>k</code>.</para>
</returns> </returns>
</method> <notes>
<para>
The <code>template &lt;typename K&gt;</code> overload only participates
in overload resolution if <code>Hash::is_transparent</code> and
<code>Pred::is_transparent</code> are valid member typedefs. The
library assumes that <code>Hash</code> is callable with both
<code>K</code> and <code>Key</code> and that <code>Pred</code> is
transparent. This enables heterogeneous lookup which avoids the cost of
instantiating an instance of the <code>Key</code> type.
</para>
</notes>
</overloaded-method>
<overloaded-method name="equal_range"> <overloaded-method name="equal_range">
<signature> <signature>
<parameter name="k"> <parameter name="k">
@ -1338,12 +1450,41 @@ EOL;
</parameter> </parameter>
<type>std::pair&lt;const_iterator, const_iterator&gt;</type> <type>std::pair&lt;const_iterator, const_iterator&gt;</type>
</signature> </signature>
<signature>
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K const&amp;</paramtype>
</parameter>
<type>std::pair&lt;iterator, iterator&gt;</type>
</signature>
<signature cv="const">
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K const&amp;</paramtype>
</parameter>
<type>std::pair&lt;const_iterator, const_iterator&gt;</type>
</signature>
<returns> <returns>
<para>A range containing all elements with key equivalent to <code>k</code>. <para>A range containing all elements with key equivalent to <code>k</code>.
If the container doesn't container any such elements, returns If the container doesn't contain any such elements, returns
<code><functionname>std::make_pair</functionname>(<methodname>b.end</methodname>(),<methodname>b.end</methodname>())</code>. <code><functionname>std::make_pair</functionname>(<methodname>b.end</methodname>(),<methodname>b.end</methodname>())</code>.
</para> </para>
</returns> </returns>
<notes>
<para>
The <code>template &lt;typename K&gt;</code> overloads only participate
in overload resolution if <code>Hash::is_transparent</code> and
<code>Pred::is_transparent</code> are valid member typedefs. The
library assumes that <code>Hash</code> is callable with both
<code>K</code> and <code>Key</code> and that <code>Pred</code> is
transparent. This enables heterogeneous lookup which avoids the cost of
instantiating an instance of the <code>Key</code> type.
</para>
</notes>
</overloaded-method> </overloaded-method>
<?php if ($map && !$equivalent_keys): ?> <?php if ($map && !$equivalent_keys): ?>
<method name="operator[]"> <method name="operator[]">

684
doc/ref.xml
View File

@ -840,6 +840,38 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
</para> </para>
</notes> </notes>
</method> </method>
<method name="extract">
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K&amp;&amp;</paramtype>
</parameter>
<type>node_type</type>
<description>
<para>Removes an element with key equivalent to <code>k</code>.</para>
<para>
This overload only participates in overload resolution if <code>Hash::is_transparent</code>
and <code>Pred::is_transparent</code> are valid member typedefs and neither <code>iterator</code>
nor <code>const_iterator</code> are implicitly convertible from <code>K</code>. The library
assumes that <code>Hash</code> is callable with both <code>K</code> and <code>Key</code> and
that <code>Pred</code> is transparent. This enables heterogeneous lookup which avoids the cost of
instantiating an instance of the <code>Key</code> type.
</para>
</description>
<returns>
<para>A <code>node_type</code> owning the element if found, otherwise an empty <code>node_type</code>.</para>
</returns>
<throws>
<para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
</throws>
<notes>
<para>
In C++17 a node extracted using this method can be inserted into a compatible <code>unordered_multiset</code>,
but that is not supported yet.
</para>
</notes>
</method>
<method name="insert"> <method name="insert">
<parameter name="nh"> <parameter name="nh">
<paramtype>node_type&amp;&amp;</paramtype> <paramtype>node_type&amp;&amp;</paramtype>
@ -951,6 +983,32 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
<para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para> <para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
</throws> </throws>
</method> </method>
<method name="erase">
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K&amp;&amp;</paramtype>
</parameter>
<type>size_type</type>
<returns>
<para>The number of elements erased.</para>
</returns>
<throws>
<para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
</throws>
<description>
<para>Erase all elements with key equivalent to <code>k</code>.</para>
<para>
This overload only participates in overload resolution if <code>Hash::is_transparent</code>
and <code>Pred::is_transparent</code> are valid member typedefs and neither <code>iterator</code>
nor <code>const_iterator</code> are implicitly convertible from <code>K</code>. The library
assumes that <code>Hash</code> is callable with both <code>K</code> and <code>Key</code> and
that <code>Pred</code> is transparent. This enables heterogeneous lookup which avoids the cost of
instantiating an instance of the <code>Key</code> type.
</para>
</description>
</method>
<method name="erase"> <method name="erase">
<parameter name="first"> <parameter name="first">
<paramtype>const_iterator</paramtype> <paramtype>const_iterator</paramtype>
@ -1099,6 +1157,24 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
</parameter> </parameter>
<type>const_iterator</type> <type>const_iterator</type>
</signature> </signature>
<signature>
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K const&amp;</paramtype>
</parameter>
<type>iterator</type>
</signature>
<signature cv="const">
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K const&amp;</paramtype>
</parameter>
<type>const_iterator</type>
</signature>
<signature> <signature>
<template> <template>
<template-type-parameter name="CompatibleKey"/> <template-type-parameter name="CompatibleKey"/>
@ -1136,22 +1212,58 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
<returns> <returns>
<para>An iterator pointing to an element with key equivalent to <code>k</code>, or <code>b.end()</code> if no such element exists.</para> <para>An iterator pointing to an element with key equivalent to <code>k</code>, or <code>b.end()</code> if no such element exists.</para>
</returns> </returns>
<notes><para> <notes>
The templated overloads are a non-standard extensions which <para>
allows you to use a compatible hash function and equality The templated overloads containing <code>CompatibleKey</code>,
predicate for a key of a different type in order to avoid <code>CompatibleHash</code> and <code>CompatiblePredicate</code>
an expensive type cast. In general, its use is not encouraged. are non-standard extensions which allow you to use a compatible
</para></notes> hash function and equality predicate for a key of a different type
</overloaded-method> in order to avoid an expensive type cast. In general, its use is
<method name="count" cv="const"> not encouraged and instead the <code>K</code> member function
<parameter name="k"> templates should be used.
<paramtype>key_type const&amp;</paramtype> </para>
</parameter> <para>
<type>size_type</type> The <code>template &lt;typename K&gt;</code> overloads only participate
in overload resolution if <code>Hash::is_transparent</code> and
<code>Pred::is_transparent</code> are valid member typedefs. The
library assumes that <code>Hash</code> is callable with both
<code>K</code> and <code>Key</code> and that <code>Pred</code> is
transparent. This enables heterogeneous lookup which avoids the cost of
instantiating an instance of the <code>Key</code> type.
</para>
</notes>
</overloaded-method>
<overloaded-method name="count">
<signature cv="const">
<parameter name="k">
<paramtype>key_type const&amp;</paramtype>
</parameter>
<type>size_type</type>
</signature>
<signature cv="const">
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K const&amp;</paramtype>
</parameter>
<type>size_type</type>
</signature>
<returns> <returns>
<para>The number of elements with key equivalent to <code>k</code>.</para> <para>The number of elements with key equivalent to <code>k</code>.</para>
</returns> </returns>
</method> <notes>
<para>
The <code>template &lt;typename K&gt;</code> overload only participates
in overload resolution if <code>Hash::is_transparent</code> and
<code>Pred::is_transparent</code> are valid member typedefs. The
library assumes that <code>Hash</code> is callable with both
<code>K</code> and <code>Key</code> and that <code>Pred</code> is
transparent. This enables heterogeneous lookup which avoids the cost of
instantiating an instance of the <code>Key</code> type.
</para>
</notes>
</overloaded-method>
<overloaded-method name="equal_range"> <overloaded-method name="equal_range">
<signature> <signature>
<parameter name="k"> <parameter name="k">
@ -1165,12 +1277,41 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
</parameter> </parameter>
<type>std::pair&lt;const_iterator, const_iterator&gt;</type> <type>std::pair&lt;const_iterator, const_iterator&gt;</type>
</signature> </signature>
<signature>
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K const&amp;</paramtype>
</parameter>
<type>std::pair&lt;iterator, iterator&gt;</type>
</signature>
<signature cv="const">
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K const&amp;</paramtype>
</parameter>
<type>std::pair&lt;const_iterator, const_iterator&gt;</type>
</signature>
<returns> <returns>
<para>A range containing all elements with key equivalent to <code>k</code>. <para>A range containing all elements with key equivalent to <code>k</code>.
If the container doesn't container any such elements, returns If the container doesn't contain any such elements, returns
<code><functionname>std::make_pair</functionname>(<methodname>b.end</methodname>(),<methodname>b.end</methodname>())</code>. <code><functionname>std::make_pair</functionname>(<methodname>b.end</methodname>(),<methodname>b.end</methodname>())</code>.
</para> </para>
</returns> </returns>
<notes>
<para>
The <code>template &lt;typename K&gt;</code> overloads only participate
in overload resolution if <code>Hash::is_transparent</code> and
<code>Pred::is_transparent</code> are valid member typedefs. The
library assumes that <code>Hash</code> is callable with both
<code>K</code> and <code>Key</code> and that <code>Pred</code> is
transparent. This enables heterogeneous lookup which avoids the cost of
instantiating an instance of the <code>Key</code> type.
</para>
</notes>
</overloaded-method> </overloaded-method>
</method-group> </method-group>
<method-group name="bucket interface"> <method-group name="bucket interface">
@ -2254,6 +2395,38 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
</para> </para>
</notes> </notes>
</method> </method>
<method name="extract">
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K&amp;&amp;</paramtype>
</parameter>
<type>node_type</type>
<description>
<para>Removes an element with key equivalent to <code>k</code>.</para>
<para>
This overload only participates in overload resolution if <code>Hash::is_transparent</code>
and <code>Pred::is_transparent</code> are valid member typedefs and neither <code>iterator</code>
nor <code>const_iterator</code> are implicitly convertible from <code>K</code>. The library
assumes that <code>Hash</code> is callable with both <code>K</code> and <code>Key</code> and
that <code>Pred</code> is transparent. This enables heterogeneous lookup which avoids the cost of
instantiating an instance of the <code>Key</code> type.
</para>
</description>
<returns>
<para>A <code>node_type</code> owning the element if found, otherwise an empty <code>node_type</code>.</para>
</returns>
<throws>
<para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
</throws>
<notes>
<para>
In C++17 a node extracted using this method can be inserted into a compatible <code>unordered_set</code>,
but that is not supported yet.
</para>
</notes>
</method>
<method name="insert"> <method name="insert">
<parameter name="nh"> <parameter name="nh">
<paramtype>node_type&amp;&amp;</paramtype> <paramtype>node_type&amp;&amp;</paramtype>
@ -2349,6 +2522,32 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
<para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para> <para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
</throws> </throws>
</method> </method>
<method name="erase">
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K&amp;&amp;</paramtype>
</parameter>
<type>size_type</type>
<returns>
<para>The number of elements erased.</para>
</returns>
<throws>
<para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
</throws>
<description>
<para>Erase all elements with key equivalent to <code>k</code>.</para>
<para>
This overload only participates in overload resolution if <code>Hash::is_transparent</code>
and <code>Pred::is_transparent</code> are valid member typedefs and neither <code>iterator</code>
nor <code>const_iterator</code> are implicitly convertible from <code>K</code>. The library
assumes that <code>Hash</code> is callable with both <code>K</code> and <code>Key</code> and
that <code>Pred</code> is transparent. This enables heterogeneous lookup which avoids the cost of
instantiating an instance of the <code>Key</code> type.
</para>
</description>
</method>
<method name="erase"> <method name="erase">
<parameter name="first"> <parameter name="first">
<paramtype>const_iterator</paramtype> <paramtype>const_iterator</paramtype>
@ -2497,6 +2696,24 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
</parameter> </parameter>
<type>const_iterator</type> <type>const_iterator</type>
</signature> </signature>
<signature>
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K const&amp;</paramtype>
</parameter>
<type>iterator</type>
</signature>
<signature cv="const">
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K const&amp;</paramtype>
</parameter>
<type>const_iterator</type>
</signature>
<signature> <signature>
<template> <template>
<template-type-parameter name="CompatibleKey"/> <template-type-parameter name="CompatibleKey"/>
@ -2534,22 +2751,58 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
<returns> <returns>
<para>An iterator pointing to an element with key equivalent to <code>k</code>, or <code>b.end()</code> if no such element exists.</para> <para>An iterator pointing to an element with key equivalent to <code>k</code>, or <code>b.end()</code> if no such element exists.</para>
</returns> </returns>
<notes><para> <notes>
The templated overloads are a non-standard extensions which <para>
allows you to use a compatible hash function and equality The templated overloads containing <code>CompatibleKey</code>,
predicate for a key of a different type in order to avoid <code>CompatibleHash</code> and <code>CompatiblePredicate</code>
an expensive type cast. In general, its use is not encouraged. are non-standard extensions which allow you to use a compatible
</para></notes> hash function and equality predicate for a key of a different type
</overloaded-method> in order to avoid an expensive type cast. In general, its use is
<method name="count" cv="const"> not encouraged and instead the <code>K</code> member function
<parameter name="k"> templates should be used.
<paramtype>key_type const&amp;</paramtype> </para>
</parameter> <para>
<type>size_type</type> The <code>template &lt;typename K&gt;</code> overloads only participate
in overload resolution if <code>Hash::is_transparent</code> and
<code>Pred::is_transparent</code> are valid member typedefs. The
library assumes that <code>Hash</code> is callable with both
<code>K</code> and <code>Key</code> and that <code>Pred</code> is
transparent. This enables heterogeneous lookup which avoids the cost of
instantiating an instance of the <code>Key</code> type.
</para>
</notes>
</overloaded-method>
<overloaded-method name="count">
<signature cv="const">
<parameter name="k">
<paramtype>key_type const&amp;</paramtype>
</parameter>
<type>size_type</type>
</signature>
<signature cv="const">
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K const&amp;</paramtype>
</parameter>
<type>size_type</type>
</signature>
<returns> <returns>
<para>The number of elements with key equivalent to <code>k</code>.</para> <para>The number of elements with key equivalent to <code>k</code>.</para>
</returns> </returns>
</method> <notes>
<para>
The <code>template &lt;typename K&gt;</code> overload only participates
in overload resolution if <code>Hash::is_transparent</code> and
<code>Pred::is_transparent</code> are valid member typedefs. The
library assumes that <code>Hash</code> is callable with both
<code>K</code> and <code>Key</code> and that <code>Pred</code> is
transparent. This enables heterogeneous lookup which avoids the cost of
instantiating an instance of the <code>Key</code> type.
</para>
</notes>
</overloaded-method>
<overloaded-method name="equal_range"> <overloaded-method name="equal_range">
<signature> <signature>
<parameter name="k"> <parameter name="k">
@ -2563,12 +2816,41 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
</parameter> </parameter>
<type>std::pair&lt;const_iterator, const_iterator&gt;</type> <type>std::pair&lt;const_iterator, const_iterator&gt;</type>
</signature> </signature>
<signature>
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K const&amp;</paramtype>
</parameter>
<type>std::pair&lt;iterator, iterator&gt;</type>
</signature>
<signature cv="const">
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K const&amp;</paramtype>
</parameter>
<type>std::pair&lt;const_iterator, const_iterator&gt;</type>
</signature>
<returns> <returns>
<para>A range containing all elements with key equivalent to <code>k</code>. <para>A range containing all elements with key equivalent to <code>k</code>.
If the container doesn't container any such elements, returns If the container doesn't contain any such elements, returns
<code><functionname>std::make_pair</functionname>(<methodname>b.end</methodname>(),<methodname>b.end</methodname>())</code>. <code><functionname>std::make_pair</functionname>(<methodname>b.end</methodname>(),<methodname>b.end</methodname>())</code>.
</para> </para>
</returns> </returns>
<notes>
<para>
The <code>template &lt;typename K&gt;</code> overloads only participate
in overload resolution if <code>Hash::is_transparent</code> and
<code>Pred::is_transparent</code> are valid member typedefs. The
library assumes that <code>Hash</code> is callable with both
<code>K</code> and <code>Key</code> and that <code>Pred</code> is
transparent. This enables heterogeneous lookup which avoids the cost of
instantiating an instance of the <code>Key</code> type.
</para>
</notes>
</overloaded-method> </overloaded-method>
</method-group> </method-group>
<method-group name="bucket interface"> <method-group name="bucket interface">
@ -3757,6 +4039,38 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
</para> </para>
</notes> </notes>
</method> </method>
<method name="extract">
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K&amp;&amp;</paramtype>
</parameter>
<type>node_type</type>
<description>
<para>Removes an element with key equivalent to <code>k</code>.</para>
<para>
This overload only participates in overload resolution if <code>Hash::is_transparent</code>
and <code>Pred::is_transparent</code> are valid member typedefs and neither <code>iterator</code>
nor <code>const_iterator</code> are implicitly convertible from <code>K</code>. The library
assumes that <code>Hash</code> is callable with both <code>K</code> and <code>Key</code> and
that <code>Pred</code> is transparent. This enables heterogeneous lookup which avoids the cost of
instantiating an instance of the <code>Key</code> type.
</para>
</description>
<returns>
<para>A <code>node_type</code> owning the element if found, otherwise an empty <code>node_type</code>.</para>
</returns>
<throws>
<para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
</throws>
<notes>
<para>
In C++17 a node extracted using this method can be inserted into a compatible <code>unordered_multimap</code>,
but that is not supported yet.
</para>
</notes>
</method>
<method name="insert"> <method name="insert">
<parameter name="nh"> <parameter name="nh">
<paramtype>node_type&amp;&amp;</paramtype> <paramtype>node_type&amp;&amp;</paramtype>
@ -3868,6 +4182,32 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
<para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para> <para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
</throws> </throws>
</method> </method>
<method name="erase">
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K&amp;&amp;</paramtype>
</parameter>
<type>size_type</type>
<returns>
<para>The number of elements erased.</para>
</returns>
<throws>
<para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
</throws>
<description>
<para>Erase all elements with key equivalent to <code>k</code>.</para>
<para>
This overload only participates in overload resolution if <code>Hash::is_transparent</code>
and <code>Pred::is_transparent</code> are valid member typedefs and neither <code>iterator</code>
nor <code>const_iterator</code> are implicitly convertible from <code>K</code>. The library
assumes that <code>Hash</code> is callable with both <code>K</code> and <code>Key</code> and
that <code>Pred</code> is transparent. This enables heterogeneous lookup which avoids the cost of
instantiating an instance of the <code>Key</code> type.
</para>
</description>
</method>
<method name="erase"> <method name="erase">
<parameter name="first"> <parameter name="first">
<paramtype>const_iterator</paramtype> <paramtype>const_iterator</paramtype>
@ -4016,6 +4356,24 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
</parameter> </parameter>
<type>const_iterator</type> <type>const_iterator</type>
</signature> </signature>
<signature>
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K const&amp;</paramtype>
</parameter>
<type>iterator</type>
</signature>
<signature cv="const">
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K const&amp;</paramtype>
</parameter>
<type>const_iterator</type>
</signature>
<signature> <signature>
<template> <template>
<template-type-parameter name="CompatibleKey"/> <template-type-parameter name="CompatibleKey"/>
@ -4053,22 +4411,58 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
<returns> <returns>
<para>An iterator pointing to an element with key equivalent to <code>k</code>, or <code>b.end()</code> if no such element exists.</para> <para>An iterator pointing to an element with key equivalent to <code>k</code>, or <code>b.end()</code> if no such element exists.</para>
</returns> </returns>
<notes><para> <notes>
The templated overloads are a non-standard extensions which <para>
allows you to use a compatible hash function and equality The templated overloads containing <code>CompatibleKey</code>,
predicate for a key of a different type in order to avoid <code>CompatibleHash</code> and <code>CompatiblePredicate</code>
an expensive type cast. In general, its use is not encouraged. are non-standard extensions which allow you to use a compatible
</para></notes> hash function and equality predicate for a key of a different type
</overloaded-method> in order to avoid an expensive type cast. In general, its use is
<method name="count" cv="const"> not encouraged and instead the <code>K</code> member function
<parameter name="k"> templates should be used.
<paramtype>key_type const&amp;</paramtype> </para>
</parameter> <para>
<type>size_type</type> The <code>template &lt;typename K&gt;</code> overloads only participate
in overload resolution if <code>Hash::is_transparent</code> and
<code>Pred::is_transparent</code> are valid member typedefs. The
library assumes that <code>Hash</code> is callable with both
<code>K</code> and <code>Key</code> and that <code>Pred</code> is
transparent. This enables heterogeneous lookup which avoids the cost of
instantiating an instance of the <code>Key</code> type.
</para>
</notes>
</overloaded-method>
<overloaded-method name="count">
<signature cv="const">
<parameter name="k">
<paramtype>key_type const&amp;</paramtype>
</parameter>
<type>size_type</type>
</signature>
<signature cv="const">
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K const&amp;</paramtype>
</parameter>
<type>size_type</type>
</signature>
<returns> <returns>
<para>The number of elements with key equivalent to <code>k</code>.</para> <para>The number of elements with key equivalent to <code>k</code>.</para>
</returns> </returns>
</method> <notes>
<para>
The <code>template &lt;typename K&gt;</code> overload only participates
in overload resolution if <code>Hash::is_transparent</code> and
<code>Pred::is_transparent</code> are valid member typedefs. The
library assumes that <code>Hash</code> is callable with both
<code>K</code> and <code>Key</code> and that <code>Pred</code> is
transparent. This enables heterogeneous lookup which avoids the cost of
instantiating an instance of the <code>Key</code> type.
</para>
</notes>
</overloaded-method>
<overloaded-method name="equal_range"> <overloaded-method name="equal_range">
<signature> <signature>
<parameter name="k"> <parameter name="k">
@ -4082,12 +4476,41 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
</parameter> </parameter>
<type>std::pair&lt;const_iterator, const_iterator&gt;</type> <type>std::pair&lt;const_iterator, const_iterator&gt;</type>
</signature> </signature>
<signature>
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K const&amp;</paramtype>
</parameter>
<type>std::pair&lt;iterator, iterator&gt;</type>
</signature>
<signature cv="const">
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K const&amp;</paramtype>
</parameter>
<type>std::pair&lt;const_iterator, const_iterator&gt;</type>
</signature>
<returns> <returns>
<para>A range containing all elements with key equivalent to <code>k</code>. <para>A range containing all elements with key equivalent to <code>k</code>.
If the container doesn't container any such elements, returns If the container doesn't contain any such elements, returns
<code><functionname>std::make_pair</functionname>(<methodname>b.end</methodname>(),<methodname>b.end</methodname>())</code>. <code><functionname>std::make_pair</functionname>(<methodname>b.end</methodname>(),<methodname>b.end</methodname>())</code>.
</para> </para>
</returns> </returns>
<notes>
<para>
The <code>template &lt;typename K&gt;</code> overloads only participate
in overload resolution if <code>Hash::is_transparent</code> and
<code>Pred::is_transparent</code> are valid member typedefs. The
library assumes that <code>Hash</code> is callable with both
<code>K</code> and <code>Key</code> and that <code>Pred</code> is
transparent. This enables heterogeneous lookup which avoids the cost of
instantiating an instance of the <code>Key</code> type.
</para>
</notes>
</overloaded-method> </overloaded-method>
<method name="operator[]"> <method name="operator[]">
<parameter name="k"> <parameter name="k">
@ -5218,6 +5641,38 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
</para> </para>
</notes> </notes>
</method> </method>
<method name="extract">
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K&amp;&amp;</paramtype>
</parameter>
<type>node_type</type>
<description>
<para>Removes an element with key equivalent to <code>k</code>.</para>
<para>
This overload only participates in overload resolution if <code>Hash::is_transparent</code>
and <code>Pred::is_transparent</code> are valid member typedefs and neither <code>iterator</code>
nor <code>const_iterator</code> are implicitly convertible from <code>K</code>. The library
assumes that <code>Hash</code> is callable with both <code>K</code> and <code>Key</code> and
that <code>Pred</code> is transparent. This enables heterogeneous lookup which avoids the cost of
instantiating an instance of the <code>Key</code> type.
</para>
</description>
<returns>
<para>A <code>node_type</code> owning the element if found, otherwise an empty <code>node_type</code>.</para>
</returns>
<throws>
<para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
</throws>
<notes>
<para>
In C++17 a node extracted using this method can be inserted into a compatible <code>unordered_map</code>,
but that is not supported yet.
</para>
</notes>
</method>
<method name="insert"> <method name="insert">
<parameter name="nh"> <parameter name="nh">
<paramtype>node_type&amp;&amp;</paramtype> <paramtype>node_type&amp;&amp;</paramtype>
@ -5313,6 +5768,32 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
<para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para> <para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
</throws> </throws>
</method> </method>
<method name="erase">
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K&amp;&amp;</paramtype>
</parameter>
<type>size_type</type>
<returns>
<para>The number of elements erased.</para>
</returns>
<throws>
<para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
</throws>
<description>
<para>Erase all elements with key equivalent to <code>k</code>.</para>
<para>
This overload only participates in overload resolution if <code>Hash::is_transparent</code>
and <code>Pred::is_transparent</code> are valid member typedefs and neither <code>iterator</code>
nor <code>const_iterator</code> are implicitly convertible from <code>K</code>. The library
assumes that <code>Hash</code> is callable with both <code>K</code> and <code>Key</code> and
that <code>Pred</code> is transparent. This enables heterogeneous lookup which avoids the cost of
instantiating an instance of the <code>Key</code> type.
</para>
</description>
</method>
<method name="erase"> <method name="erase">
<parameter name="first"> <parameter name="first">
<paramtype>const_iterator</paramtype> <paramtype>const_iterator</paramtype>
@ -5461,6 +5942,24 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
</parameter> </parameter>
<type>const_iterator</type> <type>const_iterator</type>
</signature> </signature>
<signature>
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K const&amp;</paramtype>
</parameter>
<type>iterator</type>
</signature>
<signature cv="const">
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K const&amp;</paramtype>
</parameter>
<type>const_iterator</type>
</signature>
<signature> <signature>
<template> <template>
<template-type-parameter name="CompatibleKey"/> <template-type-parameter name="CompatibleKey"/>
@ -5498,22 +5997,58 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
<returns> <returns>
<para>An iterator pointing to an element with key equivalent to <code>k</code>, or <code>b.end()</code> if no such element exists.</para> <para>An iterator pointing to an element with key equivalent to <code>k</code>, or <code>b.end()</code> if no such element exists.</para>
</returns> </returns>
<notes><para> <notes>
The templated overloads are a non-standard extensions which <para>
allows you to use a compatible hash function and equality The templated overloads containing <code>CompatibleKey</code>,
predicate for a key of a different type in order to avoid <code>CompatibleHash</code> and <code>CompatiblePredicate</code>
an expensive type cast. In general, its use is not encouraged. are non-standard extensions which allow you to use a compatible
</para></notes> hash function and equality predicate for a key of a different type
</overloaded-method> in order to avoid an expensive type cast. In general, its use is
<method name="count" cv="const"> not encouraged and instead the <code>K</code> member function
<parameter name="k"> templates should be used.
<paramtype>key_type const&amp;</paramtype> </para>
</parameter> <para>
<type>size_type</type> The <code>template &lt;typename K&gt;</code> overloads only participate
in overload resolution if <code>Hash::is_transparent</code> and
<code>Pred::is_transparent</code> are valid member typedefs. The
library assumes that <code>Hash</code> is callable with both
<code>K</code> and <code>Key</code> and that <code>Pred</code> is
transparent. This enables heterogeneous lookup which avoids the cost of
instantiating an instance of the <code>Key</code> type.
</para>
</notes>
</overloaded-method>
<overloaded-method name="count">
<signature cv="const">
<parameter name="k">
<paramtype>key_type const&amp;</paramtype>
</parameter>
<type>size_type</type>
</signature>
<signature cv="const">
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K const&amp;</paramtype>
</parameter>
<type>size_type</type>
</signature>
<returns> <returns>
<para>The number of elements with key equivalent to <code>k</code>.</para> <para>The number of elements with key equivalent to <code>k</code>.</para>
</returns> </returns>
</method> <notes>
<para>
The <code>template &lt;typename K&gt;</code> overload only participates
in overload resolution if <code>Hash::is_transparent</code> and
<code>Pred::is_transparent</code> are valid member typedefs. The
library assumes that <code>Hash</code> is callable with both
<code>K</code> and <code>Key</code> and that <code>Pred</code> is
transparent. This enables heterogeneous lookup which avoids the cost of
instantiating an instance of the <code>Key</code> type.
</para>
</notes>
</overloaded-method>
<overloaded-method name="equal_range"> <overloaded-method name="equal_range">
<signature> <signature>
<parameter name="k"> <parameter name="k">
@ -5527,12 +6062,41 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
</parameter> </parameter>
<type>std::pair&lt;const_iterator, const_iterator&gt;</type> <type>std::pair&lt;const_iterator, const_iterator&gt;</type>
</signature> </signature>
<signature>
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K const&amp;</paramtype>
</parameter>
<type>std::pair&lt;iterator, iterator&gt;</type>
</signature>
<signature cv="const">
<template>
<template-type-parameter name="K" />
</template>
<parameter name="k">
<paramtype>K const&amp;</paramtype>
</parameter>
<type>std::pair&lt;const_iterator, const_iterator&gt;</type>
</signature>
<returns> <returns>
<para>A range containing all elements with key equivalent to <code>k</code>. <para>A range containing all elements with key equivalent to <code>k</code>.
If the container doesn't container any such elements, returns If the container doesn't contain any such elements, returns
<code><functionname>std::make_pair</functionname>(<methodname>b.end</methodname>(),<methodname>b.end</methodname>())</code>. <code><functionname>std::make_pair</functionname>(<methodname>b.end</methodname>(),<methodname>b.end</methodname>())</code>.
</para> </para>
</returns> </returns>
<notes>
<para>
The <code>template &lt;typename K&gt;</code> overloads only participate
in overload resolution if <code>Hash::is_transparent</code> and
<code>Pred::is_transparent</code> are valid member typedefs. The
library assumes that <code>Hash</code> is callable with both
<code>K</code> and <code>Key</code> and that <code>Pred</code> is
transparent. This enables heterogeneous lookup which avoids the cost of
instantiating an instance of the <code>Key</code> type.
</para>
</notes>
</overloaded-method> </overloaded-method>
</method-group> </method-group>
<method-group name="bucket interface"> <method-group name="bucket interface">