From 1f0ba0198b25d1580c4fa877e051c94f80f2e636 Mon Sep 17 00:00:00 2001 From: Christian Mazakas Date: Mon, 17 Jan 2022 14:47:19 -0800 Subject: [PATCH] Convert Change Log to AsciiDoc --- doc/unordered/changes.adoc | 369 +++++++++++++++++++++++++++++++++++++ 1 file changed, 369 insertions(+) diff --git a/doc/unordered/changes.adoc b/doc/unordered/changes.adoc index 154e3010..2a4cab68 100644 --- a/doc/unordered/changes.adoc +++ b/doc/unordered/changes.adoc @@ -1,2 +1,371 @@ [#changes] = Change Log + +:idprefix: changes_ +:svn-ticket-url: https://svn.boost.org/trac/boost/ticket +:github-pr-url: https://github.com/boostorg/unordered/pull +:cpp: C++ + +== Changes in Boost 1.79.0 + +* Improved {cpp}20 support: + ** All containers have been updated to support + heterogeneous `count`, `equal_range` and `find`. + ** All containers now implement the member function `contains` +* Improved {cpp}23 support: + ** All containers have been updated to support + heterogeneous `erase` and `extract`. +* Changed behavior of `reserve` to eagerly + allocate ({github-pr-url}/59[PR#59^]). +* Various warning fixes in the test suite. +* Update code to internally use `boost::allocator_traits`. + +== Changes in Boost 1.67.0 + +* Improved {cpp}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 {cpp}20 support: + ** Use `boost::to_address`, which has the proposed {cpp}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 {cpp}, + 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 {cpp}17, thanks to Daniela Engert + ({github-pr-url}/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. + +== Changes in Boost 1.66.0 + +* Simpler move construction implementation. +* Documentation fixes ({github-pr-url}/6[GitHub #6^]). + +== Changes in Boost 1.65.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. + +== Changes in Boost 1.64.0 + +* Initial support for new {cpp}17 member functions: + `insert_or_assign` and `try_emplace` in `unordered_map`, +* Initial support for `merge` and `extract`. + Does not include transferring nodes between + `unordered_map` and `unordered_multimap` or between `unordered_set` and + `unordered_multiset` yet. That will hopefully be in the next version of + Boost. + +== Changes in Boost 1.63.0 + +* 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 {cpp}. +* 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 ({svn-ticket-url}/12459[#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 {cpp}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. + +== Changes in Boost 1.62.0 + +* Remove use of deprecated `boost::iterator`. +* 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. + +== Changes in Boost 1.58.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 ({svn-ticket-url}/10777[#10777^]). +* Fix rare exception safety issue in move assignment. +* Fix potential overflow when calculating number of buckets to allocate + ({github-pr-url}/4[GitHub #4^]). + +== Changes in Boost 1.57.0 + +* Fix the `pointer` typedef in iterators ({svn-ticket-url}/10672[#10672^]). +* Fix Coverity warning + ({github-pr-url}/2[GitHub #2^]). + +== Changes in Boost 1.56.0 + +* Fix some shadowed variable warnings ({svn-ticket-url}/9377[#9377^]). +* Fix allocator use in documentation ({svn-ticket-url}/9719[#9719^]). +* Always use prime number of buckets for integers. Fixes performance + regression when inserting consecutive integers, although makes other + uses slower ({svn-ticket-url}/9282[#9282^]). +* Only construct elements using allocators, as specified in {cpp}11 standard. + +== Changes in Boost 1.55.0 + +* Avoid some warnings ({svn-ticket-url}/8851[#8851^], {svn-ticket-url}/8874[#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. + +== Changes in Boost 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. + +== Changes in Boost 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`. + +== Changes in Boost 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` ({svn-ticket-url}/7471[#7471^]). +* Reverted some of the internal changes to how nodes are created, especially + for {cpp}11 compilers. 'construct' and 'destroy' should work a little better + for {cpp}11 allocators. +* Simplified the implementation a bit. Hopefully more robust. + +== Changes in Boost 1.51.0 + +* Fix construction/destruction issue when using a {cpp}11 compiler with a + {cpp}03 allocator ({svn-ticket-url}/7100[#7100^]). +* Remove a `try..catch` to support compiling without exceptions. +* Adjust SFINAE use to try to support g++ 3.4 ({svn-ticket-url}/7175[#7175^]). +* Updated to use the new config macros. + +== Changes in Boost 1.50.0 + +* Fix equality for `unordered_multiset` and `unordered_multimap`. +* {svn-ticket-url}/6857[Ticket 6857^]: + Implement `reserve`. +* {svn-ticket-url}/6771[Ticket 6771^]: + Avoid gcc's `-Wfloat-equal` warning. +* {svn-ticket-url}/6784[Ticket 6784^]: + Fix some Sun specific code. +* {svn-ticket-url}/6190[Ticket 6190^]: + Avoid gcc's `-Wshadow` warning. +* {svn-ticket-url}/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 {cpp}, 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. + +== Changes in Boost 1.49.0 + +* Fix warning due to accidental odd assignment. +* Slightly better error messages. + +== Changes in Boost 1.48.0 - Major update + +This is major change which has been converted to use Boost.Move's move +emulation, and be more compliant with the {cpp}11 standard. See the +xref:unordered.adoc#compliance[compliance section] for details. + +The container now meets {cpp}11's complexity requirements, but to do so +uses a little more memory. This means that `quick_erase` and +`erase_return_void` are no longer required, they'll be removed in a +future version. + +{cpp}11 support has resulted in some breaking changes: + +* Equality comparison has been changed to the {cpp}11 specification. + In a container with equivalent keys, elements in a group with equal + keys used to have to be in the same order to be considered equal, + now they can be a permutation of each other. To use the old + behavior define the macro `BOOST_UNORDERED_DEPRECATED_EQUALITY`. + +* The behaviour of swap is different when the two containers to be + swapped has unequal allocators. It used to allocate new nodes using + the appropriate allocators, it now swaps the allocators if + the allocator has a member structure `propagate_on_container_swap`, + such that `propagate_on_container_swap::value` is true. + +* Allocator's `construct` and `destroy` functions are called with raw + pointers, rather than the allocator's `pointer` type. + +* `emplace` used to emulate the variadic pair constructors that + appeared in early {cpp}0x drafts. Since they were removed it no + longer does so. It does emulate the new `piecewise_construct` + pair constructors - only you need to use + `boost::piecewise_construct`. To use the old emulation of + the variadic constructors define + `BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT`. + +== Changes in Boost 1.45.0 + +* Fix a bug when inserting into an `unordered_map` or `unordered_set` using + iterators which returns `value_type` by copy. + +== Changes in Boost 1.43.0 + +* {svn-ticket-url}/3966[Ticket 3966^]: + `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. + +== Changes in Boost 1.42.0 + +* Support instantiating the containers with incomplete value types. +* Reduced the number of warnings (mostly in tests). +* Improved codegear compatibility. +* {svn-ticket-url}/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. +* {svn-ticket-url}/3773[Ticket 3773^]: + Add missing `std` qualifier to `ptrdiff_t`. +* Some code formatting changes to fit almost all lines into 80 characters. + +== Changes in Boost 1.41.0 - Major update + +* The original version made heavy use of macros to sidestep some of the older + 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` + 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 + will not allocate any memory. + +== Changes in Boost 1.40.0 + +* {svn-ticket-url}/2975[Ticket 2975^]: + Store the prime list as a preprocessor sequence - so that it will always get + the length right if it changes again in the future. +* {svn-ticket-url}/1978[Ticket 1978^]: + Implement `emplace` for all compilers. +* {svn-ticket-url}/2908[Ticket 2908^], + {svn-ticket-url}/3096[Ticket 3096^]: + Some workarounds for old versions of borland, including adding explicit + destructors to all containers. +* {svn-ticket-url}/3082[Ticket 3082^]: + Disable incorrect Visual {cpp} warnings. +* Better configuration for {cpp}0x features when the headers aren't available. +* Create less buckets by default. + +== Changes in Boost 1.39.0 + +* {svn-ticket-url}/2756[Ticket 2756^]: Avoid a warning + on Visual {cpp} 2009. +* Some other minor internal changes to the implementation, tests and + documentation. +* Avoid an unnecessary copy in `operator[]`. +* {svn-ticket-url}/2975[Ticket 2975^]: Fix length of + prime number list. + +== Changes in Boost 1.38.0 + +* Use link:../../../core/swap.html[`boost::swap`^]. +* {svn-ticket-url}/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. +* {svn-ticket-url}/1710[Ticket 1710^]: + Use a larger prime number list. Thanks to Thorsten Ottosen and Hervé + Brönnimann. +* Use + link:../../../type_traits/index.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 {cpp}0x initializer lists where they're available (currently + only g++ 4.4 in {cpp}0x mode). + +== Changes in Boost 1.37.0 + +* Rename overload of `emplace` with hint, to `emplace_hint` as specified in + http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2008/n2691.pdf[n2691^]. +* Provide forwarding headers at `` and + ``. +* Move all the implementation inside `boost/unordered`, to assist + modularization and hopefully make it easier to track Changes in Boost subversion. + +== Changes in Boost 1.36.0 + +First official release. + +* Rearrange the internals. +* Move semantics - full support when rvalue references are available, emulated + 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. + +== Boost 1.35.0 Add-on - 31st March 2008 + +Unofficial release uploaded to vault, to be used with Boost 1.35.0. Incorporated +many of the suggestions from the review. + +* Improved portability thanks to Boost regression testing. +* Fix lots of typos, and clearer text in the documentation. +* Fix floating point to `std::size_t` conversion when calculating sizes from + the max load factor, and use `double` in the calculation for greater accuracy. +* Fix some errors in the examples. + +== Review Version + +Initial review version, for the review conducted from 7th December 2007 to +16th December 2007. + +