Initial review version, for the review conducted from 7th December 2007 to
16th December 2007.
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
conversion when calculating sizes from the max load factor, and use
double in the calculation for greater accuracy.
Fix some errors in the examples.
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
Added equality operators.
Rename overload of
with hint, to
as specified in n2691.
Provide forwarding headers at
Move all the implementation inside
to assist modularization and hopefully make it easier to track changes
Document that the equality and inequality operators are undefined for two
objects if their equality predicates aren't equivalent. Thanks to Daniel
Use a larger prime number list. Thanks to Thorsten Ottosen and Hervé Brönnimann.
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
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).
Avoid a warning on Visual C++ 2009.
Some other minor internal changes to the implementation, tests and documentation.
Avoid an unnecessary copy in
Fix length of prime number list.
Store the prime list as a preprocessor sequence - so that it will always
get the length right if it changes again in the future.
emplace for all
Some workarounds for old versions of borland, including adding explicit
destructors to all containers.
Disable incorrect Visual C++ warnings.
Better configuration for C++0x features when the headers aren't available.
Create less buckets by default.
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
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.
Support instantiating the containers with incomplete value types.
Reduced the number of warnings (mostly in tests).
Improved codegear compatibility.
a temporary workaround for the current
which can be inefficient because it has to find the next element to return
Add templated find overload for compatible keys.
Some code formatting changes to fit almost all lines into 80 characters.
erase_return_void is now
quick_erase, which is the
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.
Stop using deprecated
Fix a bug when inserting into an
iterators which returns
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 compliance
section for details.
The container now meets C++11's complexity requirements, but to do so uses
a little more memory. This means that
erase_return_void are no
longer required, they'll be removed in a future version.
C++11 support has resulted in some breaking changes:
Equality comparison has been changed to the C++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
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
destroy functions are called
with raw pointers, rather than the allocator's
emplace used to emulate
the variadic pair constructors that appeared in early C++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
To use the old emulation of the variadic consturctors define
Fix warning due to accidental odd assignment.
Slightly better error messages.
Fix equality for
Fix some Sun specific code.
Make namespaces in macros compatible with
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
On old versions of Visual C++, use the container library's implementation
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.
Fix construction/destruction issue when using a C++11 compiler with a C++03
try..catch to support compiling without exceptions.
Adjust SFINAE use to try to supprt g++ 3.4 (#7175).
Updated to use the new config macros.
Faster assign, which assigns to existing nodes where possible, rather than
creating entirely new nodes and copy constructing.
Fixed bug in
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.