
[/ Copyright 2008 Daniel James.
 / Distributed under the Boost Software License, Version 1.0. (See accompanying
 / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) ]

[section:changes Change Log]

[h2 Review Version]

Initial review version, for the review conducted from 7th December 2007 to
16th December 2007.

[h2 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.

[h2 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.

[h2 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 `<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]

* Use [@boost:/libs/utility/swap.html `boost::swap`].
* [@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]

* [@https://svn.boost.org/trac/boost/ticket/2756 Ticket 2756]: Avoid a warning
  on Visual C++ 2009.
* Some other minor internal changes to the implementation, tests and
  documentation.
* Avoid an unnecessary copy in `operator[]`.
* [@https://svn.boost.org/trac/boost/ticket/2975 Ticket 2975]: Fix length of
  prime number list.

[h2 Boost 1.40.0]

* [@https://svn.boost.org/trac/boost/ticket/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.
* [@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]

* 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 objcet 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.
  
[h2 Boost 1.42.0]

* Support instantiating the containers with incomplete value types.
* 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]

* [@http://svn.boost.org/trac/boost/ticket/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.

[h2 Boost 1.45.0]

* Fix a bug when inserting into an `unordered_map` or `unordered_set` using
  iterators which returns `value_type` by copy.

[endsect]
