Release 1.49.0

[SVN r77094]

doc/Jamfile.v2

@@ -3,16 +3,14 @@
 # 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)
 
+using boostbook ;
+using quickbook ;
+
 path-constant images_location : ../ ;
 path-constant admonishment_location : ../../../../doc/src/images ;
 
 xml unordered : unordered.qbk ;
 boostbook standalone : unordered :
-    <xsl:param>admon.graphics.path=images/
-    <xsl:param>navig.graphics.path=images/
-    <xsl:param>html.stylesheet=boostbook.css
-    <xsl:param>boost.root=../../../..
-    <xsl:param>boost.libraries=../../../libraries.htm
     <xsl:param>chunk.first.sections=1
     <xsl:param>chunk.section.depth=2
     <xsl:param>generate.section.toc.level=2
@@ -23,10 +21,15 @@ boostbook standalone : unordered :
     <xsl:param>boost.compact.function=0
     <xsl:param>boost.compact.enum=0
 
-    <dependency>css
-    <dependency>images
+    # HTML Options:
+
+    <format>html:<xsl:param>boost.root=../../../..
+    <format>html:<xsl:param>img.src.path=../../../../doc/html/
+    <format>xhtml:<xsl:param>boost.root=../../../..
+    <format>xhtml:<xsl:param>img.src.path=../../../../doc/html/
 
     # PDF Options:
+
     # TOC Generation: this is needed for FOP-0.9 and later:
     <xsl:param>fop1.extensions=0
     <format>pdf:<xsl:param>xep.extensions=1
@@ -51,11 +54,6 @@ boostbook standalone : unordered :
     <format>pdf:<xsl:param>img.src.path=$(images_location)/
     #<format>pdf:<xsl:param>admon.graphics.path=$(admonishment_location)
     <format>pdf:<xsl:param>draft.mode="no"
+    <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/unordered/doc/html
     ;
 
-install css : [ glob $(BOOST_ROOT)/doc/src/*.css ]
-    : <location>html ;
-install images : [ glob $(BOOST_ROOT)/doc/src/images/*.png ]
-    : <location>html/images ;
-explicit css ;
-explicit images ;

doc/bibliography.xml

@@ -1,5 +1,5 @@
 <!--
-Copyright Daniel James 2008
+Copyright Daniel James 2008-2009
 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)
 -->

doc/buckets.qbk

@@ -112,9 +112,18 @@ load factor is /required/ to be less than the maximum is following a call to
 below the max load factor, and set the maximum load factor to be the same as
 or close to the hint - unless your hint is unreasonably small or large.
 
-[table Methods for Controlling Bucket Size
+[table:bucket_size Methods for Controlling Bucket Size
     [[Method] [Description]]
 
+    [
+        [`X(size_type n)`]
+        [Construct an empty container with at least `n` buckets (`X` is the container type).]
+    ]
+    [
+        [`X(InputIterator i, InputIterator j, size_type n)`]
+        [Construct an empty container with at least `n` buckets and insert elements
+         from the range \[`i`, `j`) (`X` is the container type).]
+    ]
     [
         [`float load_factor() const`]
         [The average number of elements per bucket.]

doc/changes.qbk

@@ -33,4 +33,146 @@ First official release.
   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.
+
+[h2 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 C++11 standard. See the
+[link unordered.compliance 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 `quick_erase` and
+`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 `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 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
+  `boost::piecewise_construct`. To use the old emulation of
+  the variadic consturctors define
+  `BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT`.
+
+[h2 Boost 1.49.0]
+
+* Fix warning due to accidental odd assignment.
+* Slightly better error messages.
+
 [endsect]

doc/comparison.qbk

@@ -1,10 +1,10 @@
-[/ Copyright 2006-2008 Daniel James.
+[/ Copyright 2006-2011 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:comparison Comparison with Associative Containers]
 
-[table Interface differences.
+[table:interface_differences Interface differences.
     [[Associative Containers] [Unordered Associative Containers]]
 
     [
@@ -66,15 +66,12 @@
     [
         [No equivalent]
         [Local iterators can be used to iterate through individual buckets.
-            (I don't think that the order of local iterators and iterators are
+            (The order of local iterators and iterators aren't
             required to have any correspondence.)]
     ]
     [
         [Can be compared using the `==`, `!=`, `<`, `<=`, `>`, `>=` operators.]
-        [No comparison operators are defined in the standard, although
-            [link unordered.rationale.equality_operators
-            implementations might extend the containers to support `==` and
-            `!=`].]
+        [Can be compared using the `==` and `!=` operators.]
     ]
     [
         []
@@ -88,7 +85,7 @@
     ]
 ]
 
-[table Complexity Guarantees
+[table:complexity_guarantees Complexity Guarantees
     [[Operation] [Associative Containers] [Unordered Associative Containers]]
     [
         [Construction of empty container]

doc/compliance.qbk

@@ -0,0 +1,111 @@
+[/ Copyright 2011 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:compliance C++11 Compliance]
+
+[section:move Move emulation]
+
+Support for move semantics is implemented using Boost.Move. If rvalue
+references are available it will use them, but if not it uses a close,
+but imperfect emulation. On such compilers you'll need to use Boost.Move
+to take advantage of using movable container elements, also note that:
+
+* Non-copyable objects can be stored in the containers, but without support
+  for rvalue references the container will not be movable.
+* Argument forwarding is not perfect.
+
+[endsect]
+
+[section:allocator_compliance Use of allocators]
+
+C++11 introduced a new allocator system. It's backwards compatible due to
+the lax requirements for allocators in the old standard, but might need
+some changes for allocators which worked with the old versions of the
+unordered containers.
+It uses a traits class, `allocator_traits` to handle the allocator
+adding extra functionality, and making some methods and types optional.
+During development a stable release of
+`allocator_traits` wasn't available so an internal partial implementation
+is always used in this version. Hopefully a future version will use the
+standard implementation where available.
+
+The member functions `construct`, `destroy` and `max_size` are now
+optional, if they're not available a fallback is used.
+A full implementation of `allocator_traits` requires sophisticated
+member function detection so that the fallback is used whenever the
+member function call is not well formed.
+This requires support for SFINAE expressions, which are available on
+GCC from version 4.4 and Clang.
+
+On other compilers, there's just a test to see if the allocator has
+a member, but no check that it can be called. So rather than using a
+fallback there will just be a compile error.
+
+`propagate_on_container_copy_assignment`,
+`propagate_on_container_move_assignment`,
+`propagate_on_container_swap` and
+`select_on_container_copy_construction` are also supported.
+Due to imperfect move emulation, some assignments might check
+`propagate_on_container_copy_assignment` on some compilers and
+`propagate_on_container_move_assignment` on others.
+
+The use of the allocator's construct and destruct methods might be a bit
+surprising.
+Nodes are constructed and destructed using the allocator, but the elements
+are stored in aligned space within the node and constructed and destructed
+by calling the constructor and destructor directly.
+
+In C++11 the allocator's construct function has the signature:
+
+    template <class U, class... Args>
+    void construct(U* p, Args&&... args);
+
+which supports calling `construct` for the contained object, but
+most existing allocators don't support this. If member function detection
+was good enough then with old allocators it would fall back to calling
+the element's constructor directly but in general, detection isn't good
+enough to do this which is why Boost.Unordered just calls the constructor
+directly every time. In most cases this will work okay.
+
+`pointer_traits` aren't used. Instead, pointer types are obtained from
+rebound allocators, this can cause problems if the allocator can't be
+used with incomplete types. If `const_pointer` is not defined in the
+allocator, `boost::pointer_to_other<pointer, const value_type>::type`
+is used to obtain a const pointer.
+
+[endsect]
+
+[section:pairs Pairs]
+
+Since the containers use `std::pair` they're limited to the version
+from the current standard library. But since C++11 `std::pair`'s
+`piecewise_construct` based constructor is very useful, `emplace`
+emulates it with a `piecewise_construct` in the `boost::unordered`
+namespace. So for example, the following will work:
+
+    boost::unordered_multimap<std::string, std::complex> x;
+
+    x.emplace(
+        boost::unordered::piecewise_construct,
+        boost::make_tuple("key"), boost::make_tuple(1, 2));
+
+Older drafts of the standard also supported variadic constructors
+for `std::pair`, where the first argument would be used for the
+first part of the pair, and the remaining for the second part.
+
+[endsect]
+
+[section:misc Miscellaneous]
+
+When swapping, `Pred` and `Hash` are not currently swapped by calling
+`swap`, their copy constructors are used. As a consequence when swapping
+an exception may be throw from their  copy constructor.
+
+Variadic constructor arguments for `emplace` are only used when both
+rvalue references and variadic template parameters are available.
+Otherwise `emplace` can only take up to 10 constructors arguments.
+
+[endsect]
+
+[endsect]

doc/hash_equality.qbk

@@ -13,7 +13,7 @@ is declared as:
             class Key, class Mapped,
             class Hash = ``[classref boost::hash]``<Key>,
             class Pred = std::equal_to<Key>,
-            class Alloc = std::allocator<Key> >
+            class Alloc = std::allocator<std::pair<Key const, Mapped> > >
         class ``[classref boost::unordered_map unordered_map]``;
 
 The hash function comes first as you might want to change the hash function
@@ -23,7 +23,7 @@ but not the equality predicate. For example, if you wanted to use the
 [import src_code/dictionary.cpp]
 [case_sensitive_dictionary_fnv]
 
-There is an [@../../libs/unordered/examples/fnv1.hpp implementation
+There is an [@boost:/libs/unordered/examples/fnv1.hpp implementation
 of FNV-1] in the examples directory.
 
 If you wish to use a different equality function,
@@ -38,9 +38,19 @@ Which you can then use in a case insensitive dictionary:
 [case_insensitive_dictionary]
 
 This is a simplified version of the example at
-[@../../libs/unordered/examples/case_insensitive.hpp /libs/unordered/examples/case_insensitive.hpp]
+[@boost:/libs/unordered/examples/case_insensitive.hpp /libs/unordered/examples/case_insensitive.hpp]
 which supports other locales and string types.
 
+[caution
+Be careful when using the equality (`==`) operator with custom equality
+predicates, especially if you're using a function pointer. If you compare two
+containers with different equality predicates then the result is undefined.
+For most stateless function objects this is impossible - since you can only
+compare objects with the same equality predicate you know the equality
+predicates must be equal. But if you're using function pointers or a stateful
+equality predicate (e.g. boost::function) then you can get into trouble.
+]
+
 [h2 Custom Types]
 
 Similarly, a custom hash function can be used for custom types:
@@ -57,9 +67,10 @@ so that the hash function doesn't need to be explicitly given:
 
 See the [link hash.custom Boost.Hash documentation] for more detail on how to
 do this.  Remember that it relies on extensions to the draft standard - so it
-won't work on other implementations of the unordered associative containers.
+won't work for other implementations of the unordered associative containers,
+you'll need to explicitly use Boost.Hash.
 
-[table Methods for accessing the hash and equality functions.
+[table:access_methods Methods for accessing the hash and equality functions.
     [[Method] [Description]]
 
     [

doc/intro.qbk

@@ -2,15 +2,6 @@
  / 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) ]
 
-[def __tr1__ 
-    [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf
-    C++ Standard Library Technical Report]]
-[def __boost-tr1__
-    [@http://www.boost.org/doc/html/boost_tr1.html
-    Boost.TR1]]
-[def __draft__
-    [@http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2007/n2461.pdf
-    Working Draft of the C++ Standard]]
 [def __hash-table__ [@http://en.wikipedia.org/wiki/Hash_table
     hash table]]
 [def __hash-function__ [@http://en.wikipedia.org/wiki/Hash_function
@@ -31,12 +22,10 @@ to order their elements. For some data types this is impossible to implement
 or isn't practical. In contrast, a hash table only needs an equality function
 and a hash function for the key.
 
-With this in mind, the __tr1__ introduced the unordered associative containers,
-which are implemented using hash tables, and they have now been added to the
-__draft__.
-
-This library supplies an almost complete implementation of the specification in
-the __draft__.
+With this in mind, unordered associative containers were added to the C++
+standard. This is an implementation of the containers described in C++11,
+with some [link unordered.compliance deviations from the standard] in
+order to work with non-C++11 compilers and libraries.
 
 `unordered_set` and `unordered_multiset` are defined in the header
 <[headerref boost/unordered_set.hpp]>

doc/rationale.qbk

@@ -5,12 +5,6 @@
 [def __wang__
     [@http://www.concentric.net/~Ttwang/tech/inthash.htm
     Thomas Wang's article on integer hash functions]]
-[def __n2345__
-    [@http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2007/n2345.pdf
-    N2345, 'Placement Insert for Containers']]
-[def __n2369__
-    [@http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2007/n2369.pdf
-    the August 2007 version of the working draft standard]]
 
 [section:rationale Implementation Rationale]
 
@@ -50,6 +44,8 @@ bucket but there are a some serious problems with this:
 
 So chained addressing is used.
 
+[/ (Removing for now as this is out of date)
+
 For containers with unique keys I store the buckets in a single-linked list.
 There are other possible data structures (such as a double-linked list)
 that allow for some operations to be faster (such as erasing and iteration)
@@ -69,6 +65,17 @@ nodes in reverse order. This allows quick navigation to the end of a group (sinc
 the first element points to the last) and can be quickly updated when elements
 are inserted or erased. The main disadvantage of this approach is some hairy code
 for erasing elements.
+]
+
+[/ (Starting to write up new structure, might not be ready in time)
+The node used to be stored in a linked list for each bucket but that
+didn't meet the complexity requirements for C++11, so now the nodes
+are stored in one long single linked list. But there needs a way to get
+the bucket from the node, to do that a copy of the key's hash value is
+stored in the node. Another possibility would be to store a pointer to
+the bucket, or the bucket's index, but storing the hash value allows
+some operations to be faster.
+]
 
 [h2 Number of Buckets]
 
@@ -96,108 +103,4 @@ efficiency advantage of power of 2 hash tables.
 
 So, this implementation uses a prime number for the hash table size.
 
-[h2 Equality operators]
-
-`operator==` and `operator!=` are not included in the standard, but I've
-added them as I think they could be useful and can be efficiently
-implemented. They are specified
-differently to the standard associative containers, comparing keys
-using the equality predicate rather than `operator==`. This is inconsistent
-with the other containers but it is probably closer to user's expectations.
-
-[h2 Active Issues and Proposals]
-
-[h3 Removing unused allocator functions]
-
-In
-[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2257.html
-N2257, removing unused allocator functions],
-Matt Austern suggests removing the `construct`, `destroy` and `address` member
-functions - all of which Boost.Unordered calls. Changing this will simplify the
-implementation, as well as make supporting `emplace` easier, but means that the
-containers won't support allocators which require these methods to be called.
-Detlef Vollmann opposed this change in
-[@http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2007/n2339.htm N2339].
-
-[h3 Swapping containers with unequal allocators]
-
-It isn't clear how to swap containers when their allocators aren't equal.
-This is 
-[@http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#431
-Issue 431: Swapping containers with unequal allocators].
-
-Howard Hinnant wrote about this in
-[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1599.html N1599]
-and suggested swapping both the allocators and the containers' contents.
-But the committee have now decided that `swap` should do a fast swap if the
-allocator is Swappable and a slow swap using copy construction otherwise. To
-make this distinction requires concepts.
-
-In
-[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2387.pdf
-N2387, Omnibus Allocator Fix-up Proposals],
-Pablo Halpern suggests that there are actually two distinct allocator models,
-"Moves with Value" and "Scoped" which behave differently:
-
-[:
-When allocators are allowed to have state, it is necessary to have a model for
-determining from where an object obtains its allocator. We’ve identified two such
-models: the “Moves with Value” allocator model and the “Scoped” allocator model.
-
-In the “Moves with Value” allocator model, the copy constructor of an allocator-aware
-class will copy both the value and the allocator from its argument. This is the model
-specified in the C++03 standard. With this model, inserting an object into a container
-usually causes the new container item to copy the allocator from the object that was
-inserted. This model can be useful in special circumstances, e.g., if the items within a
-container use an allocator that is specially tuned to the item’s type.
-
-In the “Scoped” allocator model, the allocator used to construct an object is determined
-by the context of that object, much like a storage class. With this model, inserting an
-object into a container causes the new container item to use the same allocator as the
-container. To avoid allocators being used in the wrong context, the allocator is never
-copied during copy or move construction. Thus, it is possible using this model to use
-allocators based on short-lived resources without fear that an object will transfer its
-allocator to a copy that might outlive the (shared) allocator resource. This model is
-reasonably safe and generally useful on a large scale. There was strong support in the
-2005 Tremblant meeting for pursuing an allocator model that propagates allocators
-from container to contained objects.
-]
-
-With these models the choice becomes clearer:
-
-[:
-I introduced the “Moves with Value” allocator model and the
-“Scoped” allocator model. In the former case, the allocator is copied when the container
-is copy-constructed. In the latter case it is not. Swapping the allocators is the right thing
-to do if the containers conform to the “Moves with Value” allocator model and
-absolutely the wrong thing to do if the containers conform to the “Scoped” allocator
-model. With the two allocator models well-defined, the desired behavior becomes clear.
-]
-
-The proposal is that allocators are swapped if the allocator follows the
-"Moves with Value" model and the allocator is swappable. Otherwise a slow swap
-is used. Since containers currently only support the "Moves with Value" model
-this is consistent with the committee's current recommendation (although it
-suggests using a trait to detect if the allocator is swappable rather than a
-concept).
-
-Since there is currently neither have a swappable trait or concept for
-allocators this implementation always performs a slow swap.
-
-[h3 Are insert and erase stable for unordered_multiset and unordered_multimap?]
-
-It is not specified if `unordered_multiset` and `unordered_multimap` preserve the order
-of elements with equivalent keys (i.e. if they're stable under `insert` and `erase`).
-This is [@http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#518 issue 581].
-The current proposal is that insert, erase and rehash are stable - so they are here.
-(Update: during the release of this version, this requirement was added to
-[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2691.pdf
-the lastest working draft]).
-
-[h3 const_local_iterator cbegin, cend missing from TR1]
-
-[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2684.html#691
-Issue 691] is that `cbegin` and `cend` are missing for local iterators.
-The current resolution is that they'll be added, so I've added them.
-
 [endsect]

doc/src_code/intro.cpp

@@ -1,5 +1,5 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 

doc/src_code/point1.cpp

@@ -1,5 +1,5 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 

doc/src_code/point2.cpp

@@ -1,5 +1,5 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 

doc/unordered.qbk

@@ -3,7 +3,7 @@
  / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) ]
 
 [library Boost.Unordered
-    [quickbook 1.4]
+    [quickbook 1.5]
     [authors [James, Daniel]]
     [copyright 2003 2004 Jeremy B. Maitin-Shepard]
     [copyright 2005 2006 2007 2008 Daniel James]
@@ -13,7 +13,7 @@
     [license
         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]
+        [@http://www.boost.org/LICENSE_1_0.txt])
     ]
 ]
 
@@ -31,6 +31,7 @@
 [include:unordered buckets.qbk]
 [include:unordered hash_equality.qbk]
 [include:unordered comparison.qbk]
+[include:unordered compliance.qbk]
 [include:unordered rationale.qbk]
 [include:unordered changes.qbk]
 [xinclude ref.xml]

examples/case_insensitive.hpp

@@ -1,5 +1,5 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 

examples/case_insensitive_test.cpp

@@ -1,5 +1,5 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 

examples/fnv1.hpp

@@ -1,5 +1,5 @@
 
-// Copyright 2008 Daniel James.
+// Copyright 2008-2009 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)
 
@@ -55,11 +55,14 @@ namespace hash
 
     // For 128 bit machines:
     // const std::size_t fnv_prime = 309485009821345068724781401u;
-    // const std::size_t fnv_offset_basis = 275519064689413815358837431229664493455u;
+    // const std::size_t fnv_offset_basis =
+    //     275519064689413815358837431229664493455u;
 
     // For 256 bit machines:
-    // const std::size_t fnv_prime = 374144419156711147060143317175368453031918731002211u;
-    // const std::size_t fnv_offset_basis = 100029257958052580907070968620625704837092796014241193945225284501741471925557u;
+    // const std::size_t fnv_prime =
+    //     374144419156711147060143317175368453031918731002211u;
+    // const std::size_t fnv_offset_basis =
+    //     100029257958052580907070968620625704837092796014241193945225284501741471925557u;
 
     typedef basic_fnv_1<fnv_prime, fnv_offset_basis> fnv_1;
     typedef basic_fnv_1a<fnv_prime, fnv_offset_basis> fnv_1a;

include/boost/unordered/detail/allocator_helpers.hpp

@@ -1,7 +1,12 @@
 
-// Copyright 2005-2008 Daniel James.
+// Copyright 2005-2011 Daniel James.
+// Copyright 2009 Pablo Halpern.
+//
 // 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)
+//
+// Allocator traits written by Daniel James based on Pablo Halpern's
+// implementation.
 
 #ifndef BOOST_UNORDERED_DETAIL_ALLOCATOR_UTILITIES_HPP_INCLUDED
 #define BOOST_UNORDERED_DETAIL_ALLOCATOR_UTILITIES_HPP_INCLUDED
@@ -11,227 +16,508 @@
 #endif
 
 #include <boost/config.hpp>
+#include <boost/detail/select_type.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/enum.hpp>
+#include <boost/limits.hpp>
+#include <boost/type_traits/add_lvalue_reference.hpp>
+#include <boost/pointer_to_other.hpp>
+#include <boost/assert.hpp>
+#include <boost/utility/addressof.hpp>
 
-#if (defined(BOOST_NO_STD_ALLOCATOR) || defined(BOOST_DINKUMWARE_STDLIB)) \
-    && !defined(__BORLANDC__)
-#  define BOOST_UNORDERED_USE_ALLOCATOR_UTILITIES
+#if !defined(BOOST_UNORDERED_USE_ALLOCATOR_TRAITS)
+#define BOOST_UNORDERED_USE_ALLOCATOR_TRAITS 0
 #endif
 
-#if defined(BOOST_UNORDERED_USE_ALLOCATOR_UTILITIES)
-#  include <boost/detail/allocator_utilities.hpp>
+#if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS
+#  include <memory>
 #endif
 
-#include <boost/mpl/aux_/config/eti.hpp>
+#if !defined(BOOST_NO_0X_HDR_TYPE_TRAITS)
+#  include <type_traits>
+#endif
 
-namespace boost {
-    namespace unordered_detail {
+namespace boost { namespace unordered { namespace detail {
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Integral_constrant, true_type, false_type
+    //
+    // Uses the standard versions if available.
+
+#if !defined(BOOST_NO_0X_HDR_TYPE_TRAITS)
+
+    using std::integral_constant;
+    using std::true_type;
+    using std::false_type;
 
-#if defined(BOOST_UNORDERED_USE_ALLOCATOR_UTILITIES)
-        template <class Alloc, class T>
-        struct rebind_wrap : ::boost::detail::allocator::rebind_to<Alloc, T> {};
 #else
-        template <class Alloc, class T>
-        struct rebind_wrap
-        {
-            typedef BOOST_DEDUCED_TYPENAME
-                Alloc::BOOST_NESTED_TEMPLATE rebind<T>::other
-                type;
-        };
-#endif
 
-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-        template <class T>
-        inline void reset(T& x) { x  = T(); }
+    template <typename T, T Value>
+    struct integral_constant { enum { value = Value }; };
 
-        template <class Ptr>
-        inline Ptr null_ptr() { return Ptr(); }
-#else
-        template <class T>
-        inline void reset_impl(T& x, ...) { x  = T(); }
-        template <class T>
-        inline void reset_impl(T*& x, int) { x  = 0; }
-        template <class T>
-        inline void reset(T& x) { reset_impl(x); }
-
-        template <class Ptr>
-        inline Ptr null_ptr() { Ptr x; reset(x); return x; }
-#endif
-
-        // Work around for Microsoft's ETI bug.
-        
-        template <class Allocator> struct allocator_value_type
-        {
-            typedef BOOST_DEDUCED_TYPENAME Allocator::value_type type;
-        };
-
-        template <class Allocator> struct allocator_pointer
-        {
-            typedef BOOST_DEDUCED_TYPENAME Allocator::pointer type;
-        };
-        
-        template <class Allocator> struct allocator_const_pointer
-        {
-            typedef BOOST_DEDUCED_TYPENAME Allocator::const_pointer type;
-        };
-        
-        template <class Allocator> struct allocator_reference
-        {
-            typedef BOOST_DEDUCED_TYPENAME Allocator::reference type;
-        };
-        
-        template <class Allocator> struct allocator_const_reference
-        {
-            typedef BOOST_DEDUCED_TYPENAME Allocator::const_reference type;
-        };
-        
-#if defined(BOOST_MPL_CFG_MSVC_ETI_BUG)
-
-        template <>
-        struct allocator_value_type<int>
-        {
-            typedef int type;
-        };
-
-        template <>
-        struct allocator_pointer<int>
-        {
-            typedef int type;
-        };
-
-        template <>
-        struct allocator_const_pointer<int>
-        {
-            typedef int type;
-        };
-
-        template <>
-        struct allocator_reference<int>
-        {
-            typedef int type;
-        };
-
-        template <>
-        struct allocator_const_reference<int>
-        {
-            typedef int type;
-        };
+    typedef boost::unordered::detail::integral_constant<bool, true> true_type;
+    typedef boost::unordered::detail::integral_constant<bool, false> false_type;
 
 #endif
 
-        template <class Allocator>
-        struct allocator_constructor
-        {
-            typedef BOOST_DEDUCED_TYPENAME allocator_value_type<Allocator>::type value_type;
-            typedef BOOST_DEDUCED_TYPENAME allocator_pointer<Allocator>::type pointer;
+    ////////////////////////////////////////////////////////////////////////////
+    // Explicitly call a destructor
 
-            Allocator& alloc_;
-            pointer ptr_;
-            bool constructed_;
-
-            allocator_constructor(Allocator& a)
-                : alloc_(a), ptr_(), constructed_(false)
-            {
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-                    unordered_detail::reset(ptr_);
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+#pragma warning(disable:4100) // unreferenced formal parameter
 #endif
-            }
 
-            ~allocator_constructor() {
-                if(ptr_) {
-                    if(constructed_) alloc_.destroy(ptr_);
-                    alloc_.deallocate(ptr_, 1);
-                }
-            }
-
-            template <class V>
-            void construct(V const& v) {
-                BOOST_ASSERT(!ptr_ && !constructed_);
-                ptr_ = alloc_.allocate(1);
-                alloc_.construct(ptr_, value_type(v));
-                constructed_  = true;
-            }
-
-            void construct(value_type const& v) {
-                BOOST_ASSERT(!ptr_ && !constructed_);
-                ptr_ = alloc_.allocate(1);
-                alloc_.construct(ptr_, v);
-                constructed_  = true;
-            }
-
-            pointer get() const
-            {
-                return ptr_;
-            }
-
-            // no throw
-            pointer release()
-            {
-                pointer p = ptr_;
-                constructed_ = false;
-                unordered_detail::reset(ptr_);
-                return p;
-            }
-        };
-
-        template <class Allocator>
-        struct allocator_array_constructor
-        {
-            typedef BOOST_DEDUCED_TYPENAME allocator_pointer<Allocator>::type pointer;
-
-            Allocator& alloc_;
-            pointer ptr_;
-            pointer constructed_;
-            std::size_t length_;
-
-            allocator_array_constructor(Allocator& a)
-                : alloc_(a), ptr_(), constructed_(), length_(0)
-            {
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-                unordered_detail::reset(constructed_);
-                unordered_detail::reset(ptr_);
-#endif
-            }
-
-            ~allocator_array_constructor() {
-                if (ptr_) {
-                    for(pointer p = ptr_; p != constructed_; ++p)
-                        alloc_.destroy(p);
-
-                    alloc_.deallocate(ptr_, length_);
-                }
-            }
-
-            template <class V>
-            void construct(V const& v, std::size_t l)
-            {
-                BOOST_ASSERT(!ptr_);
-                length_ = l;
-                ptr_ = alloc_.allocate(length_);
-                pointer end = ptr_ + static_cast<std::ptrdiff_t>(length_);
-                for(constructed_ = ptr_; constructed_ != end; ++constructed_)
-                    alloc_.construct(constructed_, v);
-            }
-
-            pointer get() const
-            {
-                return ptr_;
-            }
-
-            pointer release()
-            {
-                pointer p(ptr_);
-                unordered_detail::reset(ptr_);
-                return p;
-            }
-        private:
-            allocator_array_constructor(allocator_array_constructor const&);
-            allocator_array_constructor& operator=(allocator_array_constructor const&);
-        };
+    template <class T>
+    inline void destroy(T* x) {
+        x->~T();
     }
-}
 
-#if defined(BOOST_UNORDERED_USE_ALLOCATOR_UTILITIES)
-#  undef BOOST_UNORDERED_USE_ALLOCATOR_UTILITIES
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
 #endif
 
+    ////////////////////////////////////////////////////////////////////////////
+    // Bits and pieces for implementing traits
+    //
+    // Some of these are also used elsewhere
+
+    template <typename T> typename boost::add_lvalue_reference<T>::type make();
+    struct choice9 { typedef char (&type)[9]; };
+    struct choice8 : choice9 { typedef char (&type)[8]; };
+    struct choice7 : choice8 { typedef char (&type)[7]; };
+    struct choice6 : choice7 { typedef char (&type)[6]; };
+    struct choice5 : choice6 { typedef char (&type)[5]; };
+    struct choice4 : choice5 { typedef char (&type)[4]; };
+    struct choice3 : choice4 { typedef char (&type)[3]; };
+    struct choice2 : choice3 { typedef char (&type)[2]; };
+    struct choice1 : choice2 { typedef char (&type)[1]; };
+    choice1 choose();
+
+    typedef choice1::type yes_type;
+    typedef choice2::type no_type;
+
+    struct private_type
+    {
+       private_type const &operator,(int) const;
+    };
+
+    template <typename T>
+    no_type is_private_type(T const&);
+    yes_type is_private_type(private_type const&);
+
+    struct convert_from_anything {
+        template <typename T>
+        convert_from_anything(T const&);
+    };
+
+#if !defined(BOOST_NO_SFINAE_EXPR)
+
+#   define BOOST_UNORDERED_HAVE_CALL_DETECTION 1
+
+    template <typename T, unsigned int> struct expr_test;
+    template <typename T> struct expr_test<T, sizeof(char)> : T {};
+    template <typename U> static char for_expr_test(U const&);
+
+#define BOOST_UNORDERED_CHECK_EXPRESSION(count, result, expression)         \
+        template <typename U>                                               \
+        static typename boost::unordered::detail::expr_test<                \
+            BOOST_PP_CAT(choice, result),                                   \
+            sizeof(boost::unordered::detail::for_expr_test((                \
+                (expression),                                               \
+            0)))>::type test(                                               \
+            BOOST_PP_CAT(choice, count))
+
+#define BOOST_UNORDERED_DEFAULT_EXPRESSION(count, result)                   \
+        template <typename U>                                               \
+        static BOOST_PP_CAT(choice, result)::type test(                     \
+            BOOST_PP_CAT(choice, count))
+
+#define BOOST_UNORDERED_HAS_FUNCTION(name, thing, args, _)                  \
+    struct BOOST_PP_CAT(has_, name)                                         \
+    {                                                                       \
+        BOOST_UNORDERED_CHECK_EXPRESSION(1, 1,                              \
+            boost::unordered::detail::make< thing >().name args);           \
+        BOOST_UNORDERED_DEFAULT_EXPRESSION(2, 2);                           \
+                                                                            \
+        enum { value = sizeof(test<T>(choose())) == sizeof(choice1::type) };\
+    }
+
+#else
+
+#   define BOOST_UNORDERED_HAVE_CALL_DETECTION 0
+
+    template <typename T> struct identity { typedef T type; };
+
+#define BOOST_UNORDERED_CHECK_MEMBER(count, result, name, member)           \
+                                                                            \
+    typedef typename boost::unordered::detail::identity<member>::type       \
+        BOOST_PP_CAT(check, count);                                         \
+                                                                            \
+    template <BOOST_PP_CAT(check, count) e>                                 \
+    struct BOOST_PP_CAT(test, count) {                                      \
+        typedef BOOST_PP_CAT(choice, result) type;                          \
+    };                                                                      \
+                                                                            \
+    template <class U> static typename                                      \
+        BOOST_PP_CAT(test, count)<&U::name>::type                           \
+        test(BOOST_PP_CAT(choice, count))
+
+#define BOOST_UNORDERED_DEFAULT_MEMBER(count, result)                       \
+    template <class U> static BOOST_PP_CAT(choice, result)::type            \
+        test(BOOST_PP_CAT(choice, count))
+
+#define BOOST_UNORDERED_HAS_MEMBER(name)                                    \
+    struct BOOST_PP_CAT(has_, name)                                         \
+    {                                                                       \
+        struct impl {                                                       \
+            struct base_mixin { int name; };                                \
+            struct base : public T, public base_mixin {};                   \
+                                                                            \
+            BOOST_UNORDERED_CHECK_MEMBER(1, 1, name, int base_mixin::*);    \
+            BOOST_UNORDERED_DEFAULT_MEMBER(2, 2);                           \
+                                                                            \
+            enum { value = sizeof(choice2::type) ==                         \
+                sizeof(test<base>(choose()))                                \
+            };                                                              \
+        };                                                                  \
+                                                                            \
+        enum { value = impl::value };                                       \
+    }
+
+#endif
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Allocator traits
+    //
+    // Uses the standard versions if available.
+    // (although untested as I don't have access to a standard version yet)
+
+#if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS
+
+    template <typename Alloc>
+    struct allocator_traits : std::allocator_traits<Alloc> {};
+
+    template <typename Alloc, typename T>
+    struct rebind_wrap
+    {
+        typedef typename std::allocator_traits<Alloc>::
+            template rebind_alloc<T> type;
+    };
+
+#else
+
+    // TODO: Does this match std::allocator_traits<Alloc>::rebind_alloc<T>?
+    template <typename Alloc, typename T>
+    struct rebind_wrap
+    {
+        typedef typename Alloc::BOOST_NESTED_TEMPLATE rebind<T>::other
+            type;
+    };
+
+#if defined(BOOST_MSVC) && BOOST_MSVC <= 1400
+
+    #define BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(tname)                       \
+        template <typename Tp, typename Default>                            \
+        struct default_type_ ## tname {                                     \
+                                                                            \
+            template <typename X>                                           \
+            static choice1::type test(choice1, typename X::tname* = 0);     \
+                                                                            \
+            template <typename X>                                           \
+            static choice2::type test(choice2, void* = 0);                  \
+                                                                            \
+            struct DefaultWrap { typedef Default tname; };                  \
+                                                                            \
+            enum { value = (1 == sizeof(test<Tp>(choose()))) };             \
+                                                                            \
+            typedef typename boost::detail::if_true<value>::                \
+                BOOST_NESTED_TEMPLATE then<Tp, DefaultWrap>                 \
+                ::type::tname type;                                         \
+        }
+
+#else
+
+    template <typename T, typename T2>
+    struct sfinae : T2 {};
+
+    #define BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(tname)                       \
+        template <typename Tp, typename Default>                            \
+        struct default_type_ ## tname {                                     \
+                                                                            \
+            template <typename X>                                           \
+            static typename boost::unordered::detail::sfinae<               \
+                    typename X::tname, choice1>::type                       \
+                test(choice1);                                              \
+                                                                            \
+            template <typename X>                                           \
+            static choice2::type test(choice2);                             \
+                                                                            \
+            struct DefaultWrap { typedef Default tname; };                  \
+                                                                            \
+            enum { value = (1 == sizeof(test<Tp>(choose()))) };             \
+                                                                            \
+            typedef typename boost::detail::if_true<value>::                \
+                BOOST_NESTED_TEMPLATE then<Tp, DefaultWrap>                 \
+                ::type::tname type;                                         \
+        }
+
+#endif
+
+    #define BOOST_UNORDERED_DEFAULT_TYPE(T,tname, arg)                      \
+        typename default_type_ ## tname<T, arg>::type
+
+    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(pointer);
+    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(const_pointer);
+    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(void_pointer);
+    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(const_void_pointer);
+    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(difference_type);
+    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(size_type);
+    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_copy_assignment);
+    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_move_assignment);
+    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_swap);
+
+#if BOOST_UNORDERED_HAVE_CALL_DETECTION
+    template <typename T>
+    BOOST_UNORDERED_HAS_FUNCTION(
+        select_on_container_copy_construction, U const, (), 0
+    );
+
+    template <typename T>
+    BOOST_UNORDERED_HAS_FUNCTION(
+        max_size, U const, (), 0
+    );
+
+    template <typename T, typename ValueType>
+    BOOST_UNORDERED_HAS_FUNCTION(
+        construct, U, (
+            boost::unordered::detail::make<ValueType*>(),
+            boost::unordered::detail::make<ValueType const>()), 2
+    );
+
+    template <typename T, typename ValueType>
+    BOOST_UNORDERED_HAS_FUNCTION(
+        destroy, U, (boost::unordered::detail::make<ValueType*>()), 1
+    );
+#else
+    template <typename T>
+    BOOST_UNORDERED_HAS_MEMBER(select_on_container_copy_construction);
+
+    template <typename T>
+    BOOST_UNORDERED_HAS_MEMBER(max_size);
+
+    template <typename T, typename ValueType>
+    BOOST_UNORDERED_HAS_MEMBER(construct);
+
+    template <typename T, typename ValueType>
+    BOOST_UNORDERED_HAS_MEMBER(destroy);
+#endif
+
+    template <typename Alloc>
+    inline typename boost::enable_if_c<
+            boost::unordered::detail::
+            has_select_on_container_copy_construction<Alloc>::value, Alloc
+        >::type call_select_on_container_copy_construction(const Alloc& rhs)
+    {
+        return rhs.select_on_container_copy_construction();
+    }
+
+    template <typename Alloc>
+    inline typename boost::disable_if_c<
+            boost::unordered::detail::
+            has_select_on_container_copy_construction<Alloc>::value, Alloc
+        >::type call_select_on_container_copy_construction(const Alloc& rhs)
+    {
+        return rhs;
+    }
+
+    template <typename SizeType, typename Alloc>
+    inline typename boost::enable_if_c<
+            boost::unordered::detail::has_max_size<Alloc>::value, SizeType
+        >::type call_max_size(const Alloc& a)
+    {
+        return a.max_size();
+    }
+
+    template <typename SizeType, typename Alloc>
+    inline typename boost::disable_if_c<
+            boost::unordered::detail::has_max_size<Alloc>::value, SizeType
+        >::type call_max_size(const Alloc&)
+    {
+        return (std::numeric_limits<SizeType>::max)();
+    }
+
+    template <typename Alloc>
+    struct allocator_traits
+    {
+        typedef Alloc allocator_type;
+        typedef typename Alloc::value_type value_type;
+
+        typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, pointer, value_type*)
+            pointer;
+
+        template <typename T>
+        struct pointer_to_other : boost::pointer_to_other<pointer, T> {};
+
+        typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, const_pointer,
+            typename pointer_to_other<const value_type>::type)
+            const_pointer;
+
+        //typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, void_pointer,
+        //    typename pointer_to_other<void>::type)
+        //    void_pointer;
+        //
+        //typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, const_void_pointer,
+        //    typename pointer_to_other<const void>::type)
+        //    const_void_pointer;
+
+        typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, difference_type,
+            std::ptrdiff_t) difference_type;
+
+        typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, size_type, std::size_t)
+            size_type;
+
+        // TODO: rebind_alloc and rebind_traits
+
+       static pointer allocate(Alloc& a, size_type n)
+            { return a.allocate(n); }
+
+        // I never use this, so I'll just comment it out for now.
+        //
+        //static pointer allocate(Alloc& a, size_type n,
+        //        const_void_pointer hint)
+        //    { return DEFAULT_FUNC(allocate, pointer)(a, n, hint); }
+    
+        static void deallocate(Alloc& a, pointer p, size_type n)
+            { a.deallocate(p, n); }
+
+    public:
+
+        // Only supporting the basic copy constructor for now.
+
+        template <typename T>
+        static typename boost::enable_if_c<
+                boost::unordered::detail::has_construct<Alloc, T>::value>::type
+            construct(Alloc& a, T* p, T const& x)
+        {
+            a.construct(p, x);
+        }
+
+        template <typename T>
+        static typename boost::disable_if_c<
+                boost::unordered::detail::has_construct<Alloc, T>::value>::type
+            construct(Alloc&, T* p, T const& x)
+        {
+            new ((void*) p) T(x);
+        }
+
+        template <typename T>
+        static typename boost::enable_if_c<
+                boost::unordered::detail::has_destroy<Alloc, T>::value>::type
+            destroy(Alloc& a, T* p)
+        {
+            a.destroy(p);
+        }
+
+        template <typename T>
+        static typename boost::disable_if_c<
+                boost::unordered::detail::has_destroy<Alloc, T>::value>::type
+            destroy(Alloc&, T* p)
+        {
+            boost::unordered::detail::destroy(p);
+        }
+
+        static size_type max_size(const Alloc& a)
+        {
+            return boost::unordered::detail::call_max_size<size_type>(a);
+        }
+
+        // Allocator propagation on construction
+        
+        static Alloc select_on_container_copy_construction(Alloc const& rhs)
+        {
+            return boost::unordered::detail::
+                call_select_on_container_copy_construction(rhs);
+        }
+    
+        // Allocator propagation on assignment and swap.
+        // Return true if lhs is modified.
+        typedef BOOST_UNORDERED_DEFAULT_TYPE(
+            Alloc, propagate_on_container_copy_assignment, false_type)
+            propagate_on_container_copy_assignment;
+        typedef BOOST_UNORDERED_DEFAULT_TYPE(
+            Alloc,propagate_on_container_move_assignment, false_type)
+            propagate_on_container_move_assignment;
+        typedef BOOST_UNORDERED_DEFAULT_TYPE(
+            Alloc,propagate_on_container_swap,false_type)
+            propagate_on_container_swap;
+    };
+
+#undef BOOST_UNORDERED_DEFAULT_TYPE_TMPLT
+#undef BOOST_UNORDERED_DEFAULT_TYPE
+
+#endif
+
+    // array_constructor
+    //
+    // Allocate and construct an array in an exception safe manner, and
+    // clean up if an exception is thrown before the container takes charge
+    // of it.
+
+    template <typename Allocator>
+    struct array_constructor
+    {
+        typedef boost::unordered::detail::allocator_traits<Allocator> traits;
+        typedef typename traits::pointer pointer;
+
+        Allocator& alloc_;
+        pointer ptr_;
+        pointer constructed_;
+        std::size_t length_;
+
+        array_constructor(Allocator& a)
+            : alloc_(a), ptr_(), constructed_(), length_(0)
+        {
+            constructed_ = pointer();
+            ptr_ = pointer();
+        }
+
+        ~array_constructor() {
+            if (ptr_) {
+                for(pointer p = ptr_; p != constructed_; ++p)
+                    traits::destroy(alloc_, boost::addressof(*p));
+
+                traits::deallocate(alloc_, ptr_, length_);
+            }
+        }
+
+        template <typename V>
+        void construct(V const& v, std::size_t l)
+        {
+            BOOST_ASSERT(!ptr_);
+            length_ = l;
+            ptr_ = traits::allocate(alloc_, length_);
+            pointer end = ptr_ + static_cast<std::ptrdiff_t>(length_);
+            for(constructed_ = ptr_; constructed_ != end; ++constructed_)
+                traits::construct(alloc_, boost::addressof(*constructed_), v);
+        }
+
+        pointer get() const
+        {
+            return ptr_;
+        }
+
+        pointer release()
+        {
+            pointer p(ptr_);
+            ptr_ = pointer();
+            return p;
+        }
+    private:
+        array_constructor(array_constructor const&);
+        array_constructor& operator=(array_constructor const&);
+    };
+}}}
+
 #endif

include/boost/unordered/detail/buckets.hpp

@@ -0,0 +1,667 @@
+
+// Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
+// Copyright (C) 2005-2011 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)
+
+#ifndef BOOST_UNORDERED_DETAIL_MANAGER_HPP_INCLUDED
+#define BOOST_UNORDERED_DETAIL_MANAGER_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/unordered/detail/util.hpp>
+#include <boost/unordered/detail/allocator_helpers.hpp>
+#include <boost/unordered/detail/emplace_args.hpp>
+#include <boost/type_traits/aligned_storage.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#include <boost/swap.hpp>
+#include <boost/assert.hpp>
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+#pragma warning(disable:4127) // conditional expression is constant
+#endif
+
+namespace boost { namespace unordered { namespace detail {
+
+    template <typename Types> struct table;
+    template <typename NodePointer> struct bucket;
+    struct ptr_bucket;
+    template <typename A, typename Bucket, typename Node> struct buckets;
+
+    ///////////////////////////////////////////////////////////////////
+    //
+    // Node construction
+
+    template <typename NodeAlloc>
+    struct node_constructor
+    {
+    private:
+
+        typedef NodeAlloc node_allocator;
+        typedef boost::unordered::detail::allocator_traits<NodeAlloc>
+            node_allocator_traits;
+        typedef typename node_allocator_traits::value_type node;
+        typedef typename node_allocator_traits::pointer node_pointer;
+        typedef typename node::value_type value_type;
+
+        node_allocator& alloc_;
+        node_pointer node_;
+        bool node_constructed_;
+        bool value_constructed_;
+
+    public:
+
+        node_constructor(node_allocator& n) :
+            alloc_(n),
+            node_(),
+            node_constructed_(false),
+            value_constructed_(false)
+        {
+        }
+
+        ~node_constructor();
+
+        void construct_node();
+
+        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
+        void construct_value(BOOST_UNORDERED_EMPLACE_ARGS)
+        {
+            BOOST_ASSERT(node_ && node_constructed_ && !value_constructed_);
+            boost::unordered::detail::construct_impl(
+                node_->value_ptr(), BOOST_UNORDERED_EMPLACE_FORWARD);
+            value_constructed_ = true;
+        }
+
+        template <typename A0>
+        void construct_value2(BOOST_FWD_REF(A0) a0)
+        {
+            BOOST_ASSERT(node_ && node_constructed_ && !value_constructed_);
+            boost::unordered::detail::construct_impl2(
+                node_->value_ptr(), boost::forward<A0>(a0));
+            value_constructed_ = true;
+        }
+
+        value_type const& value() const {
+            BOOST_ASSERT(node_ && node_constructed_ && value_constructed_);
+            return node_->value();
+        }
+
+        // no throw
+        node_pointer release()
+        {
+            node_pointer p = node_;
+            node_ = node_pointer();
+            return p;
+        }
+
+    private:
+        node_constructor(node_constructor const&);
+        node_constructor& operator=(node_constructor const&);
+    };
+    
+    template <typename Alloc>
+    node_constructor<Alloc>::~node_constructor()
+    {
+        if (node_) {
+            if (value_constructed_) {
+                boost::unordered::detail::destroy(node_->value_ptr());
+            }
+
+            if (node_constructed_) {
+                node_allocator_traits::destroy(alloc_,
+                    boost::addressof(*node_));
+            }
+
+            node_allocator_traits::deallocate(alloc_, node_, 1);
+        }
+    }
+
+    template <typename Alloc>
+    void node_constructor<Alloc>::construct_node()
+    {
+        if(!node_) {
+            node_constructed_ = false;
+            value_constructed_ = false;
+
+            node_ = node_allocator_traits::allocate(alloc_, 1);
+
+            node_allocator_traits::construct(alloc_,
+                boost::addressof(*node_), node());
+            node_->init(static_cast<typename node::link_pointer>(node_));
+            node_constructed_ = true;
+        }
+        else {
+            BOOST_ASSERT(node_constructed_);
+
+            if (value_constructed_)
+            {
+                boost::unordered::detail::destroy(node_->value_ptr());
+                value_constructed_ = false;
+            }
+        }
+    }
+
+    ///////////////////////////////////////////////////////////////////
+    //
+    // Bucket
+
+    template <typename NodePointer>
+    struct bucket
+    {
+        typedef NodePointer previous_pointer;
+        previous_pointer next_;
+
+        bucket() : next_() {}
+
+        previous_pointer first_from_start()
+        {
+            return next_;
+        }
+
+        enum { extra_node = true };
+    };
+
+    struct ptr_bucket
+    {
+        typedef ptr_bucket* previous_pointer;
+        previous_pointer next_;
+
+        ptr_bucket() : next_(0) {}
+
+        previous_pointer first_from_start()
+        {
+            return this;
+        }
+
+        enum { extra_node = false };
+    };
+
+    ///////////////////////////////////////////////////////////////////
+    //
+    // Buckets
+
+    template <typename A, typename Bucket, typename Node>
+    struct buckets
+    {
+    private:
+        buckets(buckets const&);
+        buckets& operator=(buckets const&);
+    public:
+        typedef boost::unordered::detail::allocator_traits<A> traits;
+        typedef typename traits::value_type value_type;
+
+        typedef Node node;
+        typedef Bucket bucket;
+        typedef typename boost::unordered::detail::rebind_wrap<A, node>::type
+            node_allocator;
+        typedef typename boost::unordered::detail::rebind_wrap<A, bucket>::type
+            bucket_allocator;
+        typedef boost::unordered::detail::allocator_traits<node_allocator>
+            node_allocator_traits;
+        typedef boost::unordered::detail::allocator_traits<bucket_allocator>
+            bucket_allocator_traits;
+        typedef typename node_allocator_traits::pointer
+            node_pointer;
+        typedef typename node_allocator_traits::const_pointer
+            const_node_pointer;
+        typedef typename bucket_allocator_traits::pointer
+            bucket_pointer;
+        typedef typename bucket::previous_pointer
+            previous_pointer;
+        typedef boost::unordered::detail::node_constructor<node_allocator>
+            node_constructor;
+
+        // Members
+
+        bucket_pointer buckets_;
+        std::size_t bucket_count_;
+        std::size_t size_;
+        boost::unordered::detail::compressed<bucket_allocator, node_allocator>
+            allocators_;
+
+        // Data access
+
+        bucket_allocator const& bucket_alloc() const
+        {
+            return allocators_.first();
+        }
+
+        node_allocator const& node_alloc() const
+        {
+            return allocators_.second();
+        }
+
+        bucket_allocator& bucket_alloc()
+        {
+            return allocators_.first();
+        }
+
+        node_allocator& node_alloc()
+        {
+            return allocators_.second();
+        }
+
+        std::size_t max_bucket_count() const
+        {
+            // -1 to account for the start bucket.
+            return boost::unordered::detail::prev_prime(
+                bucket_allocator_traits::max_size(bucket_alloc()) - 1);
+        }
+
+        bucket_pointer get_bucket(std::size_t bucket_index) const
+        {
+            return buckets_ + static_cast<std::ptrdiff_t>(bucket_index);
+        }
+
+        previous_pointer get_previous_start() const
+        {
+            return this->get_bucket(this->bucket_count_)->first_from_start();
+        }
+
+        previous_pointer get_previous_start(std::size_t bucket_index) const
+        {
+            return this->get_bucket(bucket_index)->next_;
+        }
+
+        node_pointer get_start() const
+        {
+            return static_cast<node_pointer>(this->get_previous_start()->next_);
+        }
+
+        node_pointer get_start(std::size_t bucket_index) const
+        {
+            previous_pointer prev = this->get_previous_start(bucket_index);
+            return prev ? static_cast<node_pointer>(prev->next_) :
+                node_pointer();
+        }
+
+        float load_factor() const
+        {
+            BOOST_ASSERT(this->bucket_count_ != 0);
+            return static_cast<float>(this->size_)
+                / static_cast<float>(this->bucket_count_);
+        }
+
+        std::size_t bucket_size(std::size_t index) const
+        {
+            if (!this->size_) return 0;
+            node_pointer ptr = this->get_start(index);
+            if (!ptr) return 0;
+
+            std::size_t count = 0;
+            while(ptr && ptr->hash_ % this->bucket_count_ == index)
+            {
+                ++count;
+                ptr = static_cast<node_pointer>(ptr->next_);
+            }
+
+            return count;
+        }
+
+        ////////////////////////////////////////////////////////////////////////
+        // Constructors
+
+        buckets(node_allocator const& a, std::size_t bucket_count) :
+            buckets_(),
+            bucket_count_(bucket_count),
+            size_(),
+            allocators_(a,a)
+        {
+        }
+
+        buckets(buckets& b, boost::unordered::detail::move_tag m) :
+            buckets_(),
+            bucket_count_(b.bucket_count_),
+            size_(),
+            allocators_(b.allocators_, m)
+        {
+            swap(b);
+        }
+
+        template <typename Types>
+        buckets(boost::unordered::detail::table<Types>& x,
+                boost::unordered::detail::move_tag m) :
+            buckets_(),
+            bucket_count_(x.bucket_count_),
+            size_(),
+            allocators_(x.allocators_, m)
+        {
+            swap(x);
+        }
+
+        ////////////////////////////////////////////////////////////////////////
+        // Create buckets
+        // (never called in constructor to avoid exception issues)
+
+        void create_buckets()
+        {
+            boost::unordered::detail::array_constructor<bucket_allocator>
+                constructor(bucket_alloc());
+    
+            // Creates an extra bucket to act as the start node.
+            constructor.construct(bucket(), this->bucket_count_ + 1);
+    
+            if (bucket::extra_node)
+            {
+                node_constructor a(this->node_alloc());
+                a.construct_node();
+
+                (constructor.get() +
+                    static_cast<std::ptrdiff_t>(this->bucket_count_))->next_ =
+                        a.release();
+            }
+
+            this->buckets_ = constructor.release();
+        }
+
+        ////////////////////////////////////////////////////////////////////////
+        // Swap and Move
+
+        void swap(buckets& other, false_type = false_type())
+        {
+            BOOST_ASSERT(node_alloc() == other.node_alloc());
+            boost::swap(buckets_, other.buckets_);
+            boost::swap(bucket_count_, other.bucket_count_);
+            boost::swap(size_, other.size_);
+        }
+
+        void swap(buckets& other, true_type)
+        {
+            allocators_.swap(other.allocators_);
+            boost::swap(buckets_, other.buckets_);
+            boost::swap(bucket_count_, other.bucket_count_);
+            boost::swap(size_, other.size_);
+        }
+
+        void move_buckets_from(buckets& other)
+        {
+            BOOST_ASSERT(node_alloc() == other.node_alloc());
+            BOOST_ASSERT(!this->buckets_);
+            this->buckets_ = other.buckets_;
+            this->bucket_count_ = other.bucket_count_;
+            this->size_ = other.size_;
+            other.buckets_ = bucket_pointer();
+            other.bucket_count_ = 0;
+            other.size_ = 0;
+        }
+
+        ////////////////////////////////////////////////////////////////////////
+        // Delete/destruct
+
+        inline void delete_node(node_pointer n)
+        {
+            boost::unordered::detail::destroy(n->value_ptr());
+            node_allocator_traits::destroy(node_alloc(), boost::addressof(*n));
+            node_allocator_traits::deallocate(node_alloc(), n, 1);
+            --size_;
+        }
+
+        std::size_t delete_nodes(node_pointer begin, node_pointer end)
+        {
+            std::size_t count = 0;
+
+            while(begin != end) {
+                node_pointer n = begin;
+                begin = static_cast<node_pointer>(begin->next_);
+                delete_node(n);
+                ++count;
+            }
+
+            return count;
+        }
+
+        inline void delete_extra_node(bucket_pointer) {}
+
+        inline void delete_extra_node(node_pointer n) {
+            node_allocator_traits::destroy(node_alloc(), boost::addressof(*n));
+            node_allocator_traits::deallocate(node_alloc(), n, 1);
+        }
+
+        inline ~buckets()
+        {
+            this->delete_buckets();
+        }
+
+        void delete_buckets()
+        {
+            if(this->buckets_) {
+                previous_pointer prev = this->get_previous_start();
+
+                while(prev->next_) {
+                    node_pointer n = static_cast<node_pointer>(prev->next_);
+                    prev->next_ = n->next_;
+                    delete_node(n);
+                }
+
+                delete_extra_node(prev);
+
+                bucket_pointer end = this->get_bucket(this->bucket_count_ + 1);
+                for(bucket_pointer it = this->buckets_; it != end; ++it)
+                {
+                    bucket_allocator_traits::destroy(bucket_alloc(),
+                        boost::addressof(*it));
+                }
+
+                bucket_allocator_traits::deallocate(bucket_alloc(),
+                    this->buckets_, this->bucket_count_ + 1);
+    
+                this->buckets_ = bucket_pointer();
+            }
+
+            BOOST_ASSERT(!this->size_);
+        }
+
+        void clear()
+        {
+            if(!this->size_) return;
+
+            previous_pointer prev = this->get_previous_start();
+
+            while(prev->next_) {
+                node_pointer n = static_cast<node_pointer>(prev->next_);
+                prev->next_ = n->next_;
+                delete_node(n);
+            }
+
+            bucket_pointer end = this->get_bucket(this->bucket_count_);
+            for(bucket_pointer it = this->buckets_; it != end; ++it)
+            {
+                it->next_ = node_pointer();
+            }
+
+            BOOST_ASSERT(!this->size_);
+        }
+
+        // This is called after erasing a node or group of nodes to fix up
+        // the bucket pointers.
+        void fix_buckets(bucket_pointer bucket,
+                previous_pointer prev, node_pointer next)
+        {
+            if (!next)
+            {
+                if (bucket->next_ == prev) bucket->next_ = node_pointer();
+            }
+            else
+            {
+                bucket_pointer next_bucket = this->get_bucket(
+                    next->hash_ % this->bucket_count_);
+
+                if (next_bucket != bucket)
+                {
+                    next_bucket->next_ = prev;
+                    if (bucket->next_ == prev) bucket->next_ = node_pointer();
+                }
+            }
+        }
+
+        // This is called after erasing a range of nodes to fix any bucket
+        // pointers into that range.
+        void fix_buckets_range(std::size_t bucket_index,
+                previous_pointer prev, node_pointer begin, node_pointer end)
+        {
+            node_pointer n = begin;
+    
+            // If we're not at the start of the current bucket, then
+            // go to the start of the next bucket.
+            if (this->get_bucket(bucket_index)->next_ != prev)
+            {
+                for(;;) {
+                    n = static_cast<node_pointer>(n->next_);
+                    if (n == end) return;
+    
+                    std::size_t new_bucket_index =
+                        n->hash_ % this->bucket_count_;
+                    if (bucket_index != new_bucket_index) {
+                        bucket_index = new_bucket_index;
+                        break;
+                    }
+                }
+            }
+    
+            // Iterate through the remaining nodes, clearing out the bucket
+            // pointers.
+            this->get_bucket(bucket_index)->next_ = previous_pointer();
+            for(;;) {
+                n = static_cast<node_pointer>(n->next_);
+                if (n == end) break;
+    
+                std::size_t new_bucket_index =
+                    n->hash_ % this->bucket_count_;
+                if (bucket_index != new_bucket_index) {
+                    bucket_index = new_bucket_index;
+                    this->get_bucket(bucket_index)->next_ = previous_pointer();
+                }
+            };
+    
+            // Finally fix the bucket containing the trailing node.
+            if (n) {
+                this->get_bucket(n->hash_ % this->bucket_count_)->next_
+                    = prev;
+            }
+        }
+    };
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Functions
+
+    // Assigning and swapping the equality and hash function objects
+    // needs strong exception safety. To implement that normally we'd
+    // require one of them to be known to not throw and the other to
+    // guarantee strong exception safety. Unfortunately they both only
+    // have basic exception safety. So to acheive strong exception
+    // safety we have storage space for two copies, and assign the new
+    // copies to the unused space. Then switch to using that to use
+    // them. This is implemented in 'set_hash_functions' which
+    // atomically assigns the new function objects in a strongly
+    // exception safe manner.
+
+    template <class H, class P> class set_hash_functions;
+
+    template <class H, class P>
+    class functions
+    {
+        friend class boost::unordered::detail::set_hash_functions<H, P>;
+        functions& operator=(functions const&);
+
+        typedef compressed<H, P> function_pair;
+
+        typedef typename boost::aligned_storage<
+            sizeof(function_pair),
+            boost::alignment_of<function_pair>::value>::type aligned_function;
+
+        bool current_; // The currently active functions.
+        aligned_function funcs_[2];
+
+        function_pair const& current() const {
+            return *static_cast<function_pair const*>(
+                static_cast<void const*>(&funcs_[current_]));
+        }
+
+        void construct(bool which, H const& hf, P const& eq)
+        {
+            new((void*) &funcs_[which]) function_pair(hf, eq);
+        }
+
+        void construct(bool which, function_pair const& f)
+        {
+            new((void*) &funcs_[which]) function_pair(f);
+        }
+        
+        void destroy(bool which)
+        {
+            boost::unordered::detail::destroy((function_pair*)(&funcs_[which]));
+        }
+        
+    public:
+
+        functions(H const& hf, P const& eq)
+            : current_(false)
+        {
+            construct(current_, hf, eq);
+        }
+
+        functions(functions const& bf)
+            : current_(false)
+        {
+            construct(current_, bf.current());
+        }
+
+        ~functions() {
+            this->destroy(current_);
+        }
+
+        H const& hash_function() const {
+            return current().first();
+        }
+
+        P const& key_eq() const {
+            return current().second();
+        }
+    };
+    
+    template <class H, class P>
+    class set_hash_functions
+    {
+        set_hash_functions(set_hash_functions const&);
+        set_hash_functions& operator=(set_hash_functions const&);
+    
+        functions<H,P>& functions_;
+        bool tmp_functions_;
+
+    public:
+
+        set_hash_functions(functions<H,P>& f, H const& h, P const& p)
+          : functions_(f),
+            tmp_functions_(!f.current_)
+        {
+            f.construct(tmp_functions_, h, p);
+        }
+
+        set_hash_functions(functions<H,P>& f, functions<H,P> const& other)
+          : functions_(f),
+            tmp_functions_(!f.current_)
+        {
+            f.construct(tmp_functions_, other.current());
+        }
+
+        ~set_hash_functions()
+        {
+            functions_.destroy(tmp_functions_);
+        }
+
+        void commit()
+        {
+            functions_.current_ = tmp_functions_;
+            tmp_functions_ = !tmp_functions_;
+        }
+    };
+}}}
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
+
+#endif

include/boost/unordered/detail/config.hpp

@@ -1,22 +0,0 @@
-
-// 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)
-
-#if !defined(BOOST_UNORDERED_DETAIL_CONFIG_HEADER)
-#define BOOST_UNORDERED_DETAIL_CONFIG_HEADER
-
-#include <boost/config.hpp>
-
-#if defined(BOOST_NO_SFINAE)
-#  define BOOST_UNORDERED_NO_HAS_MOVE_ASSIGN
-#elif defined(__GNUC__) && \
-    (__GNUC__ < 3 || __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
-#  define BOOST_UNORDERED_NO_HAS_MOVE_ASSIGN
-#elif BOOST_WORKAROUND(BOOST_INTEL, < 900) || \
-    BOOST_WORKAROUND(__EDG_VERSION__, < 304) || \
-    BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0593))
-#  define BOOST_UNORDERED_NO_HAS_MOVE_ASSIGN
-#endif
-
-#endif

include/boost/unordered/detail/emplace_args.hpp

@@ -0,0 +1,480 @@
+
+// Copyright (C) 2011 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)
+
+//  See http://www.boost.org/libs/unordered for documentation
+
+#ifndef BOOST_UNORDERED_EMPLACE_ARGS_HPP
+#define BOOST_UNORDERED_EMPLACE_ARGS_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/move/move.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/inc.hpp>
+#include <boost/preprocessor/dec.hpp>
+#include <boost/preprocessor/repetition/enum.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/type_traits/is_class.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <utility>
+
+#if !defined(BOOST_NO_0X_HDR_TUPLE)
+#include <tuple>
+#endif
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+#pragma warning(disable:4512) // assignment operator could not be generated.
+#pragma warning(disable:4345) // behavior change: an object of POD type
+                              // constructed with an initializer of the form ()
+                              // will be default-initialized.
+#endif
+
+#define BOOST_UNORDERED_EMPLACE_LIMIT 10
+
+#if !defined(BOOST_NO_RVALUE_REFERENCES) && \
+        !defined(BOOST_NO_VARIADIC_TEMPLATES)
+#define BOOST_UNORDERED_VARIADIC_MOVE
+#endif
+
+namespace boost { namespace unordered { namespace detail {
+
+    ////////////////////////////////////////////////////////////////////////////
+    // emplace_args
+    //
+    // Either forwarding variadic arguments, or storing the arguments in
+    // emplace_args##n
+
+#if defined(BOOST_UNORDERED_VARIADIC_MOVE)
+
+#define BOOST_UNORDERED_EMPLACE_TEMPLATE typename... Args
+#define BOOST_UNORDERED_EMPLACE_ARGS Args&&... args
+#define BOOST_UNORDERED_EMPLACE_FORWARD boost::forward<Args>(args)...
+
+#else
+
+#define BOOST_UNORDERED_EMPLACE_TEMPLATE typename Args
+#define BOOST_UNORDERED_EMPLACE_ARGS Args const& args
+#define BOOST_UNORDERED_EMPLACE_FORWARD args
+
+#define BOOST_UNORDERED_FWD_PARAM(z, n, a) \
+    BOOST_FWD_REF(BOOST_PP_CAT(A, n)) BOOST_PP_CAT(a, n)
+
+#define BOOST_UNORDERED_CALL_FORWARD(z, i, a) \
+    boost::forward<BOOST_PP_CAT(A,i)>(BOOST_PP_CAT(a,i))
+
+#define BOOST_UNORDERED_EARGS(z, n, _)                                      \
+    template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                     \
+    struct BOOST_PP_CAT(emplace_args, n)                                    \
+    {                                                                       \
+        BOOST_PP_REPEAT_##z(n, BOOST_UNORDERED_EARGS_MEMBER, _)             \
+        BOOST_PP_CAT(emplace_args, n) (                                     \
+            BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, Arg, a)                     \
+        ) : BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_EARGS_INIT, _)             \
+        {}                                                                  \
+                                                                            \
+    };                                                                      \
+                                                                            \
+    template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                     \
+    inline BOOST_PP_CAT(emplace_args, n) <                                  \
+        BOOST_PP_ENUM_PARAMS_Z(z, n, A)                                     \
+    > create_emplace_args(                                                  \
+        BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a)                  \
+    )                                                                       \
+    {                                                                       \
+        BOOST_PP_CAT(emplace_args, n) <                                     \
+            BOOST_PP_ENUM_PARAMS_Z(z, n, A)                                 \
+        > e(BOOST_PP_ENUM_PARAMS_Z(z, n, a));                               \
+        return e;                                                           \
+    }
+
+#if defined(BOOST_NO_RVALUE_REFERENCES)
+
+#define BOOST_UNORDERED_EARGS_MEMBER(z, n, _)                               \
+    typedef BOOST_FWD_REF(BOOST_PP_CAT(A, n)) BOOST_PP_CAT(Arg, n);         \
+    BOOST_PP_CAT(Arg, n) BOOST_PP_CAT(a, n);
+
+#define BOOST_UNORDERED_EARGS_INIT(z, n, _)                                 \
+    BOOST_PP_CAT(a, n)(                                                     \
+        boost::forward<BOOST_PP_CAT(A,n)>(BOOST_PP_CAT(a, n)))
+
+#else
+
+#define BOOST_UNORDERED_EARGS_MEMBER(z, n, _)                               \
+    typedef typename boost::add_lvalue_reference<BOOST_PP_CAT(A, n)>::type  \
+        BOOST_PP_CAT(Arg, n);                                               \
+    BOOST_PP_CAT(Arg, n) BOOST_PP_CAT(a, n);
+
+#define BOOST_UNORDERED_EARGS_INIT(z, n, _)                                 \
+    BOOST_PP_CAT(a, n)(BOOST_PP_CAT(a, n))
+
+#endif
+
+BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT, BOOST_UNORDERED_EARGS,
+    _)
+
+#undef BOOST_UNORDERED_DEFINE_EMPLACE_ARGS
+#undef BOOST_UNORDERED_EARGS_MEMBER
+#undef BOOST_UNORDERED_EARGS_INIT
+
+#endif
+
+    ////////////////////////////////////////////////////////////////////////////
+    // rvalue parameters when type can't be a BOOST_RV_REF(T) parameter
+    // e.g. for int
+
+#if !defined(BOOST_NO_RVALUE_REFERENCES)
+#   define BOOST_UNORDERED_RV_REF(T) BOOST_RV_REF(T)
+#else
+    struct please_ignore_this_overload {
+        typedef please_ignore_this_overload type;
+    };
+
+    template <typename T>
+    struct rv_ref_impl {
+        typedef BOOST_RV_REF(T) type;
+    };
+
+    template <typename T>
+    struct rv_ref :
+        boost::detail::if_true<
+            boost::is_class<T>::value
+        >::BOOST_NESTED_TEMPLATE then <
+            boost::unordered::detail::rv_ref_impl<T>,
+            please_ignore_this_overload
+        >::type
+    {};
+
+#   define BOOST_UNORDERED_RV_REF(T) \
+        typename boost::unordered::detail::rv_ref<T>::type
+#endif
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Construct from tuple
+    //
+    // Used for piecewise construction.
+
+#if !BOOST_WORKAROUND(__SUNPRO_CC, <= 0x590)
+
+#define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(n, namespace_)                 \
+    template<typename T>                                                    \
+    void construct_from_tuple(T* ptr, namespace_::tuple<>)                  \
+    {                                                                       \
+        new ((void*) ptr) T();                                              \
+    }                                                                       \
+                                                                            \
+    BOOST_PP_REPEAT_FROM_TO(1, n,                                           \
+        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL, namespace_)
+
+#define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL(z, n, namespace_)         \
+    template<typename T, BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>          \
+    void construct_from_tuple(T* ptr,                                       \
+            namespace_::tuple<BOOST_PP_ENUM_PARAMS_Z(z, n, A)> const& x)    \
+    {                                                                       \
+        new ((void*) ptr) T(                                                \
+            BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_GET_TUPLE_ARG, namespace_) \
+        );                                                                  \
+    }
+
+#define BOOST_UNORDERED_GET_TUPLE_ARG(z, n, namespace_)                     \
+    namespace_::get<n>(x)
+
+BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, boost)
+
+#if !defined(BOOST_NO_0X_HDR_TUPLE)
+BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, std)
+#endif
+
+#undef BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE
+#undef BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL
+#undef BOOST_UNORDERED_GET_TUPLE_ARG
+
+#else
+
+    template <int N> struct length {};
+
+    template<typename T>
+    void construct_from_tuple_impl(
+            boost::unordered::detail::length<0>, T* ptr,
+            boost::tuple<>)
+    {
+        new ((void*) ptr) T();
+    }
+
+#define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL(z, n, _)                  \
+    template<typename T, BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>          \
+    void construct_from_tuple_impl(                                         \
+            boost::unordered::detail::length<n>, T* ptr,                    \
+            namespace_::tuple<BOOST_PP_ENUM_PARAMS_Z(z, n, A)> const& x)    \
+    {                                                                       \
+        new ((void*) ptr) T(                                                \
+            BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_GET_TUPLE_ARG, namespace_) \
+        );                                                                  \
+    }
+
+#define BOOST_UNORDERED_GET_TUPLE_ARG(z, n, _)                              \
+    boost::get<n>(x)
+
+    BOOST_PP_REPEAT_FROM_TO(1, 10,                                          \
+        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL, _)
+
+    template <typename T, typename Tuple>
+    void construct_from_tuple(T* ptr, Tuple const& x)
+    {
+        construct_from_tuple_impl(
+            boost::unordered::detail::length<
+                boost::tuples::length<Tuple>::value>(),
+            ptr, x);
+    }
+
+#undef BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL
+#undef BOOST_UNORDERED_GET_TUPLE_ARG
+
+#endif
+
+    ////////////////////////////////////////////////////////////////////////////
+    // SFINAE traits for construction.
+
+    // Decide which construction method to use for a three argument
+    // call. Note that this is difficult to do using overloads because
+    // the arguments are packed into 'emplace_args3'.
+    //
+    // The decision is made on the first argument.
+
+
+#if defined(BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT)
+    template <typename A, typename B, typename A0>
+    struct emulation1 {
+        static choice1::type test(choice1, std::pair<A, B> const&);
+        static choice2::type test(choice2, A const&);
+        static choice3::type test(choice3, convert_from_anything const&);
+
+        enum { value =
+            sizeof(test(choose(), boost::unordered::detail::make<A0>())) ==
+                sizeof(choice2::type) };
+    };
+#endif
+
+    template <typename A, typename B, typename A0>
+    struct check3_base {
+        static choice1::type test(choice1,
+            boost::unordered::piecewise_construct_t);
+
+#if defined(BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT)
+        static choice2::type test(choice2, A const&);
+#endif
+
+        static choice3::type test(choice3, ...);
+
+        enum { value =
+            sizeof(test(choose(), boost::unordered::detail::make<A0>())) };
+    };
+
+    template <typename A, typename B, typename A0>
+    struct piecewise3 {
+        enum { value = check3_base<A,B,A0>::value == sizeof(choice1::type) };
+    };
+
+#if defined(BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT)
+    template <typename A, typename B, typename A0>
+    struct emulation3 {
+        enum { value = check3_base<A,B,A0>::value == sizeof(choice2::type) };
+    };
+
+#endif
+
+#if defined(BOOST_UNORDERED_VARIADIC_MOVE)
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Construct from variadic parameters
+
+    template <typename T, typename... Args>
+    inline void construct_impl(T* address, Args&&... args)
+    {
+        new((void*) address) T(boost::forward<Args>(args)...);
+    }
+
+    template <typename A, typename B, typename A0, typename A1, typename A2>
+    inline typename enable_if<piecewise3<A, B, A0>, void>::type
+        construct_impl(std::pair<A, B>* address, A0&&, A1&& a1, A2&& a2)
+    {
+        boost::unordered::detail::construct_from_tuple(
+            boost::addressof(address->first), a1);
+        boost::unordered::detail::construct_from_tuple(
+            boost::addressof(address->second), a2);
+    }
+
+#if defined(BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT)
+
+    template <typename A, typename B, typename A0>
+    inline typename enable_if<emulation1<A, B, A0>, void>::type
+        construct_impl(std::pair<A, B>* address, A0&& a0)
+    {
+        new((void*) boost::addressof(address->first)) A(boost::forward<A0>(a0));
+        new((void*) boost::addressof(address->second)) B();
+   }
+
+    template <typename A, typename B, typename A0, typename A1, typename A2>
+    inline typename enable_if<emulation3<A, B, A0>, void>::type
+        construct_impl(std::pair<A, B>* address, A0&& a0, A1&& a1, A2&& a2)
+    {
+        new((void*) boost::addressof(address->first)) A(boost::forward<A0>(a0));
+        new((void*) boost::addressof(address->second)) B(
+            boost::forward<A1>(a1),
+            boost::forward<A2>(a2));
+    }
+
+    template <typename A, typename B,
+            typename A0, typename A1, typename A2, typename A3,
+            typename... Args>
+    inline void construct_impl(std::pair<A, B>* address,
+            A0&& a0, A1&& a1, A2&& a2, A3&& a3, Args&&... args)
+    {
+        new((void*) boost::addressof(address->first)) A(boost::forward<A0>(a0));
+
+        new((void*) boost::addressof(address->second)) B(
+            boost::forward<A1>(a1),
+            boost::forward<A2>(a2),
+            boost::forward<A3>(a3),
+            boost::forward<Args>(args)...);
+    }
+
+#endif // BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT
+#else // BOOST_UNORDERED_VARIADIC_MOVE
+
+////////////////////////////////////////////////////////////////////////////////
+// Construct from emplace_args
+
+#define BOOST_UNORDERED_CONSTRUCT_IMPL(z, num_params, _)                    \
+    template <                                                              \
+        typename T,                                                         \
+        BOOST_PP_ENUM_PARAMS_Z(z, num_params, typename A)                   \
+    >                                                                       \
+    inline void construct_impl(T* address,                                  \
+        boost::unordered::detail::BOOST_PP_CAT(emplace_args,num_params) <   \
+            BOOST_PP_ENUM_PARAMS_Z(z, num_params, A)                        \
+        > const& args)                                                      \
+    {                                                                       \
+        new((void*) address) T(                                             \
+            BOOST_PP_ENUM_##z(num_params, BOOST_UNORDERED_CALL_FORWARD,     \
+                args.a));                                                   \
+    }
+
+    template <typename T, typename A0>
+    inline void construct_impl(T* address, emplace_args1<A0> const& args)
+    {
+        new((void*) address) T(boost::forward<A0>(args.a0));
+    }
+
+    template <typename T, typename A0, typename A1>
+    inline void construct_impl(T* address, emplace_args2<A0, A1> const& args)
+    {
+        new((void*) address) T(
+            boost::forward<A0>(args.a0),
+            boost::forward<A1>(args.a1)
+        );
+    }
+
+    template <typename T, typename A0, typename A1, typename A2>
+    inline void construct_impl(T* address, emplace_args3<A0, A1, A2> const& args)
+    {
+        new((void*) address) T(
+            boost::forward<A0>(args.a0),
+            boost::forward<A1>(args.a1),
+            boost::forward<A2>(args.a2)
+        );
+    }
+
+    BOOST_PP_REPEAT_FROM_TO(4, BOOST_UNORDERED_EMPLACE_LIMIT,
+        BOOST_UNORDERED_CONSTRUCT_IMPL, _)
+
+#undef BOOST_UNORDERED_CONSTRUCT_IMPL
+
+    template <typename A, typename B, typename A0, typename A1, typename A2>
+    inline typename enable_if<piecewise3<A, B, A0>, void>::type
+        construct_impl(std::pair<A, B>* address,
+            boost::unordered::detail::emplace_args3<A0, A1, A2> const& args)
+    {
+        boost::unordered::detail::construct_from_tuple(
+            boost::addressof(address->first), args.a1);
+        boost::unordered::detail::construct_from_tuple(
+            boost::addressof(address->second), args.a2);
+    }
+
+#if defined(BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT)
+
+    template <typename A, typename B, typename A0>
+    inline typename enable_if<emulation1<A, B, A0>, void>::type
+        construct_impl(std::pair<A, B>* address,
+            boost::unordered::detail::emplace_args1<A0> const& args)
+    {
+        new((void*) boost::addressof(address->first)) A(
+            boost::forward<A0>(args.a0));
+        new((void*) boost::addressof(address->second)) B();
+    }
+
+    template <typename A, typename B, typename A0, typename A1, typename A2>
+    inline typename enable_if<emulation3<A, B, A0>, void>::type
+        construct_impl(std::pair<A, B>* address,
+            boost::unordered::detail::emplace_args3<A0, A1, A2> const& args)
+    {
+        new((void*) boost::addressof(address->first)) A(
+            boost::forward<A0>(args.a0));
+        new((void*) boost::addressof(address->second)) B(
+            boost::forward<A1>(args.a1),
+            boost::forward<A2>(args.a2));
+    }
+
+#define BOOST_UNORDERED_CONSTRUCT_PAIR_IMPL(z, num_params, _)               \
+    template <typename A, typename B,                                       \
+        BOOST_PP_ENUM_PARAMS_Z(z, num_params, typename A)                   \
+    >                                                                       \
+    inline void construct_impl(std::pair<A, B>* address,                    \
+        boost::unordered::detail::BOOST_PP_CAT(emplace_args, num_params) <  \
+                BOOST_PP_ENUM_PARAMS_Z(z, num_params, A)                    \
+            > const& args)                                                  \
+    {                                                                       \
+        new((void*) boost::addressof(address->first)) A(                    \
+            boost::forward<A0>(args.a0));                                   \
+        new((void*) boost::addressof(address->second)) B(                   \
+            BOOST_PP_ENUM_##z(BOOST_PP_DEC(num_params),                     \
+                BOOST_UNORDERED_CALL_FORWARD2, args.a));                    \
+    }
+
+#define BOOST_UNORDERED_CALL_FORWARD2(z, i, a) \
+    BOOST_UNORDERED_CALL_FORWARD(z, BOOST_PP_INC(i), a)
+
+    BOOST_UNORDERED_CONSTRUCT_PAIR_IMPL(1, 2, _)
+    BOOST_PP_REPEAT_FROM_TO(4, BOOST_UNORDERED_EMPLACE_LIMIT,
+        BOOST_UNORDERED_CONSTRUCT_PAIR_IMPL, _)
+
+#undef BOOST_UNORDERED_CONSTRUCT_PAIR_IMPL
+#undef BOOST_UNORDERED_CALL_FORWARD2
+
+#endif // BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT
+#endif // BOOST_UNORDERED_VARIADIC_MOVE
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Construct without using the emplace args mechanism.
+
+    template <typename T, typename A0>
+    inline void construct_impl2(T* address, BOOST_FWD_REF(A0) a0)
+    {
+        new((void*) address) T(
+            boost::forward<A0>(a0)
+        );
+    }
+
+}}}
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
+
+#endif

include/boost/unordered/detail/equivalent.hpp

@@ -0,0 +1,829 @@
+
+// Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
+// Copyright (C) 2005-2011 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)
+
+#ifndef BOOST_UNORDERED_DETAIL_EQUIVALENT_HPP_INCLUDED
+#define BOOST_UNORDERED_DETAIL_EQUIVALENT_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/unordered/detail/table.hpp>
+#include <boost/unordered/detail/emplace_args.hpp>
+#include <boost/unordered/detail/extract_key.hpp>
+
+namespace boost { namespace unordered { namespace detail {
+
+    template <typename A, typename T> struct grouped_node;
+    template <typename T> struct grouped_ptr_node;
+    template <typename Types> struct grouped_table_impl;
+
+    template <typename A, typename T>
+    struct grouped_node :
+        boost::unordered::detail::value_base<T>
+    {
+        typedef typename ::boost::unordered::detail::rebind_wrap<
+            A, grouped_node<A, T> >::type::pointer link_pointer;
+
+        link_pointer next_;
+        link_pointer group_prev_;
+        std::size_t hash_;
+
+        grouped_node() :
+            next_(),
+            group_prev_(),
+            hash_(0)
+        {}
+
+        void init(link_pointer self)
+        {
+            group_prev_ = self;
+        }
+    };
+
+    template <typename T>
+    struct grouped_ptr_node :
+        boost::unordered::detail::value_base<T>,
+        boost::unordered::detail::ptr_bucket
+    {
+        typedef boost::unordered::detail::ptr_bucket bucket_base;
+        typedef ptr_bucket* link_pointer;
+
+        link_pointer group_prev_;
+        std::size_t hash_;
+
+        grouped_ptr_node() :
+            bucket_base(),
+            group_prev_(0),
+            hash_(0)
+        {}
+
+        void init(link_pointer self)
+        {
+            group_prev_ = self;
+        }
+    };
+
+    // If the allocator uses raw pointers use grouped_ptr_node
+    // Otherwise use grouped_node.
+
+    template <typename A, typename T, typename NodePtr, typename BucketPtr>
+    struct pick_grouped_node2
+    {
+        typedef boost::unordered::detail::grouped_node<A, T> node;
+
+        typedef typename boost::unordered::detail::allocator_traits<
+            typename boost::unordered::detail::rebind_wrap<A, node>::type
+        >::pointer node_pointer;
+
+        typedef boost::unordered::detail::bucket<node_pointer> bucket;
+        typedef node_pointer link_pointer;
+    };
+
+    template <typename A, typename T>
+    struct pick_grouped_node2<A, T,
+        boost::unordered::detail::grouped_ptr_node<T>*,
+        boost::unordered::detail::ptr_bucket*>
+    {
+        typedef boost::unordered::detail::grouped_ptr_node<T> node;
+        typedef boost::unordered::detail::ptr_bucket bucket;
+        typedef bucket* link_pointer;
+    };
+
+    template <typename A, typename T>
+    struct pick_grouped_node
+    {
+        typedef boost::unordered::detail::allocator_traits<
+            typename boost::unordered::detail::rebind_wrap<A,
+                boost::unordered::detail::grouped_ptr_node<T> >::type
+        > tentative_node_traits;
+
+        typedef boost::unordered::detail::allocator_traits<
+            typename boost::unordered::detail::rebind_wrap<A,
+                boost::unordered::detail::ptr_bucket >::type
+        > tentative_bucket_traits;
+
+        typedef pick_grouped_node2<A, T,
+            typename tentative_node_traits::pointer,
+            typename tentative_bucket_traits::pointer> pick;
+
+        typedef typename pick::node node;
+        typedef typename pick::bucket bucket;
+        typedef typename pick::link_pointer link_pointer;
+    };
+
+    template <typename A, typename T, typename H, typename P>
+    struct multiset
+    {
+        typedef boost::unordered::detail::multiset<A, T, H, P> types;
+
+        typedef T value_type;
+        typedef H hasher;
+        typedef P key_equal;
+        typedef T key_type;
+
+        typedef typename boost::unordered::detail::rebind_wrap<
+                A, value_type>::type allocator;
+
+        typedef boost::unordered::detail::allocator_traits<allocator> traits;
+        typedef boost::unordered::detail::pick_grouped_node<allocator, value_type> pick;
+        typedef typename pick::node node;
+        typedef typename pick::bucket bucket;
+        typedef typename pick::link_pointer link_pointer;
+
+        typedef boost::unordered::detail::grouped_table_impl<types> table;
+        typedef boost::unordered::detail::set_extractor<value_type> extractor;
+    };
+
+    template <typename A, typename K, typename M, typename H, typename P>
+    struct multimap
+    {
+        typedef boost::unordered::detail::multimap<A, K, M, H, P> types;
+
+        typedef std::pair<K const, M> value_type;
+        typedef H hasher;
+        typedef P key_equal;
+        typedef K key_type;
+
+        typedef typename boost::unordered::detail::rebind_wrap<
+                A, value_type>::type allocator;
+
+        typedef boost::unordered::detail::allocator_traits<allocator> traits;
+        typedef boost::unordered::detail::pick_grouped_node<allocator, value_type> pick;
+        typedef typename pick::node node;
+        typedef typename pick::bucket bucket;
+        typedef typename pick::link_pointer link_pointer;
+
+        typedef boost::unordered::detail::grouped_table_impl<types> table;
+        typedef boost::unordered::detail::map_extractor<key_type, value_type>
+            extractor;
+    };
+
+    template <typename Types>
+    struct grouped_table_impl : boost::unordered::detail::table<Types>
+    {
+        typedef boost::unordered::detail::table<Types> table;
+        typedef typename table::value_type value_type;
+        typedef typename table::bucket bucket;
+        typedef typename table::buckets buckets;
+        typedef typename table::node_pointer node_pointer;
+        typedef typename table::node_allocator node_allocator;
+        typedef typename table::node_allocator_traits node_allocator_traits;
+        typedef typename table::bucket_pointer bucket_pointer;
+        typedef typename table::link_pointer link_pointer;
+        typedef typename table::previous_pointer previous_pointer;
+        typedef typename table::hasher hasher;
+        typedef typename table::key_equal key_equal;
+        typedef typename table::key_type key_type;
+        typedef typename table::node_constructor node_constructor;
+        typedef typename table::extractor extractor;
+        typedef typename table::iterator iterator;
+
+        // Constructors
+
+        grouped_table_impl(std::size_t n,
+                hasher const& hf,
+                key_equal const& eq,
+                node_allocator const& a)
+          : table(n, hf, eq, a)
+        {}
+
+        grouped_table_impl(grouped_table_impl const& x)
+          : table(x, node_allocator_traits::
+                select_on_container_copy_construction(x.node_alloc())) {}
+
+        grouped_table_impl(grouped_table_impl const& x,
+                node_allocator const& a)
+          : table(x, a)
+        {}
+
+        grouped_table_impl(grouped_table_impl& x,
+                boost::unordered::detail::move_tag m)
+          : table(x, m)
+        {}
+
+        grouped_table_impl(grouped_table_impl& x,
+                node_allocator const& a,
+                boost::unordered::detail::move_tag m)
+          : table(x, a, m)
+        {}
+
+        // Accessors
+
+        template <class Key, class Pred>
+        node_pointer find_node_impl(
+                std::size_t hash,
+                Key const& k,
+                Pred const& eq) const
+        {
+            std::size_t bucket_index = hash % this->bucket_count_;
+            node_pointer n = this->get_start(bucket_index);
+
+            for (;;)
+            {
+                if (!n) return n;
+
+                std::size_t node_hash = n->hash_;
+                if (hash == node_hash)
+                {
+                    if (eq(k, this->get_key(n->value())))
+                        return n;
+                }
+                else
+                {
+                    if (node_hash % this->bucket_count_ != bucket_index)
+                        return node_pointer();
+                }
+
+                n = static_cast<node_pointer>(
+                    static_cast<node_pointer>(n->group_prev_)->next_);
+            }
+        }
+
+        std::size_t count(key_type const& k) const
+        {
+            node_pointer n = this->find_node(k);
+            if (!n) return 0;
+
+            std::size_t count = 0;
+            node_pointer it = n;
+            do {
+                it = static_cast<node_pointer>(it->group_prev_);
+                ++count;
+            } while(it != n);
+
+            return count;
+        }
+
+        std::pair<iterator, iterator>
+            equal_range(key_type const& k) const
+        {
+            node_pointer n = this->find_node(k);
+            return std::make_pair(
+                iterator(n), iterator(n ?
+                    static_cast<node_pointer>(
+                        static_cast<node_pointer>(n->group_prev_)->next_) :
+                    n));
+        }
+
+        // Equality
+
+        bool equals(grouped_table_impl const& other) const
+        {
+            if(this->size_ != other.size_) return false;
+            if(!this->size_) return true;
+    
+            for(node_pointer n1 = this->get_start(); n1;)
+            {
+                node_pointer n2 = other.find_matching_node(n1);
+                if (!n2) return false;
+                node_pointer end1 = static_cast<node_pointer>(
+                    static_cast<node_pointer>(n1->group_prev_)->next_);
+                node_pointer end2 = static_cast<node_pointer>(
+                    static_cast<node_pointer>(n2->group_prev_)->next_);
+                if (!group_equals(n1, end1, n2, end2)) return false;
+                n1 = end1;    
+            }
+    
+            return true;
+        }
+
+#if !defined(BOOST_UNORDERED_DEPRECATED_EQUALITY)
+
+        static bool group_equals(node_pointer n1, node_pointer end1,
+                node_pointer n2, node_pointer end2)
+        {
+            for(;;)
+            {
+                if (n1->value() != n2->value())
+                    break;
+
+                n1 = static_cast<node_pointer>(n1->next_);
+                n2 = static_cast<node_pointer>(n2->next_);
+            
+                if (n1 == end1) return n2 == end2;
+                if (n2 == end2) return false;
+            }
+            
+            for(node_pointer n1a = n1, n2a = n2;;)
+            {
+                n1a = static_cast<node_pointer>(n1a->next_);
+                n2a = static_cast<node_pointer>(n2a->next_);
+
+                if (n1a == end1)
+                {
+                    if (n2a == end2) break;
+                    else return false;
+                }
+
+                if (n2a == end2) return false;
+            }
+
+            node_pointer start = n1;
+            for(;n1 != end2; n1 = static_cast<node_pointer>(n1->next_))
+            {
+                value_type const& v = n1->value();
+                if (find(start, n1, v)) continue;
+                std::size_t matches = count_equal(n2, end2, v);
+                if (!matches || matches != 1 + count_equal(
+                        static_cast<node_pointer>(n1->next_), end1, v))
+                    return false;
+            }
+            
+            return true;
+        }
+
+        static bool find(node_pointer n, node_pointer end, value_type const& v)
+        {
+            for(;n != end; n = static_cast<node_pointer>(n->next_))
+                if (n->value() == v)
+                    return true;
+            return false;
+        }
+
+        static std::size_t count_equal(node_pointer n, node_pointer end,
+            value_type const& v)
+        {
+            std::size_t count = 0;
+            for(;n != end; n = static_cast<node_pointer>(n->next_))
+                if (n->value() == v) ++count;
+            return count;
+        }
+
+#else
+
+        static bool group_equals(node_pointer n1, node_pointer end1,
+                node_pointer n2, node_pointer end2)
+        {
+            for(;;)
+            {
+                if(!extractor::compare_mapped(
+                    n1->value(), n2->value()))
+                    return false;
+
+                n1 = static_cast<node_pointer>(n1->next_);
+                n2 = static_cast<node_pointer>(n2->next_);
+
+                if (n1 == end1) return n2 == end2;
+                if (n2 == end2) return false;
+            }
+        }
+
+#endif
+
+        // Emplace/Insert
+
+        static inline void add_after_node(
+                node_pointer n,
+                node_pointer pos)
+        {
+            n->next_ = static_cast<node_pointer>(pos->group_prev_)->next_;
+            n->group_prev_ = pos->group_prev_;
+            static_cast<node_pointer>(pos->group_prev_)->next_ =
+                static_cast<link_pointer>(n);
+            pos->group_prev_ = static_cast<link_pointer>(n);
+        }
+
+        inline node_pointer add_node(
+                node_constructor& a,
+                std::size_t hash,
+                node_pointer pos)
+        {
+            node_pointer n = a.release();
+            n->hash_ = hash;
+            if(pos) {
+                this->add_after_node(n, pos);
+                if (n->next_) {
+                    std::size_t next_bucket =
+                        static_cast<node_pointer>(n->next_)->hash_ %
+                        this->bucket_count_;
+                    if (next_bucket != hash % this->bucket_count_) {
+                        this->get_bucket(next_bucket)->next_ = n;
+                    }
+                }
+            }
+            else {
+                bucket_pointer b = this->get_bucket(hash % this->bucket_count_);
+
+                if (!b->next_)
+                {
+                    previous_pointer start_node = this->get_previous_start();
+                    
+                    if (start_node->next_) {
+                        this->get_bucket(
+                            static_cast<node_pointer>(start_node->next_)->hash_
+                                % this->bucket_count_)->next_ = n;
+                    }
+    
+                    b->next_ = start_node;
+                    n->next_ = start_node->next_;
+                    start_node->next_ = static_cast<link_pointer>(n);
+                }
+                else
+                {
+                    n->next_ = b->next_->next_;
+                    b->next_->next_ = static_cast<link_pointer>(n);
+                }
+            }
+            ++this->size_;
+            return n;
+        }
+
+        node_pointer emplace_impl(node_constructor& a)
+        {
+            key_type const& k = this->get_key(a.value());
+            std::size_t hash = this->hash_function()(k);
+            node_pointer position = this->find_node(hash, k);
+
+            // reserve has basic exception safety if the hash function
+            // throws, strong otherwise.
+            this->reserve_for_insert(this->size_ + 1);
+            return this->add_node(a, hash, position);
+        }
+
+        void emplace_impl_no_rehash(node_constructor& a)
+        {
+            key_type const& k = this->get_key(a.value());
+            std::size_t hash = this->hash_function()(k);
+            this->add_node(a, hash,
+                this->find_node(hash, k));
+        }
+
+#if defined(BOOST_NO_RVALUE_REFERENCES)
+        iterator emplace(boost::unordered::detail::emplace_args1<
+                boost::unordered::detail::please_ignore_this_overload> const&)
+        {
+            BOOST_ASSERT(false);
+            return iterator();
+        }
+#endif
+
+        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
+        iterator emplace(BOOST_UNORDERED_EMPLACE_ARGS)
+        {
+            node_constructor a(this->node_alloc());
+            a.construct_node();
+            a.construct_value(BOOST_UNORDERED_EMPLACE_FORWARD);
+
+            return iterator(emplace_impl(a));
+        }
+
+        ////////////////////////////////////////////////////////////////////////
+        // Insert range methods
+
+        // if hash function throws, or inserting > 1 element, basic exception
+        // safety. Strong otherwise
+        template <class I>
+        typename boost::unordered::detail::enable_if_forward<I, void>::type
+            insert_range(I i, I j)
+        {
+            if(i == j) return;
+
+            std::size_t distance = boost::unordered::detail::distance(i, j);
+            if(distance == 1) {
+                node_constructor a(this->node_alloc());
+                a.construct_node();
+                a.construct_value2(*i);
+                emplace_impl(a);
+            }
+            else {
+                // Only require basic exception safety here
+                this->reserve_for_insert(this->size_ + distance);
+
+                node_constructor a(this->node_alloc());
+                for (; i != j; ++i) {
+                    a.construct_node();
+                    a.construct_value2(*i);
+                    emplace_impl_no_rehash(a);
+                }
+            }
+        }
+
+        template <class I>
+        typename boost::unordered::detail::disable_if_forward<I, void>::type
+            insert_range(I i, I j)
+        {
+            node_constructor a(this->node_alloc());
+            for (; i != j; ++i) {
+                a.construct_node();
+                a.construct_value2(*i);
+                emplace_impl(a);
+            }
+        }
+
+        ////////////////////////////////////////////////////////////////////////
+        // Erase
+        //
+        // no throw
+
+        std::size_t erase_key(key_type const& k)
+        {
+            if(!this->size_) return 0;
+
+            std::size_t hash = this->hash_function()(k);
+            std::size_t bucket_index = hash % this->bucket_count_;
+            bucket_pointer bucket = this->get_bucket(bucket_index);
+
+            previous_pointer prev = bucket->next_;
+            if (!prev) return 0;
+
+            for (;;)
+            {
+                if (!prev->next_) return 0;
+                std::size_t node_hash =
+                    static_cast<node_pointer>(prev->next_)->hash_;
+                if (node_hash % this->bucket_count_ != bucket_index)
+                    return 0;
+                if (node_hash == hash &&
+                    this->key_eq()(k, this->get_key(
+                        static_cast<node_pointer>(prev->next_)->value())))
+                    break;
+                prev = static_cast<previous_pointer>(
+                    static_cast<node_pointer>(prev->next_)->group_prev_);
+            }
+
+            node_pointer pos = static_cast<node_pointer>(prev->next_);
+            link_pointer end1 =
+                static_cast<node_pointer>(pos->group_prev_)->next_;
+            node_pointer end = static_cast<node_pointer>(end1);
+            prev->next_ = end1;
+            this->fix_buckets(bucket, prev, end);
+            return this->delete_nodes(pos, end);
+        }
+
+        node_pointer erase(node_pointer r)
+        {
+            BOOST_ASSERT(r);
+            node_pointer next = static_cast<node_pointer>(r->next_);
+
+            bucket_pointer bucket = this->get_bucket(
+                r->hash_ % this->bucket_count_);
+            previous_pointer prev = unlink_node(*bucket, r);
+
+            this->fix_buckets(bucket, prev, next);
+
+            this->delete_node(r);
+
+            return next;
+        }
+
+        node_pointer erase_range(node_pointer r1, node_pointer r2)
+        {
+            if (r1 == r2) return r2;
+
+            std::size_t bucket_index = r1->hash_ % this->bucket_count_;
+            previous_pointer prev = unlink_nodes(
+                *this->get_bucket(bucket_index), r1, r2);
+            this->fix_buckets_range(bucket_index, prev, r1, r2);
+            this->delete_nodes(r1, r2);
+
+            return r2;
+        }
+
+        static previous_pointer unlink_node(bucket& b, node_pointer n)
+        {
+            node_pointer next = static_cast<node_pointer>(n->next_);
+            previous_pointer prev =
+                static_cast<previous_pointer>(n->group_prev_);
+
+            if(prev->next_ != n) {
+                // The node is at the beginning of a group.
+
+                // Find the previous node pointer:
+                prev = b.next_;
+                while(prev->next_ != n) {
+                    prev = static_cast<previous_pointer>(
+                        static_cast<node_pointer>(prev->next_)->group_prev_);
+                }
+
+                // Remove from group
+                if (next && next->group_prev_ == static_cast<link_pointer>(n))
+                {
+                    next->group_prev_ = n->group_prev_;
+                }
+            }
+            else if (next && next->group_prev_ == static_cast<link_pointer>(n))
+            {
+                // The deleted node is not at the end of the group, so
+                // change the link from the next node.
+                next->group_prev_ = n->group_prev_;
+            }
+            else {
+                // The deleted node is at the end of the group, so the
+                // first node in the group is pointing to it.
+                // Find that to change its pointer.
+                node_pointer x = static_cast<node_pointer>(n->group_prev_);
+                while(x->group_prev_ != static_cast<link_pointer>(n)) {
+                    x = static_cast<node_pointer>(x->group_prev_);
+                }
+                x->group_prev_ = n->group_prev_;
+            }
+
+            prev->next_ = static_cast<link_pointer>(next);
+            return prev;
+        }
+
+        static previous_pointer unlink_nodes(bucket& b,
+                node_pointer begin, node_pointer end)
+        {
+            previous_pointer prev = static_cast<previous_pointer>(
+                begin->group_prev_);
+
+            if(prev->next_ != static_cast<link_pointer>(begin)) {
+                // The node is at the beginning of a group.
+
+                // Find the previous node pointer:
+                prev = b.next_;
+                while(prev->next_ != static_cast<link_pointer>(begin))
+                    prev = static_cast<previous_pointer>(
+                        static_cast<node_pointer>(prev->next_)->group_prev_);
+
+                if (end) split_group(end);
+            }
+            else {
+                node_pointer group1 = split_group(begin);
+
+                if (end) {
+                    node_pointer group2 = split_group(end);
+
+                    if(begin == group2) {
+                        link_pointer end1 = group1->group_prev_;
+                        link_pointer end2 = group2->group_prev_;
+                        group1->group_prev_ = end2;
+                        group2->group_prev_ = end1;
+                    }
+                }
+            }
+
+            prev->next_ = static_cast<link_pointer>(end);
+
+            return prev;
+        }
+
+        // Break a ciruclar list into two, with split as the beginning
+        // of the second group (if split is at the beginning then don't
+        // split).
+        static node_pointer split_group(node_pointer split)
+        {
+            // Find first node in group.
+            node_pointer first = split;
+            while (static_cast<node_pointer>(first->group_prev_)->next_ ==
+                    static_cast<link_pointer>(first))
+                first = static_cast<node_pointer>(first->group_prev_);
+
+            if(first == split) return split;
+
+            link_pointer last = first->group_prev_;
+            first->group_prev_ = split->group_prev_;
+            split->group_prev_ = last;
+
+            return first;
+        }
+
+        ////////////////////////////////////////////////////////////////////////
+        // copy_buckets_to
+        //
+        // Basic exception safety. If an exception is thrown this will
+        // leave dst partially filled and the buckets unset.
+
+        static void copy_buckets_to(buckets const& src, buckets& dst)
+        {
+            BOOST_ASSERT(!dst.buckets_);
+
+            dst.create_buckets();
+
+            node_constructor a(dst.node_alloc());
+
+            node_pointer n = src.get_start();
+            previous_pointer prev = dst.get_previous_start();
+
+            while(n) {
+                std::size_t hash = n->hash_;
+                node_pointer group_end =
+                    static_cast<node_pointer>(
+                        static_cast<node_pointer>(n->group_prev_)->next_);
+
+                a.construct_node();
+                a.construct_value2(n->value());
+
+                node_pointer first_node = a.release();
+                node_pointer end = first_node;
+                first_node->hash_ = hash;
+                prev->next_ = static_cast<link_pointer>(first_node);
+                ++dst.size_;
+
+                for(n = static_cast<node_pointer>(n->next_); n != group_end;
+                        n = static_cast<node_pointer>(n->next_))
+                {
+                    a.construct_node();
+                    a.construct_value2(n->value());
+                    end = a.release();
+                    end->hash_ = hash;
+                    add_after_node(end, first_node);
+                    ++dst.size_;
+                }
+
+                prev = place_in_bucket(dst, prev, end);
+            }
+        }
+
+        ////////////////////////////////////////////////////////////////////////
+        // move_buckets_to
+        //
+        // Basic exception safety. The source nodes are left in an unusable
+        // state if an exception throws.
+
+        static void move_buckets_to(buckets& src, buckets& dst)
+        {
+            BOOST_ASSERT(!dst.buckets_);
+
+            dst.create_buckets();
+
+            node_constructor a(dst.node_alloc());
+
+            node_pointer n = src.get_start();
+            previous_pointer prev = dst.get_previous_start();
+
+            while(n) {
+                std::size_t hash = n->hash_;
+                node_pointer group_end =
+                    static_cast<node_pointer>(
+                        static_cast<node_pointer>(n->group_prev_)->next_);
+
+                a.construct_node();
+                a.construct_value2(boost::move(n->value()));
+
+                node_pointer first_node = a.release();
+                node_pointer end = first_node;
+                first_node->hash_ = hash;
+                prev->next_ = static_cast<link_pointer>(first_node);
+                ++dst.size_;
+
+                for(n = static_cast<node_pointer>(n->next_); n != group_end;
+                        n = static_cast<node_pointer>(n->next_))
+                {
+                    a.construct_node();
+                    a.construct_value2(boost::move(n->value()));
+                    end = a.release();
+                    end->hash_ = hash;
+                    add_after_node(end, first_node);
+                    ++dst.size_;
+                }
+
+                prev = place_in_bucket(dst, prev, end);
+            }
+        }
+
+        // strong otherwise exception safety
+        void rehash_impl(std::size_t num_buckets)
+        {
+            BOOST_ASSERT(this->size_);
+
+            buckets dst(this->node_alloc(), num_buckets);
+            dst.create_buckets();
+
+            previous_pointer src_start = this->get_previous_start();
+            previous_pointer dst_start = dst.get_previous_start();
+
+            dst_start->next_ = src_start->next_;
+            src_start->next_ = link_pointer();
+            dst.size_ = this->size_;
+            this->size_ = 0;
+
+            previous_pointer prev = dst_start;
+            while (prev->next_)
+                prev = place_in_bucket(dst, prev,
+                    static_cast<node_pointer>(
+                        static_cast<node_pointer>(prev->next_)->group_prev_));
+
+            // Swap the new nodes back into the container and setup the
+            // variables.
+            dst.swap(*this); // no throw
+        }
+
+        // Iterate through the nodes placing them in the correct buckets.
+        // pre: prev->next_ is not null.
+        static previous_pointer place_in_bucket(buckets& dst,
+                previous_pointer prev, node_pointer end)
+        {
+            bucket_pointer b = dst.get_bucket(end->hash_ % dst.bucket_count_);
+
+            if (!b->next_) {
+                b->next_ = static_cast<node_pointer>(prev);
+                return static_cast<previous_pointer>(end);
+            }
+            else {
+                link_pointer next = end->next_;
+                end->next_ = b->next_->next_;
+                b->next_->next_ = prev->next_;
+                prev->next_ = next;
+                return prev;
+            }
+        }
+    };
+}}}
+
+#endif

include/boost/unordered/detail/extract_key.hpp

@@ -0,0 +1,206 @@
+
+// Copyright (C) 2005-2011 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)
+
+#ifndef BOOST_UNORDERED_DETAIL_EXTRACT_KEY_HPP_INCLUDED
+#define BOOST_UNORDERED_DETAIL_EXTRACT_KEY_HPP_INCLUDED
+
+#include <boost/unordered/detail/table.hpp>
+
+namespace boost {
+namespace unordered {
+namespace detail {
+
+    // key extractors
+    //
+    // no throw
+    //
+    // 'extract_key' is called with the emplace parameters to return a
+    // key if available or 'no_key' is one isn't and will need to be
+    // constructed. This could be done by overloading the emplace implementation
+    // for the different cases, but that's a bit tricky on compilers without
+    // variadic templates.
+
+    struct no_key {
+        no_key() {}
+        template <class T> no_key(T const&) {}
+    };
+
+    template <typename Key, typename T>
+    struct is_key {
+        template <typename T2>
+        static choice1::type test(T2 const&);
+        static choice2::type test(Key const&);
+        
+        enum { value = sizeof(test(boost::unordered::detail::make<T>())) ==
+            sizeof(choice2::type) };
+        
+        typedef typename boost::detail::if_true<value>::
+            BOOST_NESTED_TEMPLATE then<Key const&, no_key>::type type;
+    };
+
+    template <class ValueType>
+    struct set_extractor
+    {
+        typedef ValueType value_type;
+        typedef ValueType key_type;
+
+        static key_type const& extract(key_type const& v)
+        {
+            return v;
+        }
+
+        static no_key extract()
+        {
+            return no_key();
+        }
+        
+#if defined(BOOST_UNORDERED_VARIADIC_MOVE)
+        template <class... Args>
+        static no_key extract(Args const&...)
+        {
+            return no_key();
+        }
+#else
+        template <class Arg>
+        static no_key extract(Arg const&)
+        {
+            return no_key();
+        }
+
+        template <class Arg1, class Arg2>
+        static no_key extract(Arg1 const&, Arg2 const&)
+        {
+            return no_key();
+        }
+#endif
+
+        static bool compare_mapped(value_type const&, value_type const&)
+        {
+            return true;
+        }
+    };
+
+    template <class Key, class ValueType>
+    struct map_extractor
+    {
+        typedef ValueType value_type;
+        typedef typename boost::remove_const<Key>::type key_type;
+
+        static key_type const& extract(value_type const& v)
+        {
+            return v.first;
+        }
+            
+        static key_type const& extract(key_type const& v)
+        {
+            return v;
+        }
+
+        template <class Second>
+        static key_type const& extract(std::pair<key_type, Second> const& v)
+        {
+            return v.first;
+        }
+
+        template <class Second>
+        static key_type const& extract(
+            std::pair<key_type const, Second> const& v)
+        {
+            return v.first;
+        }
+
+#if defined(BOOST_UNORDERED_VARIADIC_MOVE)
+        template <class Arg1, class... Args>
+        static key_type const& extract(key_type const& k,
+            Arg1 const&, Args const&...)
+        {
+            return k;
+        }
+
+        template <class... Args>
+        static no_key extract(Args const&...)
+        {
+            return no_key();
+        }
+#else
+
+        template <class Arg1>
+        static key_type const& extract(key_type const& k, Arg1 const&)
+        {
+            return k;
+        }
+
+        static no_key extract()
+        {
+            return no_key();
+        }
+
+        template <class Arg>
+        static no_key extract(Arg const&)
+        {
+            return no_key();
+        }
+
+        template <class Arg, class Arg1>
+        static no_key extract(Arg const&, Arg1 const&)
+        {
+            return no_key();
+        }
+#endif
+
+#if defined(BOOST_UNORDERED_VARIADIC_MOVE)
+
+#define BOOST_UNORDERED_KEY_FROM_TUPLE(namespace_)                          \
+        template <typename T2>                                              \
+        static no_key extract(boost::unordered::piecewise_construct_t,      \
+                namespace_::tuple<> const&, T2&&)                           \
+        {                                                                   \
+            return no_key();                                                \
+        }                                                                   \
+                                                                            \
+        template <typename T, typename T2>                                  \
+        static typename is_key<key_type, T>::type                           \
+            extract(boost::unordered::piecewise_construct_t,                \
+                namespace_::tuple<T> const& k, T2&&)                        \
+        {                                                                   \
+            return typename is_key<key_type, T>::type(                      \
+                namespace_::get<0>(k));                                     \
+        }
+
+#else
+
+#define BOOST_UNORDERED_KEY_FROM_TUPLE(namespace_)                          \
+        static no_key extract(boost::unordered::piecewise_construct_t,      \
+                namespace_::tuple<> const&)                                 \
+        {                                                                   \
+            return no_key();                                                \
+        }                                                                   \
+                                                                            \
+        template <typename T>                                               \
+        static typename is_key<key_type, T>::type                           \
+            extract(boost::unordered::piecewise_construct_t,                \
+                namespace_::tuple<T> const& k)                              \
+        {                                                                   \
+            return typename is_key<key_type, T>::type(                      \
+                namespace_::get<0>(k));                                     \
+        }
+
+#endif
+
+BOOST_UNORDERED_KEY_FROM_TUPLE(boost)
+
+#if !defined(BOOST_NO_0X_HDR_TUPLE)
+BOOST_UNORDERED_KEY_FROM_TUPLE(std)
+#endif
+
+
+        static bool compare_mapped(value_type const& x, value_type const& y)
+        {
+            return x.second == y.second;
+        }
+    };
+}}}
+
+#endif

include/boost/unordered/detail/fwd.hpp

@@ -0,0 +1,53 @@
+
+// Copyright (C) 2008-2011 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)
+
+#ifndef BOOST_UNORDERED_FWD_HPP_INCLUDED
+#define BOOST_UNORDERED_FWD_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <memory>
+#include <functional>
+#include <boost/functional/hash_fwd.hpp>
+
+namespace boost
+{
+namespace unordered
+{
+    template <class K,
+        class T,
+        class H = boost::hash<K>,
+        class P = std::equal_to<K>,
+        class A = std::allocator<std::pair<const K, T> > >
+    class unordered_map;
+
+    template <class K,
+        class T,
+        class H = boost::hash<K>,
+        class P = std::equal_to<K>,
+        class A = std::allocator<std::pair<const K, T> > >
+    class unordered_multimap;
+
+    template <class T,
+        class H = boost::hash<T>,
+        class P = std::equal_to<T>,
+        class A = std::allocator<T> >
+    class unordered_set;
+
+    template <class T,
+        class H = boost::hash<T>,
+        class P = std::equal_to<T>,
+        class A = std::allocator<T> >
+    class unordered_multiset;
+
+    struct piecewise_construct_t {};
+    const piecewise_construct_t piecewise_construct = piecewise_construct_t();
+}
+}
+
+#endif

include/boost/unordered/detail/hash_table.hpp

@@ -1,307 +0,0 @@
-
-// Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
-// Copyright (C) 2005-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)
-
-#ifndef BOOST_UNORDERED_DETAIL_HASH_TABLE_HPP_INCLUDED
-#define BOOST_UNORDERED_DETAIL_HASH_TABLE_HPP_INCLUDED
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-#include <boost/config.hpp>
-
-#include <cstddef>
-#include <cmath>
-#include <algorithm>
-#include <utility>
-#include <stdexcept>
-
-#include <boost/iterator.hpp>
-#include <boost/iterator/iterator_categories.hpp>
-#include <boost/limits.hpp>
-#include <boost/assert.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/unordered/detail/allocator_helpers.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/and.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/mpl/aux_/config/eti.hpp>
-
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/mpl/not.hpp>
-#endif
-
-#if BOOST_WORKAROUND(__BORLANDC__, <= 0x0582)
-#define BOOST_UNORDERED_BORLAND_BOOL(x) (bool)(x)
-#else
-#define BOOST_UNORDERED_BORLAND_BOOL(x) x
-#endif
-
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-#define BOOST_UNORDERED_MSVC_RESET_PTR(x) unordered_detail::reset(x)
-#else
-#define BOOST_UNORDERED_MSVC_RESET_PTR(x)
-#endif
-
-namespace boost {
-    namespace unordered_detail {
-        template <class T> struct type_wrapper {};
-
-        static const std::size_t default_initial_bucket_count = 50;
-        static const float minimum_max_load_factor = 1e-3f;
-
-        template <class T>
-        inline void hash_swap(T& x, T& y)
-        {
-#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
-            std::swap(x,y);
-#else
-            using std::swap;
-            swap(x, y);
-#endif
-        }
-
-        inline std::size_t double_to_size_t(double f)
-        {
-            return f >= static_cast<double>((std::numeric_limits<std::size_t>::max)()) ?
-                (std::numeric_limits<std::size_t>::max)() :
-                static_cast<std::size_t>(f);
-        }
-
-        // prime number list, accessor
-
-        template<typename T> struct prime_list_template
-        {
-            static std::size_t const value[];
-            static std::ptrdiff_t const length;
-        };
-
-        template<typename T>
-        std::size_t const prime_list_template<T>::value[] = {
-            53ul, 97ul, 193ul, 389ul, 769ul,
-            1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
-            49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
-            1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
-            50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
-            1610612741ul, 3221225473ul, 4294967291ul };
-
-        template<typename T>
-        std::ptrdiff_t const prime_list_template<T>::length = 28;
-
-        typedef prime_list_template<std::size_t> prime_list;
-
-        // no throw
-        inline std::size_t next_prime(std::size_t n) {
-            std::size_t const* const prime_list_begin = prime_list::value;
-            std::size_t const* const prime_list_end = prime_list_begin +
-                prime_list::length;
-            std::size_t const* bound =
-                std::lower_bound(prime_list_begin, prime_list_end, n);
-            if(bound == prime_list_end)
-                bound--;
-            return *bound;
-        }
-
-        // no throw
-        inline std::size_t prev_prime(std::size_t n) {
-            std::size_t const* const prime_list_begin = prime_list::value;
-            std::size_t const* const prime_list_end = prime_list_begin +
-                prime_list::length;
-            std::size_t const* bound =
-                std::upper_bound(prime_list_begin,prime_list_end, n);
-            if(bound != prime_list_begin)
-                bound--;
-            return *bound;
-        }
-        
-        // Controls how many buckets are allocated and which buckets hash
-        // values map to. Does not contain the buckets themselves, or ever
-        // deal with them directly.
-
-        struct bucket_manager {
-            std::size_t bucket_count_;
-            
-            bucket_manager()
-                : bucket_count_(0) {}
-            
-            explicit bucket_manager(std::size_t n)
-                : bucket_count_(next_prime(n)) {}
-            
-            std::size_t bucket_count() const {
-                return bucket_count_;
-            }
-            
-            std::size_t bucket_from_hash(std::size_t hashed) const {
-                return hashed % bucket_count_;
-            }
-            
-            std::size_t max_bucket_count(std::size_t max_size) const {
-                return prev_prime(max_size);
-            }
-        };
-
-        // pair_cast - used to convert between pair types.
-
-        template <class Dst1, class Dst2, class Src1, class Src2>
-        inline std::pair<Dst1, Dst2> pair_cast(std::pair<Src1, Src2> const& x)
-        {
-            return std::pair<Dst1, Dst2>(Dst1(x.first), Dst2(x.second));
-        }
-
-#if !defined(BOOST_NO_STD_DISTANCE)
-        using ::std::distance;
-#else
-        template <class ForwardIterator>
-        inline std::size_t distance(ForwardIterator i, ForwardIterator j) {
-            std::size_t x;
-            std::distance(i, j, x);
-            return x;
-        }
-#endif
-
-        struct move_tag {};
-
-        // Both hasher and key_equal's copy/assign can throw so double
-        // buffering is used to copy them.
-
-        template <typename Hash, typename Pred>
-        struct buffered_functions
-        {
-            typedef Hash hasher;
-            typedef Pred key_equal;
-
-            class functions
-            {
-                std::pair<hasher, key_equal> functions_;
-
-            public:
-
-                functions(hasher const& h, key_equal const& k)
-                    : functions_(h, k) {}
-
-                hasher const& hash_function() const
-                {
-                    return functions_.first;
-                }
-
-                key_equal const& key_eq() const
-                {
-                    return functions_.second;
-                }
-            };
-
-            typedef functions buffered_functions::*functions_ptr;
-
-            buffered_functions(hasher const& h, key_equal const& k)
-                : func1_(h, k), func2_(h, k), func_(&buffered_functions::func1_) {}
-
-            // This copies the given function objects into the currently unused
-            // function objects and returns a pointer, that func_ can later be
-            // set to, to commit the change.
-            //
-            // Strong exception safety (since only usued function objects are
-            // changed).
-            functions_ptr buffer(buffered_functions const& x) {
-                functions_ptr ptr = func_ == &buffered_functions::func1_
-                    ? &buffered_functions::func2_ : &buffered_functions::func1_;
-                this->*ptr = x.current();
-                return ptr;
-            }
-
-            void set(functions_ptr ptr) {
-                BOOST_ASSERT(ptr != func_);
-                func_ = ptr;
-            }
-
-            functions const& current() const {
-                return this->*func_;
-            }
-
-        private:
-            functions func1_;
-            functions func2_;
-            functions_ptr func_; // The currently active functions.
-        };
-
-    }
-}
-
-#define BOOST_UNORDERED_EQUIVALENT_KEYS 1
-#include <boost/unordered/detail/hash_table_impl.hpp>
-#undef BOOST_UNORDERED_EQUIVALENT_KEYS
-
-#define BOOST_UNORDERED_EQUIVALENT_KEYS 0
-#include <boost/unordered/detail/hash_table_impl.hpp>
-#undef BOOST_UNORDERED_EQUIVALENT_KEYS
-
-namespace boost {
-    namespace unordered_detail {
-        class iterator_access
-        {
-        public:
-            template <class Iterator>
-            static BOOST_DEDUCED_TYPENAME Iterator::base const& get(Iterator const& it) {
-                return it.base_;
-            }
-        };
-
-        template <class ValueType, class KeyType,
-            class Hash, class Pred, class Alloc>
-        class hash_types_unique_keys
-        {
-        public:
-            typedef BOOST_DEDUCED_TYPENAME
-                boost::unordered_detail::rebind_wrap<Alloc, ValueType>::type
-                value_allocator;
-
-            typedef hash_table_unique_keys<ValueType, KeyType, Hash, Pred,
-                    value_allocator> hash_table;
-            typedef hash_table_data_unique_keys<value_allocator> data;
-            typedef BOOST_DEDUCED_TYPENAME data::iterator_base iterator_base;
-
-            typedef hash_const_local_iterator_unique_keys<value_allocator> const_local_iterator;
-            typedef hash_local_iterator_unique_keys<value_allocator> local_iterator;
-            typedef hash_const_iterator_unique_keys<value_allocator> const_iterator;
-            typedef hash_iterator_unique_keys<value_allocator> iterator;
-
-            typedef BOOST_DEDUCED_TYPENAME data::size_type size_type;
-            typedef std::ptrdiff_t difference_type;
-        };
-
-        template <class ValueType, class KeyType,
-            class Hash, class Pred, class Alloc>
-        class hash_types_equivalent_keys
-        {
-        public:
-            typedef BOOST_DEDUCED_TYPENAME
-                boost::unordered_detail::rebind_wrap<Alloc, ValueType>::type
-                value_allocator;
-
-            typedef hash_table_equivalent_keys<ValueType, KeyType, Hash, Pred,
-                    value_allocator> hash_table;
-            typedef hash_table_data_equivalent_keys<value_allocator> data;
-            typedef BOOST_DEDUCED_TYPENAME data::iterator_base iterator_base;
-
-            typedef hash_const_local_iterator_equivalent_keys<value_allocator> const_local_iterator;
-            typedef hash_local_iterator_equivalent_keys<value_allocator> local_iterator;
-            typedef hash_const_iterator_equivalent_keys<value_allocator> const_iterator;
-            typedef hash_iterator_equivalent_keys<value_allocator> iterator;
-
-            typedef BOOST_DEDUCED_TYPENAME data::size_type size_type;
-            typedef std::ptrdiff_t difference_type;
-        };
-    } // namespace boost::unordered_detail
-} // namespace boost
-
-#undef BOOST_UNORDERED_BORLAND_BOOL
-#undef BOOST_UNORDERED_MSVC_RESET_PTR
-
-#endif // BOOST_UNORDERED_DETAIL_HASH_TABLE_HPP_INCLUDED

include/boost/unordered/detail/move.hpp

@@ -1,228 +0,0 @@
-/*
-    Copyright 2005-2007 Adobe Systems Incorporated
-   
-    Use, modification and distribution are subject to 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).
-*/
-
-/*************************************************************************************************/
-
-#ifndef BOOST_UNORDERED_DETAIL_MOVE_HEADER
-#define BOOST_UNORDERED_DETAIL_MOVE_HEADER
-
-
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/or.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_class.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/unordered/detail/config.hpp>
-
-/*************************************************************************************************/
-
-namespace boost {
-namespace unordered_detail {
-
-/*************************************************************************************************/
-
-namespace move_detail {
-
-/*************************************************************************************************/
-
-#if !defined(BOOST_UNORDERED_NO_HAS_MOVE_ASSIGN)
-
-/*************************************************************************************************/
-
-template <typename T>  
-struct class_has_move_assign {  
-    class type {
-        typedef T& (T::*E)(T t);  
-        typedef char (&no_type)[1];  
-        typedef char (&yes_type)[2];  
-        template <E e> struct sfinae { typedef yes_type type; };  
-        template <class U>  
-        static typename sfinae<&U::operator=>::type test(int);  
-        template <class U>  
-        static no_type test(...);  
-    public:  
-        enum {value = sizeof(test<T>(1)) == sizeof(yes_type)};  
-    };
- };  
-
-/*************************************************************************************************/
-
-template<typename T>
-struct has_move_assign : boost::mpl::and_<boost::is_class<T>, class_has_move_assign<T> > {};
-
-/*************************************************************************************************/
-
-class test_can_convert_anything { };
-
-/*************************************************************************************************/
-
-#endif // BOOST_UNORDERED_NO_HAS_MOVE_ASSIGN
-
-/*************************************************************************************************/
-
-/*
-    REVISIT (sparent@adobe.com): This is a work around for Boost 1.34.1 and VC++ 2008 where
-    boost::is_convertible<T, T> fails to compile.
-*/
-
-template <typename T, typename U>
-struct is_convertible : boost::mpl::or_<
-    boost::is_same<T, U>,
-    boost::is_convertible<T, U>
-> { };
-
-/*************************************************************************************************/
-
-} //namespace move_detail
-
-
-/*************************************************************************************************/
-
-/*!
-\ingroup move_related
-\brief move_from is used for move_ctors.
-*/
-
-template <typename T>
-struct move_from
-{
-    explicit move_from(T& x) : source(x) { }
-    T& source;
-};
-
-/*************************************************************************************************/
-
-#if !defined(BOOST_UNORDERED_NO_HAS_MOVE_ASSIGN)
-
-/*************************************************************************************************/
-
-/*!
-\ingroup move_related
-\brief The is_movable trait can be used to identify movable types.
-*/
-template <typename T>
-struct is_movable : boost::mpl::and_<
-                        boost::is_convertible<move_from<T>, T>,
-                        move_detail::has_move_assign<T>,
-                        boost::mpl::not_<boost::is_convertible<move_detail::test_can_convert_anything, T> >
-                    > { };
-
-/*************************************************************************************************/
-
-#else // BOOST_UNORDERED_NO_HAS_MOVE_ASSIGN
-
-// On compilers which don't have adequate SFINAE support, treat most types as unmovable,
-// unless the trait is specialized.
-
-template <typename T>
-struct is_movable : boost::mpl::false_ { };
-
-#endif
-
-/*************************************************************************************************/
-
-#if !defined(BOOST_NO_SFINAE)
-
-/*************************************************************************************************/
-
-/*!
-\ingroup move_related
-\brief copy_sink and move_sink are used to select between overloaded operations according to
- whether type T is movable and convertible to type U.
-\sa move
-*/
-
-template <typename T,
-          typename U = T,
-          typename R = void*>
-struct copy_sink : boost::enable_if<
-                        boost::mpl::and_<
-                            boost::unordered_detail::move_detail::is_convertible<T, U>,                           
-                            boost::mpl::not_<is_movable<T> >
-                        >,
-                        R
-                    >
-{ };
-
-/*************************************************************************************************/
-
-/*!
-\ingroup move_related
-\brief move_sink and copy_sink are used to select between overloaded operations according to
- whether type T is movable and convertible to type U.
- \sa move
-*/
-
-template <typename T,
-          typename U = T,
-          typename R = void*>
-struct move_sink : boost::enable_if<
-                        boost::mpl::and_<
-                            boost::unordered_detail::move_detail::is_convertible<T, U>,                            
-                            is_movable<T>
-                        >,
-                        R
-                    >
-{ };
-
-/*************************************************************************************************/
-
-/*!
-\ingroup move_related
-\brief This version of move is selected when T is_movable . It in turn calls the move
-constructor. This call, with the help of the return value optimization, will cause x to be moved
-instead of copied to its destination. See adobe/test/move/main.cpp for examples.
-
-*/
-template <typename T>
-T move(T& x, typename move_sink<T>::type = 0) { return T(move_from<T>(x)); }
-
-/*************************************************************************************************/
-
-/*!
-\ingroup move_related
-\brief This version of move is selected when T is not movable . The net result will be that
-x gets copied.
-*/
-template <typename T>
-T& move(T& x, typename copy_sink<T>::type = 0) { return x; }
-
-/*************************************************************************************************/
-
-#else // BOOST_NO_SFINAE
-
-// On compilers without SFINAE, define copy_sink to always use the copy function.
-
-template <typename T,
-          typename U = T,
-          typename R = void*>
-struct copy_sink
-{
-    typedef R type;
-};
-
-// Always copy the element unless this is overloaded.
-
-template <typename T>
-T& move(T& x) {
-    return x;
-}
-
-#endif // BOOST_NO_SFINAE
-
-} // namespace unordered_detail
-} // namespace boost
-
-/*************************************************************************************************/
-
-#endif
-
-/*************************************************************************************************/

include/boost/unordered/detail/table.hpp

@@ -0,0 +1,685 @@
+
+// Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
+// Copyright (C) 2005-2011 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)
+
+#ifndef BOOST_UNORDERED_DETAIL_ALL_HPP_INCLUDED
+#define BOOST_UNORDERED_DETAIL_ALL_HPP_INCLUDED
+
+#include <boost/unordered/detail/buckets.hpp>
+#include <boost/unordered/detail/util.hpp>
+#include <boost/type_traits/aligned_storage.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#include <boost/iterator.hpp>
+#include <cmath>
+
+namespace boost { namespace unordered { namespace iterator_detail {
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Iterators
+    //
+    // all no throw
+
+    template <typename NodePointer, typename Value> struct iterator;
+    template <typename ConstNodePointer, typename NodePointer,
+        typename Value> struct c_iterator;
+    template <typename NodePointer, typename Value> struct l_iterator;
+    template <typename ConstNodePointer, typename NodePointer,
+        typename Value> struct cl_iterator;
+
+    // Local Iterators
+    //
+    // all no throw
+
+    template <typename NodePointer, typename Value>
+    struct l_iterator
+        : public boost::iterator<
+            std::forward_iterator_tag, Value, std::ptrdiff_t,
+            NodePointer, Value&>
+    {
+#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+        template <typename ConstNodePointer, typename NodePointer2,
+                typename Value2>
+        friend struct boost::unordered::iterator_detail::cl_iterator;
+    private:
+#endif
+        typedef NodePointer node_pointer;
+        node_pointer ptr_;
+        std::size_t bucket_;
+        std::size_t bucket_count_;
+
+    public:
+
+        l_iterator() : ptr_() {}
+
+        l_iterator(node_pointer x, std::size_t b, std::size_t c)
+            : ptr_(x), bucket_(b), bucket_count_(c) {}
+
+        Value& operator*() const {
+            return ptr_->value();
+        }
+
+        Value* operator->() const {
+            return ptr_->value_ptr();
+        }
+
+        l_iterator& operator++() {
+            ptr_ = static_cast<node_pointer>(ptr_->next_);
+            if (ptr_ && ptr_->hash_ % bucket_count_ != bucket_)
+                ptr_ = node_pointer();
+            return *this;
+        }
+
+        l_iterator operator++(int) {
+            l_iterator tmp(*this);
+            ++(*this);
+            return tmp;
+        }
+
+        bool operator==(l_iterator x) const {
+            return ptr_ == x.ptr_;
+        }
+
+        bool operator!=(l_iterator x) const {
+            return ptr_ != x.ptr_;
+        }
+    };
+
+    template <typename ConstNodePointer, typename NodePointer, typename Value>
+    struct cl_iterator
+        : public boost::iterator<
+            std::forward_iterator_tag, Value, std::ptrdiff_t,
+            ConstNodePointer, Value const&>
+    {
+        friend struct boost::unordered::iterator_detail::l_iterator
+            <NodePointer, Value>;
+    private:
+
+        typedef NodePointer node_pointer;
+        node_pointer ptr_;
+        std::size_t bucket_;
+        std::size_t bucket_count_;
+
+    public:
+
+        cl_iterator() : ptr_() {}
+
+        cl_iterator(node_pointer x, std::size_t b, std::size_t c) :
+            ptr_(x), bucket_(b), bucket_count_(c) {}
+
+        cl_iterator(boost::unordered::iterator_detail::l_iterator<
+                NodePointer, Value> const& x) :
+            ptr_(x.ptr_), bucket_(x.bucket_), bucket_count_(x.bucket_count_)
+        {}
+
+        Value const&
+            operator*() const {
+            return ptr_->value();
+        }
+
+        Value const* operator->() const {
+            return ptr_->value_ptr();
+        }
+
+        cl_iterator& operator++() {
+            ptr_ = static_cast<node_pointer>(ptr_->next_);
+            if (ptr_ && ptr_->hash_ % bucket_count_ != bucket_)
+                ptr_ = node_pointer();
+            return *this;
+        }
+
+        cl_iterator operator++(int) {
+            cl_iterator tmp(*this);
+            ++(*this);
+            return tmp;
+        }
+
+        friend bool operator==(cl_iterator const& x, cl_iterator const& y) {
+            return x.ptr_ == y.ptr_;
+        }
+
+        friend bool operator!=(cl_iterator const& x, cl_iterator const& y) {
+            return x.ptr_ != y.ptr_;
+        }
+    };
+
+    template <typename NodePointer, typename Value>
+    struct iterator
+        : public boost::iterator<
+            std::forward_iterator_tag, Value, std::ptrdiff_t,
+            NodePointer, Value&>
+    {
+#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+        template <typename ConstNodePointer, typename NodePointer2,
+                typename Value2>
+        friend struct boost::unordered::iterator_detail::c_iterator;
+    private:
+#endif
+        typedef NodePointer node_pointer;
+        node_pointer node_;
+
+    public:
+
+        iterator() : node_() {}
+
+        explicit iterator(node_pointer const& x) : node_(x) {}
+
+        Value& operator*() const {
+            return node_->value();
+        }
+
+        Value* operator->() const {
+            return &node_->value();
+        }
+
+        iterator& operator++() {
+            node_ = static_cast<node_pointer>(node_->next_);
+            return *this;
+        }
+
+        iterator operator++(int) {
+            iterator tmp(node_);
+            node_ = static_cast<node_pointer>(node_->next_);
+            return tmp;
+        }
+
+        bool operator==(iterator const& x) const {
+            return node_ == x.node_;
+        }
+
+        bool operator!=(iterator const& x) const {
+            return node_ != x.node_;
+        }
+    };
+
+    template <typename ConstNodePointer, typename NodePointer, typename Value>
+    struct c_iterator
+        : public boost::iterator<
+            std::forward_iterator_tag, Value, std::ptrdiff_t,
+            ConstNodePointer, Value const&>
+    {
+        friend struct boost::unordered::iterator_detail::iterator<
+                NodePointer, Value>;
+
+#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+        template <typename K, typename T, typename H, typename P, typename A>
+        friend class boost::unordered::unordered_map;
+        template <typename K, typename T, typename H, typename P, typename A>
+        friend class boost::unordered::unordered_multimap;
+        template <typename T, typename H, typename P, typename A>
+        friend class boost::unordered::unordered_set;
+        template <typename T, typename H, typename P, typename A>
+        friend class boost::unordered::unordered_multiset;
+
+    private:
+#endif
+
+        typedef NodePointer node_pointer;
+        node_pointer node_;
+
+    public:
+
+        c_iterator() : node_() {}
+
+        explicit c_iterator(node_pointer const& x) : node_(x) {}
+
+        c_iterator(boost::unordered::iterator_detail::iterator<
+                NodePointer, Value> const& x) : node_(x.node_) {}
+
+        Value const& operator*() const {
+            return node_->value();
+        }
+
+        Value const* operator->() const {
+            return &node_->value();
+        }
+
+        c_iterator& operator++() {
+            node_ = static_cast<node_pointer>(node_->next_);
+            return *this;
+        }
+
+        c_iterator operator++(int) {
+            c_iterator tmp(node_);
+            node_ = static_cast<node_pointer>(node_->next_);
+            return tmp;
+        }
+
+        friend bool operator==(c_iterator const& x, c_iterator const& y) {
+            return x.node_ == y.node_;
+        }
+
+        friend bool operator!=(c_iterator const& x, c_iterator const& y) {
+            return x.node_ != y.node_;
+        }
+    };
+}}}
+
+namespace boost { namespace unordered { namespace detail {
+
+    ////////////////////////////////////////////////////////////////////////////
+    // convert double to std::size_t
+
+    inline std::size_t double_to_size(double f)
+    {
+        return f >= static_cast<double>(
+            (std::numeric_limits<std::size_t>::max)()) ?
+            (std::numeric_limits<std::size_t>::max)() :
+            static_cast<std::size_t>(f);
+    }
+
+    // The space used to store values in a node.
+
+    template <typename ValueType>
+    struct value_base
+    {
+        typedef ValueType value_type;
+
+        typename boost::aligned_storage<
+            sizeof(value_type),
+            boost::alignment_of<value_type>::value>::type data_;
+
+        void* address() {
+            return this;
+        }
+
+        value_type& value() {
+            return *(ValueType*) this;
+        }
+
+        value_type* value_ptr() {
+            return (ValueType*) this;
+        }
+
+    private:
+
+        value_base& operator=(value_base const&);
+    };
+
+    template <typename Types>
+    struct table :
+        boost::unordered::detail::buckets<
+            typename Types::allocator,
+            typename Types::bucket,
+            typename Types::node>,
+        boost::unordered::detail::functions<
+            typename Types::hasher,
+            typename Types::key_equal>
+    {
+    private:
+        table(table const&);
+        table& operator=(table const&);
+    public:
+        typedef typename Types::hasher hasher;
+        typedef typename Types::key_equal key_equal;
+        typedef typename Types::key_type key_type;
+        typedef typename Types::extractor extractor;
+        typedef typename Types::value_type value_type;
+        typedef typename Types::table table_impl;
+        typedef typename Types::link_pointer link_pointer;
+
+        typedef boost::unordered::detail::functions<
+            typename Types::hasher,
+            typename Types::key_equal> functions;
+
+        typedef boost::unordered::detail::buckets<
+            typename Types::allocator,
+            typename Types::bucket,
+            typename Types::node> buckets;
+
+        typedef typename buckets::node_allocator node_allocator;
+        typedef typename buckets::node_allocator_traits node_allocator_traits;
+        typedef typename buckets::node_pointer node_pointer;
+        typedef typename buckets::const_node_pointer const_node_pointer;
+
+        typedef boost::unordered::iterator_detail::
+            iterator<node_pointer, value_type> iterator;
+        typedef boost::unordered::iterator_detail::
+            c_iterator<const_node_pointer, node_pointer, value_type> c_iterator;
+        typedef boost::unordered::iterator_detail::
+            l_iterator<node_pointer, value_type> l_iterator;
+        typedef boost::unordered::iterator_detail::
+            cl_iterator<const_node_pointer, node_pointer, value_type>
+            cl_iterator;
+
+        // Members
+
+        float mlf_;
+        std::size_t max_load_; // Only use if this->buckets_.
+
+        ////////////////////////////////////////////////////////////////////////
+        // Load methods
+
+        std::size_t max_size() const
+        {
+            using namespace std;
+    
+            // size < mlf_ * count
+            return boost::unordered::detail::double_to_size(ceil(
+                    static_cast<double>(this->mlf_) *
+                    static_cast<double>(this->max_bucket_count())
+                )) - 1;
+        }
+
+        std::size_t calculate_max_load()
+        {
+            using namespace std;
+    
+            // From 6.3.1/13:
+            // Only resize when size >= mlf_ * count
+            return boost::unordered::detail::double_to_size(ceil(
+                    static_cast<double>(this->mlf_) *
+                    static_cast<double>(this->bucket_count_)
+                ));
+
+        }
+        void max_load_factor(float z)
+        {
+            BOOST_ASSERT(z > 0);
+            mlf_ = (std::max)(z, minimum_max_load_factor);
+            if (this->buckets_)
+                this->max_load_ = this->calculate_max_load();
+        }
+
+        std::size_t min_buckets_for_size(std::size_t size) const
+        {
+            BOOST_ASSERT(this->mlf_ != 0);
+    
+            using namespace std;
+    
+            // From 6.3.1/13:
+            // size < mlf_ * count
+            // => count > size / mlf_
+            //
+            // Or from rehash post-condition:
+            // count > size / mlf_
+
+            return boost::unordered::detail::next_prime(
+                boost::unordered::detail::double_to_size(floor(
+                    static_cast<double>(size) /
+                    static_cast<double>(mlf_))) + 1);
+        }
+
+        ////////////////////////////////////////////////////////////////////////
+        // Constructors
+
+        table(std::size_t num_buckets,
+                hasher const& hf,
+                key_equal const& eq,
+                node_allocator const& a) :
+            buckets(a, boost::unordered::detail::next_prime(num_buckets)),
+            functions(hf, eq),
+            mlf_(1.0f),
+            max_load_(0)
+        {}
+
+        table(table const& x, node_allocator const& a) :
+            buckets(a, x.min_buckets_for_size(x.size_)),
+            functions(x),
+            mlf_(x.mlf_),
+            max_load_(0)
+        {
+            if(x.size_) {
+                table_impl::copy_buckets_to(x, *this);
+                this->max_load_ = calculate_max_load();
+            }
+        }
+
+        // TODO: Why calculate_max_load?
+        table(table& x, boost::unordered::detail::move_tag m) :
+            buckets(x, m),
+            functions(x),
+            mlf_(x.mlf_),
+            max_load_(calculate_max_load())
+        {}
+
+        // TODO: Why not calculate_max_load?
+        // TODO: Why do I use x's bucket count?
+        table(table& x, node_allocator const& a,
+                boost::unordered::detail::move_tag m) :
+            buckets(a, x.bucket_count_),
+            functions(x),
+            mlf_(x.mlf_),
+            max_load_(x.max_load_)
+        {
+            if(a == x.node_alloc()) {
+                this->buckets::swap(x, false_type());
+            }
+            else if(x.size_) {
+                // Use a temporary table because move_buckets_to leaves the
+                // source container in a complete mess.
+
+                buckets tmp(x, m);
+                table_impl::move_buckets_to(tmp, *this);
+                this->max_load_ = calculate_max_load();
+            }
+        }
+
+        // Iterators
+
+        node_pointer begin() const {
+            return !this->buckets_ ?
+                node_pointer() : this->get_start();
+        }
+
+        // Assignment
+
+        void assign(table const& x)
+        {
+            assign(x,
+                boost::unordered::detail::integral_constant<bool,
+                    allocator_traits<node_allocator>::
+                    propagate_on_container_copy_assignment::value>());
+        }
+
+        void assign(table const& x, false_type)
+        {
+            table tmp(x, this->node_alloc());
+            this->swap(tmp, false_type());
+        }
+
+        void assign(table const& x, true_type)
+        {
+            table tmp(x, x.node_alloc());
+            // Need to delete before setting the allocator so that buckets
+            // aren't deleted with the wrong allocator.
+            if(this->buckets_) this->delete_buckets();
+            // TODO: Can allocator assignment throw?
+            this->allocators_.assign(x.allocators_);
+            this->swap(tmp, false_type());
+        }
+
+        void move_assign(table& x)
+        {
+            move_assign(x,
+                boost::unordered::detail::integral_constant<bool,
+                    allocator_traits<node_allocator>::
+                    propagate_on_container_move_assignment::value>());
+        }
+
+        void move_assign(table& x, true_type)
+        {
+            if(this->buckets_) this->delete_buckets();
+            this->allocators_.move_assign(x.allocators_);
+            move_assign_no_alloc(x);
+        }
+
+        void move_assign(table& x, false_type)
+        {
+            if(this->node_alloc() == x.node_alloc()) {
+                if(this->buckets_) this->delete_buckets();
+                move_assign_no_alloc(x);
+            }
+            else {
+                boost::unordered::detail::set_hash_functions<hasher, key_equal>
+                    new_func_this(*this, x);
+
+                if (x.size_) {
+                    buckets b(this->node_alloc(),
+                        x.min_buckets_for_size(x.size_));
+                    buckets tmp(x, move_tag());
+                    table_impl::move_buckets_to(tmp, b);
+                    b.swap(*this);
+                }
+                else {
+                    this->clear();
+                }
+                
+                this->mlf_ = x.mlf_;
+                if (this->buckets_) this->max_load_ = calculate_max_load();
+                new_func_this.commit();
+            }
+        }
+        
+        void move_assign_no_alloc(table& x)
+        {
+            boost::unordered::detail::set_hash_functions<hasher, key_equal>
+                new_func_this(*this, x);
+            // No throw from here.
+            this->move_buckets_from(x);
+            this->mlf_ = x.mlf_;
+            this->max_load_ = x.max_load_;
+            new_func_this.commit();
+        }
+
+        ////////////////////////////////////////////////////////////////////////
+        // Swap & Move
+
+        void swap(table& x)
+        {
+            swap(x,
+                boost::unordered::detail::integral_constant<bool,
+                    allocator_traits<node_allocator>::
+                    propagate_on_container_swap::value>());
+        }
+
+        // Only swaps the allocators if Propagate::value
+        template <typename Propagate>
+        void swap(table& x, Propagate p)
+        {
+            boost::unordered::detail::set_hash_functions<hasher, key_equal>
+                op1(*this, x);
+            boost::unordered::detail::set_hash_functions<hasher, key_equal>
+                op2(x, *this);
+            // I think swap can throw if Propagate::value,
+            // since the allocators' swap can throw. Not sure though.
+            this->buckets::swap(x, p);
+            std::swap(this->mlf_, x.mlf_);
+            std::swap(this->max_load_, x.max_load_);
+            op1.commit();
+            op2.commit();
+        }
+
+        // Swap everything but the allocators, and the functions objects.
+        void swap_contents(table& x)
+        {
+            this->buckets::swap(x, false_type());
+            std::swap(this->mlf_, x.mlf_);
+            std::swap(this->max_load_, x.max_load_);
+        }
+
+        // Accessors
+
+        key_type const& get_key(value_type const& x) const
+        {
+            return extractor::extract(x);
+        }
+
+        // Find Node
+
+        template <typename Key, typename Hash, typename Pred>
+        node_pointer generic_find_node(
+                Key const& k,
+                Hash const& hash_function,
+                Pred const& eq) const
+        {
+            if (!this->size_) return node_pointer();
+            return static_cast<table_impl const*>(this)->
+                find_node_impl(hash_function(k), k, eq);
+        }
+
+        node_pointer find_node(
+                std::size_t hash,
+                key_type const& k) const
+        {
+            if (!this->size_) return node_pointer();
+            return static_cast<table_impl const*>(this)->
+                find_node_impl(hash, k, this->key_eq());
+        }
+
+        node_pointer find_node(key_type const& k) const
+        {
+            if (!this->size_) return node_pointer();
+            return static_cast<table_impl const*>(this)->
+                find_node_impl(this->hash_function()(k), k, this->key_eq());
+        }
+
+        node_pointer find_matching_node(node_pointer n) const
+        {
+            // TODO: Does this apply to C++11?
+            //
+            // For some stupid reason, I decided to support equality comparison
+            // when different hash functions are used. So I can't use the hash
+            // value from the node here.
+    
+            return find_node(get_key(n->value()));
+        }
+
+        // Reserve and rehash
+
+        void reserve_for_insert(std::size_t);
+        void rehash(std::size_t);
+    };
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Reserve & Rehash
+
+    // basic exception safety
+    template <typename Types>
+    inline void table<Types>::reserve_for_insert(std::size_t size)
+    {
+        if (!this->buckets_) {
+            this->bucket_count_ = (std::max)(this->bucket_count_,
+                this->min_buckets_for_size(size));
+            this->create_buckets();
+            this->max_load_ = this->calculate_max_load();
+        }
+        else if(size >= max_load_) {
+            std::size_t num_buckets
+                = this->min_buckets_for_size((std::max)(size,
+                    this->size_ + (this->size_ >> 1)));
+            if (num_buckets != this->bucket_count_) {
+                static_cast<table_impl*>(this)->rehash_impl(num_buckets);
+                this->max_load_ = this->calculate_max_load();
+            }
+        }
+    }
+
+    // if hash function throws, basic exception safety
+    // strong otherwise.
+
+    template <typename Types>
+    void table<Types>::rehash(std::size_t min_buckets)
+    {
+        using namespace std;
+
+        if(!this->size_) {
+            if(this->buckets_) this->delete_buckets();
+            this->bucket_count_ = next_prime(min_buckets);
+        }
+        else {
+            min_buckets = next_prime((std::max)(min_buckets,
+                boost::unordered::detail::double_to_size(floor(
+                    static_cast<double>(this->size_) /
+                    static_cast<double>(mlf_))) + 1));
+
+            if(min_buckets != this->bucket_count_) {
+                static_cast<table_impl*>(this)->rehash_impl(min_buckets);
+                this->max_load_ = this->calculate_max_load();
+            }
+        }
+    }
+}}}
+
+#endif

include/boost/unordered/detail/unique.hpp

@@ -0,0 +1,708 @@
+
+// Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
+// Copyright (C) 2005-2011 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)
+
+#ifndef BOOST_UNORDERED_DETAIL_UNIQUE_HPP_INCLUDED
+#define BOOST_UNORDERED_DETAIL_UNIQUE_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/unordered/detail/table.hpp>
+#include <boost/unordered/detail/emplace_args.hpp>
+#include <boost/unordered/detail/extract_key.hpp>
+#include <boost/throw_exception.hpp>
+#include <stdexcept>
+
+namespace boost { namespace unordered { namespace detail {
+
+    template <typename A, typename T> struct node;
+    template <typename T> struct ptr_node;
+    template <typename Types> struct table_impl;
+
+    template <typename A, typename T>
+    struct node :
+        boost::unordered::detail::value_base<T>
+    {
+        typedef typename ::boost::unordered::detail::rebind_wrap<
+            A, node<A, T> >::type::pointer link_pointer;
+
+        link_pointer next_;
+        std::size_t hash_;
+
+        node() :
+            next_(),
+            hash_(0)
+        {}
+
+        void init(link_pointer)
+        {
+        }
+    };
+
+    template <typename T>
+    struct ptr_node :
+        boost::unordered::detail::value_base<T>,
+        boost::unordered::detail::ptr_bucket
+    {
+        typedef boost::unordered::detail::ptr_bucket bucket_base;
+        typedef ptr_bucket* link_pointer;
+
+        std::size_t hash_;
+
+        ptr_node() :
+            bucket_base(),
+            hash_(0)
+        {}
+
+        void init(link_pointer)
+        {
+        }
+    };
+
+    // If the allocator uses raw pointers use ptr_node
+    // Otherwise use node.
+
+    template <typename A, typename T, typename NodePtr, typename BucketPtr>
+    struct pick_node2
+    {
+        typedef boost::unordered::detail::node<A, T> node;
+
+        typedef typename boost::unordered::detail::allocator_traits<
+            typename boost::unordered::detail::rebind_wrap<A, node>::type
+        >::pointer node_pointer;
+
+        typedef boost::unordered::detail::bucket<node_pointer> bucket;
+        typedef node_pointer link_pointer;
+    };
+
+    template <typename A, typename T>
+    struct pick_node2<A, T,
+        boost::unordered::detail::ptr_node<T>*,
+        boost::unordered::detail::ptr_bucket*>
+    {
+        typedef boost::unordered::detail::ptr_node<T> node;
+        typedef boost::unordered::detail::ptr_bucket bucket;
+        typedef bucket* link_pointer;
+    };
+
+    template <typename A, typename T>
+    struct pick_node
+    {
+        typedef boost::unordered::detail::allocator_traits<
+            typename boost::unordered::detail::rebind_wrap<A,
+                boost::unordered::detail::ptr_node<T> >::type
+        > tentative_node_traits;
+
+        typedef boost::unordered::detail::allocator_traits<
+            typename boost::unordered::detail::rebind_wrap<A,
+                boost::unordered::detail::ptr_bucket >::type
+        > tentative_bucket_traits;
+
+        typedef pick_node2<A, T,
+            typename tentative_node_traits::pointer,
+            typename tentative_bucket_traits::pointer> pick;
+
+        typedef typename pick::node node;
+        typedef typename pick::bucket bucket;
+        typedef typename pick::link_pointer link_pointer;
+    };
+
+    template <typename A, typename T, typename H, typename P>
+    struct set
+    {
+        typedef boost::unordered::detail::set<A, T, H, P> types;
+
+        typedef T value_type;
+        typedef H hasher;
+        typedef P key_equal;
+        typedef T key_type;
+
+        typedef typename boost::unordered::detail::rebind_wrap<
+                A, value_type>::type allocator;
+
+        typedef boost::unordered::detail::allocator_traits<allocator> traits;
+        typedef boost::unordered::detail::pick_node<allocator, value_type> pick;
+        typedef typename pick::node node;
+        typedef typename pick::bucket bucket;
+        typedef typename pick::link_pointer link_pointer;
+
+        typedef boost::unordered::detail::table_impl<types> table;
+        typedef boost::unordered::detail::set_extractor<value_type> extractor;
+    };
+
+    template <typename A, typename K, typename M, typename H, typename P>
+    struct map
+    {
+        typedef boost::unordered::detail::map<A, K, M, H, P> types;
+
+        typedef std::pair<K const, M> value_type;
+        typedef H hasher;
+        typedef P key_equal;
+        typedef K key_type;
+
+        typedef typename boost::unordered::detail::rebind_wrap<
+                A, value_type>::type allocator;
+
+        typedef boost::unordered::detail::allocator_traits<allocator> traits;
+        typedef boost::unordered::detail::pick_node<allocator, value_type> pick;
+        typedef typename pick::node node;
+        typedef typename pick::bucket bucket;
+        typedef typename pick::link_pointer link_pointer;
+
+        typedef boost::unordered::detail::table_impl<types> table;
+        typedef boost::unordered::detail::map_extractor<key_type, value_type>
+            extractor;
+    };
+
+    template <typename Types>
+    struct table_impl : boost::unordered::detail::table<Types>
+    {
+        typedef boost::unordered::detail::table<Types> table;
+        typedef typename table::value_type value_type;
+        typedef typename table::bucket bucket;
+        typedef typename table::buckets buckets;
+        typedef typename table::node_pointer node_pointer;
+        typedef typename table::node_allocator node_allocator;
+        typedef typename table::node_allocator_traits node_allocator_traits;
+        typedef typename table::bucket_pointer bucket_pointer;
+        typedef typename table::link_pointer link_pointer;
+        typedef typename table::previous_pointer previous_pointer;
+        typedef typename table::hasher hasher;
+        typedef typename table::key_equal key_equal;
+        typedef typename table::key_type key_type;
+        typedef typename table::node_constructor node_constructor;
+        typedef typename table::extractor extractor;
+        typedef typename table::iterator iterator;
+
+        typedef std::pair<iterator, bool> emplace_return;
+
+        // Constructors
+
+        table_impl(std::size_t n,
+                hasher const& hf,
+                key_equal const& eq,
+                node_allocator const& a)
+          : table(n, hf, eq, a)
+        {}
+
+        table_impl(table_impl const& x)
+          : table(x, node_allocator_traits::
+                select_on_container_copy_construction(x.node_alloc())) {}
+
+        table_impl(table_impl const& x,
+                node_allocator const& a)
+          : table(x, a)
+        {}
+
+        table_impl(table_impl& x,
+                boost::unordered::detail::move_tag m)
+          : table(x, m)
+        {}
+
+        table_impl(table_impl& x,
+                node_allocator const& a,
+                boost::unordered::detail::move_tag m)
+          : table(x, a, m)
+        {}
+
+        // Accessors
+
+        template <class Key, class Pred>
+        node_pointer find_node_impl(
+                std::size_t hash,
+                Key const& k,
+                Pred const& eq) const
+        {
+            std::size_t bucket_index = hash % this->bucket_count_;
+            node_pointer n = this->get_start(bucket_index);
+
+            for (;;)
+            {
+                if (!n) return n;
+
+                std::size_t node_hash = n->hash_;
+                if (hash == node_hash)
+                {
+                    if (eq(k, this->get_key(n->value())))
+                        return n;
+                }
+                else
+                {
+                    if (node_hash % this->bucket_count_ != bucket_index)
+                        return node_pointer();
+                }
+
+                n = static_cast<node_pointer>(n->next_);
+            }
+        }
+
+        std::size_t count(key_type const& k) const
+        {
+            return this->find_node(k) ? 1 : 0;
+        }
+
+        value_type& at(key_type const& k) const
+        {
+            if (this->size_) {
+                node_pointer it = this->find_node(k);
+                if (it) return it->value();
+            }
+
+            boost::throw_exception(
+                std::out_of_range("Unable to find key in unordered_map."));
+        }
+
+        std::pair<iterator, iterator>
+            equal_range(key_type const& k) const
+        {
+            node_pointer n = this->find_node(k);
+            return std::make_pair(iterator(n),
+                iterator(n ? static_cast<node_pointer>(n->next_) : n));
+        }
+
+        // equals
+
+        bool equals(table_impl const& other) const
+        {
+            if(this->size_ != other.size_) return false;
+            if(!this->size_) return true;
+    
+            for(node_pointer n1 = this->get_start(); n1;
+                n1 = static_cast<node_pointer>(n1->next_))
+            {
+                node_pointer n2 = other.find_matching_node(n1);
+
+#if !defined(BOOST_UNORDERED_DEPRECATED_EQUALITY)
+                if(!n2 || n1->value() != n2->value())
+                    return false;
+#else
+                if(!n2 || !extractor::compare_mapped(
+                        n1->value(), n2->value()))
+                    return false;
+#endif
+            }
+    
+            return true;
+        }
+
+        // Emplace/Insert
+
+        inline node_pointer add_node(
+                node_constructor& a,
+                std::size_t hash)
+        {
+            node_pointer n = a.release();
+            n->hash_ = hash;
+    
+            bucket_pointer b = this->get_bucket(hash % this->bucket_count_);
+
+            if (!b->next_)
+            {
+                previous_pointer start_node = this->get_previous_start();
+                
+                if (start_node->next_) {
+                    this->get_bucket(
+                        static_cast<node_pointer>(start_node->next_)->hash_ %
+                            this->bucket_count_)->next_ = n;
+                }
+
+                b->next_ = start_node;
+                n->next_ = start_node->next_;
+                start_node->next_ = static_cast<link_pointer>(n);
+            }
+            else
+            {
+                n->next_ = b->next_->next_;
+                b->next_->next_ = static_cast<link_pointer>(n);
+            }
+
+            ++this->size_;
+            return n;
+        }
+
+        value_type& operator[](key_type const& k)
+        {
+            typedef typename value_type::second_type mapped_type;
+    
+            std::size_t hash = this->hash_function()(k);
+            node_pointer pos = this->find_node(hash, k);
+    
+            if (pos) return pos->value();
+    
+            // Create the node before rehashing in case it throws an
+            // exception (need strong safety in such a case).
+            node_constructor a(this->node_alloc());
+            a.construct_node();
+#if defined(BOOST_UNORDERED_VARIADIC_MOVE)
+            a.construct_value(boost::unordered::piecewise_construct,
+                boost::make_tuple(k), boost::make_tuple());
+#else
+            a.construct_value(
+                boost::unordered::detail::create_emplace_args(
+                    boost::unordered::piecewise_construct,
+                    boost::make_tuple(k),
+                    boost::make_tuple()));
+#endif
+    
+            this->reserve_for_insert(this->size_ + 1);
+            return add_node(a, hash)->value();
+        }
+
+#if defined(BOOST_NO_RVALUE_REFERENCES)
+        emplace_return emplace(boost::unordered::detail::emplace_args1<
+                boost::unordered::detail::please_ignore_this_overload> const&)
+        {
+            BOOST_ASSERT(false);
+            return emplace_return(iterator(this->begin()), false);
+        }
+#endif
+
+        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
+        emplace_return emplace(BOOST_UNORDERED_EMPLACE_ARGS)
+        {
+#if defined(BOOST_UNORDERED_VARIADIC_MOVE)
+            return emplace_impl(
+                extractor::extract(BOOST_UNORDERED_EMPLACE_FORWARD),
+                BOOST_UNORDERED_EMPLACE_FORWARD);
+
+#else
+            return emplace_impl(
+                extractor::extract(args.a0, args.a1),
+                BOOST_UNORDERED_EMPLACE_FORWARD);
+#endif
+        }
+
+#if !defined(BOOST_UNORDERED_VARIADIC_MOVE)
+        template <typename A0>
+        emplace_return emplace(
+                boost::unordered::detail::emplace_args1<A0> const& args)
+        {
+            return emplace_impl(extractor::extract(args.a0), args);
+        }
+#endif
+
+        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
+        emplace_return emplace_impl(key_type const& k,
+            BOOST_UNORDERED_EMPLACE_ARGS)
+        {
+            std::size_t hash = this->hash_function()(k);
+            node_pointer pos = this->find_node(hash, k);
+    
+            if (pos) return emplace_return(iterator(pos), false);
+    
+            // Create the node before rehashing in case it throws an
+            // exception (need strong safety in such a case).
+            node_constructor a(this->node_alloc());
+            a.construct_node();
+            a.construct_value(BOOST_UNORDERED_EMPLACE_FORWARD);
+    
+            // reserve has basic exception safety if the hash function
+            // throws, strong otherwise.
+            this->reserve_for_insert(this->size_ + 1);
+            return emplace_return(iterator(this->add_node(a, hash)), true);
+        }
+
+        emplace_return emplace_impl_with_node(node_constructor& a)
+        {
+            key_type const& k = this->get_key(a.value());
+            std::size_t hash = this->hash_function()(k);
+            node_pointer pos = this->find_node(hash, k);
+
+            if (pos) return emplace_return(iterator(pos), false);
+
+            // reserve has basic exception safety if the hash function
+            // throws, strong otherwise.
+            this->reserve_for_insert(this->size_ + 1);
+            return emplace_return(iterator(this->add_node(a, hash)), true);
+        }
+
+        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
+        emplace_return emplace_impl(no_key, BOOST_UNORDERED_EMPLACE_ARGS)
+        {
+            // Don't have a key, so construct the node first in order
+            // to be able to lookup the position.
+            node_constructor a(this->node_alloc());
+            a.construct_node();
+            a.construct_value(BOOST_UNORDERED_EMPLACE_FORWARD);
+            return emplace_impl_with_node(a);
+        }
+
+        ////////////////////////////////////////////////////////////////////////
+        // Insert range methods
+        //
+        // if hash function throws, or inserting > 1 element, basic exception
+        // safety strong otherwise
+
+        template <class InputIt>
+        void insert_range(InputIt i, InputIt j)
+        {
+            if(i != j)
+                return insert_range_impl(extractor::extract(*i), i, j);
+        }
+
+        template <class InputIt>
+        void insert_range_impl(key_type const& k, InputIt i, InputIt j)
+        {
+            node_constructor a(this->node_alloc());
+
+            // Special case for empty buckets so that we can use
+            // max_load_ (which isn't valid when buckets_ is null).
+            if (!this->buckets_) {
+                insert_range_empty(a, k, i, j);
+                if (++i == j) return;
+            }
+
+            do {
+                // Note: can't use get_key as '*i' might not be value_type - it
+                // could be a pair with first_types as key_type without const or
+                // a different second_type.
+                //
+                // TODO: Might be worth storing the value_type instead of the
+                // key here. Could be more efficient if '*i' is expensive. Could
+                // be less efficient if copying the full value_type is
+                // expensive.
+                insert_range_impl2(a, extractor::extract(*i), i, j);
+            } while(++i != j);
+        }
+
+        template <class InputIt>
+        void insert_range_empty(node_constructor& a, key_type const& k,
+            InputIt i, InputIt j)
+        {
+            std::size_t hash = this->hash_function()(k);
+            a.construct_node();
+            a.construct_value2(*i);
+            this->reserve_for_insert(this->size_ +
+                boost::unordered::detail::insert_size(i, j));
+            this->add_node(a, hash);
+        }
+
+        template <class InputIt>
+        void insert_range_impl2(node_constructor& a, key_type const& k,
+            InputIt i, InputIt j)
+        {
+            // No side effects in this initial code
+            std::size_t hash = this->hash_function()(k);
+            node_pointer pos = this->find_node(hash, k);
+    
+            if (!pos) {
+                a.construct_node();
+                a.construct_value2(*i);
+    
+                if(this->size_ + 1 >= this->max_load_)
+                    this->reserve_for_insert(this->size_ +
+                        boost::unordered::detail::insert_size(i, j));
+    
+                // Nothing after this point can throw.
+                this->add_node(a, hash);
+            }
+        }
+
+        template <class InputIt>
+        void insert_range_impl(no_key, InputIt i, InputIt j)
+        {
+            node_constructor a(this->node_alloc());
+
+            do {
+                a.construct_node();
+                a.construct_value2(*i);
+                emplace_impl_with_node(a);
+            } while(++i != j);
+        }
+
+        ////////////////////////////////////////////////////////////////////////
+        // Erase
+        //
+        // no throw
+
+        std::size_t erase_key(key_type const& k)
+        {
+            if(!this->size_) return 0;
+
+            std::size_t hash = this->hash_function()(k);
+            std::size_t bucket_index = hash % this->bucket_count_;
+            bucket_pointer bucket = this->get_bucket(bucket_index);
+
+            previous_pointer prev = bucket->next_;
+            if (!prev) return 0;
+
+            for (;;)
+            {
+                if (!prev->next_) return 0;
+                std::size_t node_hash =
+                    static_cast<node_pointer>(prev->next_)->hash_;
+                if (node_hash % this->bucket_count_ != bucket_index)
+                    return 0;
+                if (node_hash == hash &&
+                        this->key_eq()(k, this->get_key(
+                        static_cast<node_pointer>(prev->next_)->value())))
+                    break;
+                prev = static_cast<previous_pointer>(prev->next_);
+            }
+
+            node_pointer pos = static_cast<node_pointer>(prev->next_);
+            node_pointer end = static_cast<node_pointer>(pos->next_);
+            prev->next_ = pos->next_;
+            this->fix_buckets(bucket, prev, end);
+            return this->delete_nodes(pos, end);
+        }
+
+        node_pointer erase(node_pointer r)
+        {
+            BOOST_ASSERT(r);
+            node_pointer next = static_cast<node_pointer>(r->next_);
+
+            bucket_pointer bucket = this->get_bucket(
+                r->hash_ % this->bucket_count_);
+            previous_pointer prev = unlink_node(*bucket, r);
+
+            this->fix_buckets(bucket, prev, next);
+
+            this->delete_node(r);
+
+            return next;
+        }
+
+        node_pointer erase_range(node_pointer r1, node_pointer r2)
+        {
+            if (r1 == r2) return r2;
+
+            std::size_t bucket_index = r1->hash_ % this->bucket_count_;
+            previous_pointer prev = unlink_nodes(
+                *this->get_bucket(bucket_index), r1, r2);
+            this->fix_buckets_range(bucket_index, prev, r1, r2);
+            this->delete_nodes(r1, r2);
+
+            return r2;
+        }
+
+        static previous_pointer unlink_node(bucket& b, node_pointer n)
+        {
+            return unlink_nodes(b, n, static_cast<node_pointer>(n->next_));
+        }
+
+        static previous_pointer unlink_nodes(bucket& b,
+                node_pointer begin, node_pointer end)
+        {
+            previous_pointer prev = b.next_;
+            link_pointer begin_void = static_cast<link_pointer>(begin);
+            while(prev->next_ != begin_void)
+                prev = static_cast<previous_pointer>(prev->next_);
+            prev->next_ = static_cast<link_pointer>(end);
+            return prev;
+        }
+
+        ////////////////////////////////////////////////////////////////////////
+        // copy_buckets_to
+        //
+        // Basic exception safety. If an exception is thrown this will
+        // leave dst partially filled and the buckets unset.
+
+        static void copy_buckets_to(buckets const& src, buckets& dst)
+        {
+            BOOST_ASSERT(!dst.buckets_);
+
+            dst.create_buckets();
+
+            node_constructor a(dst.node_alloc());
+
+            node_pointer n = src.get_start();
+            previous_pointer prev = dst.get_previous_start();
+
+            while(n) {
+                a.construct_node();
+                a.construct_value2(n->value());
+
+                node_pointer node = a.release();
+                node->hash_ = n->hash_;
+                prev->next_ = static_cast<link_pointer>(node);
+                ++dst.size_;
+                n = static_cast<node_pointer>(n->next_);
+
+                prev = place_in_bucket(dst, prev);
+            }
+        }
+
+        ////////////////////////////////////////////////////////////////////////
+        // move_buckets_to
+        //
+        // Basic exception safety. The source nodes are left in an unusable
+        // state if an exception throws.
+
+        static void move_buckets_to(buckets& src, buckets& dst)
+        {
+            BOOST_ASSERT(!dst.buckets_);
+
+            dst.create_buckets();
+
+            node_constructor a(dst.node_alloc());
+
+            node_pointer n = src.get_start();
+            previous_pointer prev = dst.get_previous_start();
+
+            while(n) {
+                a.construct_node();
+                a.construct_value2(boost::move(n->value()));
+
+                node_pointer node = a.release();
+                node->hash_ = n->hash_;
+                prev->next_ = static_cast<link_pointer>(node);
+                ++dst.size_;
+                n = static_cast<node_pointer>(n->next_);
+
+                prev = place_in_bucket(dst, prev);
+            }
+        }
+
+        // strong otherwise exception safety
+        void rehash_impl(std::size_t num_buckets)
+        {
+            BOOST_ASSERT(this->size_);
+
+            buckets dst(this->node_alloc(), num_buckets);
+            dst.create_buckets();
+
+            previous_pointer src_start = this->get_previous_start();
+            previous_pointer dst_start = dst.get_previous_start();
+
+            dst_start->next_ = src_start->next_;
+            src_start->next_ = link_pointer();
+            dst.size_ = this->size_;
+            this->size_ = 0;
+
+            previous_pointer prev = dst.get_previous_start();
+            while (prev->next_)
+                prev = place_in_bucket(dst, prev);
+
+            // Swap the new nodes back into the container and setup the
+            // variables.
+            dst.swap(*this); // no throw
+        }
+
+        // Iterate through the nodes placing them in the correct buckets.
+        // pre: prev->next_ is not null.
+        static previous_pointer place_in_bucket(buckets& dst,
+                previous_pointer prev)
+        {
+            node_pointer n = static_cast<node_pointer>(prev->next_);
+            bucket_pointer b = dst.get_bucket(n->hash_ % dst.bucket_count_);
+
+            if (!b->next_) {
+                b->next_ = prev;
+                return static_cast<previous_pointer>(n);
+            }
+            else {
+                prev->next_ = n->next_;
+                n->next_ = b->next_->next_;
+                b->next_->next_ = static_cast<link_pointer>(n);
+                return prev;
+            }
+        }
+    };
+}}}
+
+#endif

include/boost/unordered/detail/util.hpp

@@ -0,0 +1,260 @@
+
+// Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
+// Copyright (C) 2005-2011 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)
+
+#ifndef BOOST_UNORDERED_DETAIL_UTIL_HPP_INCLUDED
+#define BOOST_UNORDERED_DETAIL_UTIL_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_empty.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/detail/select_type.hpp>
+#include <boost/move/move.hpp>
+#include <boost/preprocessor/seq/size.hpp>
+#include <boost/preprocessor/seq/enum.hpp>
+#include <boost/swap.hpp>
+
+namespace boost { namespace unordered { namespace detail {
+
+    static const float minimum_max_load_factor = 1e-3f;
+    static const std::size_t default_bucket_count = 11;
+    struct move_tag {};
+    struct empty_emplace {};
+
+    ////////////////////////////////////////////////////////////////////////////
+    // iterator SFINAE
+
+    template <typename I>
+    struct is_forward :
+        boost::is_convertible<
+            typename boost::iterator_traversal<I>::type,
+            boost::forward_traversal_tag>
+    {};
+
+    template <typename I, typename ReturnType>
+    struct enable_if_forward :
+        boost::enable_if_c<
+            boost::unordered::detail::is_forward<I>::value,
+            ReturnType>
+    {};
+
+    template <typename I, typename ReturnType>
+    struct disable_if_forward :
+        boost::disable_if_c<
+            boost::unordered::detail::is_forward<I>::value,
+            ReturnType>
+    {};
+
+    ////////////////////////////////////////////////////////////////////////////
+    // primes
+
+#define BOOST_UNORDERED_PRIMES \
+    (5ul)(11ul)(17ul)(29ul)(37ul)(53ul)(67ul)(79ul) \
+    (97ul)(131ul)(193ul)(257ul)(389ul)(521ul)(769ul) \
+    (1031ul)(1543ul)(2053ul)(3079ul)(6151ul)(12289ul)(24593ul) \
+    (49157ul)(98317ul)(196613ul)(393241ul)(786433ul) \
+    (1572869ul)(3145739ul)(6291469ul)(12582917ul)(25165843ul) \
+    (50331653ul)(100663319ul)(201326611ul)(402653189ul)(805306457ul) \
+    (1610612741ul)(3221225473ul)(4294967291ul)
+
+    template<class T> struct prime_list_template
+    {
+        static std::size_t const value[];
+
+#if !defined(SUNPRO_CC)
+        static std::ptrdiff_t const length;
+#else
+        static std::ptrdiff_t const length
+            = BOOST_PP_SEQ_SIZE(BOOST_UNORDERED_PRIMES);
+#endif
+    };
+
+    template<class T>
+    std::size_t const prime_list_template<T>::value[] = {
+        BOOST_PP_SEQ_ENUM(BOOST_UNORDERED_PRIMES)
+    };
+
+#if !defined(SUNPRO_CC)
+    template<class T>
+    std::ptrdiff_t const prime_list_template<T>::length
+        = BOOST_PP_SEQ_SIZE(BOOST_UNORDERED_PRIMES);
+#endif
+
+#undef BOOST_UNORDERED_PRIMES
+
+    typedef prime_list_template<std::size_t> prime_list;
+
+    // no throw
+    inline std::size_t next_prime(std::size_t num) {
+        std::size_t const* const prime_list_begin = prime_list::value;
+        std::size_t const* const prime_list_end = prime_list_begin +
+            prime_list::length;
+        std::size_t const* bound =
+            std::lower_bound(prime_list_begin, prime_list_end, num);
+        if(bound == prime_list_end)
+            bound--;
+        return *bound;
+    }
+
+    // no throw
+    inline std::size_t prev_prime(std::size_t num) {
+        std::size_t const* const prime_list_begin = prime_list::value;
+        std::size_t const* const prime_list_end = prime_list_begin +
+            prime_list::length;
+        std::size_t const* bound =
+            std::upper_bound(prime_list_begin,prime_list_end, num);
+        if(bound != prime_list_begin)
+            bound--;
+        return *bound;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+    // insert_size/initial_size
+
+#if !defined(BOOST_NO_STD_DISTANCE)
+
+    using ::std::distance;
+
+#else
+
+    template <class ForwardIterator>
+    inline std::size_t distance(ForwardIterator i, ForwardIterator j) {
+        std::size_t x;
+        std::distance(i, j, x);
+        return x;
+    }
+
+#endif
+
+    template <class I>
+    inline typename
+        boost::unordered::detail::enable_if_forward<I, std::size_t>::type
+        insert_size(I i, I j)
+    {
+        return std::distance(i, j);
+    }
+
+    template <class I>
+    inline typename
+        boost::unordered::detail::disable_if_forward<I, std::size_t>::type
+        insert_size(I, I)
+    {
+        return 1;
+    }
+
+    template <class I>
+    inline std::size_t initial_size(I i, I j,
+        std::size_t num_buckets =
+            boost::unordered::detail::default_bucket_count)
+    {
+        // TODO: Why +1?
+        return (std::max)(
+            boost::unordered::detail::insert_size(i, j) + 1,
+            num_buckets);
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+    // compressed
+
+    template <typename T, int Index>
+    struct compressed_base : private T
+    {
+        compressed_base(T const& x) : T(x) {}
+        compressed_base(T& x, move_tag) : T(boost::move(x)) {}
+
+        T& get() { return *this; }
+        T const& get() const { return *this; }
+    };
+    
+    template <typename T, int Index>
+    struct uncompressed_base
+    {
+        uncompressed_base(T const& x) : value_(x) {}
+        uncompressed_base(T& x, move_tag) : value_(boost::move(x)) {}
+
+        T& get() { return value_; }
+        T const& get() const { return value_; }
+    private:
+        T value_;
+    };
+    
+    template <typename T, int Index>
+    struct generate_base
+      : boost::detail::if_true<
+            boost::is_empty<T>::value
+        >:: BOOST_NESTED_TEMPLATE then<
+            boost::unordered::detail::compressed_base<T, Index>,
+            boost::unordered::detail::uncompressed_base<T, Index>
+        >
+    {};
+    
+    template <typename T1, typename T2>
+    struct compressed
+      : private boost::unordered::detail::generate_base<T1, 1>::type,
+        private boost::unordered::detail::generate_base<T2, 2>::type
+    {
+        typedef typename generate_base<T1, 1>::type base1;
+        typedef typename generate_base<T2, 2>::type base2;
+
+        typedef T1 first_type;
+        typedef T2 second_type;
+        
+        first_type& first() {
+            return static_cast<base1*>(this)->get();
+        }
+
+        first_type const& first() const {
+            return static_cast<base1 const*>(this)->get();
+        }
+
+        second_type& second() {
+            return static_cast<base2*>(this)->get();
+        }
+
+        second_type const& second() const {
+            return static_cast<base2 const*>(this)->get();
+        }
+
+        template <typename First, typename Second>
+        compressed(First const& x1, Second const& x2)
+            : base1(x1), base2(x2) {}
+
+        compressed(compressed const& x)
+            : base1(x.first()), base2(x.second()) {}
+
+        compressed(compressed& x, move_tag m)
+            : base1(x.first(), m), base2(x.second(), m) {}
+
+        void assign(compressed const& x)
+        {
+            first() = x.first();
+            second() = x.second();
+        }
+
+        void move_assign(compressed& x)
+        {
+            first() = boost::move(x.first());
+            second() = boost::move(x.second());
+        }
+        
+        void swap(compressed& x)
+        {
+            boost::swap(first(), x.first());
+            boost::swap(second(), x.second());
+        }
+
+    private:
+        // Prevent assignment just to make use of assign or
+        // move_assign explicit.
+        compressed& operator=(compressed const&);
+    };
+}}}
+
+#endif

include/boost/unordered/unordered_map_fwd.hpp

@@ -0,0 +1,47 @@
+
+// Copyright (C) 2008-2011 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)
+
+#ifndef BOOST_UNORDERED_MAP_FWD_HPP_INCLUDED
+#define BOOST_UNORDERED_MAP_FWD_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/unordered/detail/fwd.hpp>
+
+namespace boost
+{
+    namespace unordered
+    {
+        template <class K, class T, class H, class P, class A>
+        inline bool operator==(unordered_map<K, T, H, P, A> const&,
+            unordered_map<K, T, H, P, A> const&);
+        template <class K, class T, class H, class P, class A>
+        inline bool operator!=(unordered_map<K, T, H, P, A> const&,
+            unordered_map<K, T, H, P, A> const&);
+        template <class K, class T, class H, class P, class A>
+        inline void swap(unordered_map<K, T, H, P, A>&,
+                unordered_map<K, T, H, P, A>&);
+
+        template <class K, class T, class H, class P, class A>
+        inline bool operator==(unordered_multimap<K, T, H, P, A> const&,
+            unordered_multimap<K, T, H, P, A> const&);
+        template <class K, class T, class H, class P, class A>
+        inline bool operator!=(unordered_multimap<K, T, H, P, A> const&,
+            unordered_multimap<K, T, H, P, A> const&);
+        template <class K, class T, class H, class P, class A>
+        inline void swap(unordered_multimap<K, T, H, P, A>&,
+                unordered_multimap<K, T, H, P, A>&);
+    }
+
+    using boost::unordered::unordered_map;
+    using boost::unordered::unordered_multimap;
+    using boost::unordered::swap;
+    using boost::unordered::operator==;
+    using boost::unordered::operator!=;
+}
+
+#endif

include/boost/unordered/unordered_set_fwd.hpp

@@ -0,0 +1,47 @@
+
+// Copyright (C) 2008-2011 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)
+
+#ifndef BOOST_UNORDERED_SET_FWD_HPP_INCLUDED
+#define BOOST_UNORDERED_SET_FWD_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/unordered/detail/fwd.hpp>
+
+namespace boost
+{
+    namespace unordered
+    {
+        template <class T, class H, class P, class A>
+        inline bool operator==(unordered_set<T, H, P, A> const&,
+            unordered_set<T, H, P, A> const&);
+        template <class T, class H, class P, class A>
+        inline bool operator!=(unordered_set<T, H, P, A> const&,
+            unordered_set<T, H, P, A> const&);
+        template <class T, class H, class P, class A>
+        inline void swap(unordered_set<T, H, P, A> &m1,
+                unordered_set<T, H, P, A> &m2);
+
+        template <class T, class H, class P, class A>
+        inline bool operator==(unordered_multiset<T, H, P, A> const&,
+            unordered_multiset<T, H, P, A> const&);
+        template <class T, class H, class P, class A>
+        inline bool operator!=(unordered_multiset<T, H, P, A> const&,
+            unordered_multiset<T, H, P, A> const&);
+        template <class T, class H, class P, class A>
+        inline void swap(unordered_multiset<T, H, P, A> &m1,
+                unordered_multiset<T, H, P, A> &m2);
+    }
+
+    using boost::unordered::unordered_set;
+    using boost::unordered::unordered_multiset;
+    using boost::unordered::swap;
+    using boost::unordered::operator==;
+    using boost::unordered::operator!=;
+}
+
+#endif

include/boost/unordered_map.hpp

@@ -13,812 +13,6 @@
 # pragma once
 #endif
 
-#include <boost/config.hpp>
-
-#include <functional>
-#include <memory>
-
-#include <boost/functional/hash.hpp>
-#include <boost/unordered/detail/hash_table.hpp>
-
-#if !defined(BOOST_HAS_RVALUE_REFS)
-#include <boost/unordered/detail/move.hpp>
-#endif
-
-namespace boost
-{
-    template <class Key,
-        class T,
-        class Hash = hash<Key>,
-        class Pred = std::equal_to<Key>,
-        class Alloc = std::allocator<std::pair<const Key, T> > >
-    class unordered_map;
-    template <class K, class T, class H, class P, class A>
-    bool operator==(unordered_map<K, T, H, P, A> const&,
-        unordered_map<K, T, H, P, A> const&);
-    template <class K, class T, class H, class P, class A>
-    bool operator!=(unordered_map<K, T, H, P, A> const&,
-        unordered_map<K, T, H, P, A> const&);
-    template <class K, class T, class H, class P, class A>
-    void swap(unordered_map<K, T, H, P, A>&,
-            unordered_map<K, T, H, P, A>&);
-
-    template <class Key,
-        class T,
-        class Hash = hash<Key>,
-        class Pred = std::equal_to<Key>,
-        class Alloc = std::allocator<std::pair<const Key, T> > >
-    class unordered_multimap;
-    template <class K, class T, class H, class P, class A>
-    bool operator==(unordered_multimap<K, T, H, P, A> const&,
-        unordered_multimap<K, T, H, P, A> const&);
-    template <class K, class T, class H, class P, class A>
-    bool operator!=(unordered_multimap<K, T, H, P, A> const&,
-        unordered_multimap<K, T, H, P, A> const&);
-    template <class K, class T, class H, class P, class A>
-    void swap(unordered_multimap<K, T, H, P, A>&,
-            unordered_multimap<K, T, H, P, A>&);
-
-    template <class Key, class T, class Hash, class Pred, class Alloc>
-    class unordered_map
-    {
-        typedef boost::unordered_detail::hash_types_unique_keys<
-            std::pair<const Key, T>, Key, Hash, Pred, Alloc
-        > implementation;
-
-        BOOST_DEDUCED_TYPENAME implementation::hash_table base;
-
-    public:
-
-        // types
-
-        typedef Key key_type;
-        typedef std::pair<const Key, T> value_type;
-        typedef T mapped_type;
-        typedef Hash hasher;
-        typedef Pred key_equal;
-
-        typedef Alloc allocator_type;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::pointer pointer;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::const_pointer const_pointer;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::reference reference;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::const_reference const_reference;
-
-        typedef BOOST_DEDUCED_TYPENAME implementation::size_type size_type;
-        typedef BOOST_DEDUCED_TYPENAME implementation::difference_type difference_type;
-
-        typedef BOOST_DEDUCED_TYPENAME implementation::iterator iterator;
-        typedef BOOST_DEDUCED_TYPENAME implementation::const_iterator const_iterator;
-        typedef BOOST_DEDUCED_TYPENAME implementation::local_iterator local_iterator;
-        typedef BOOST_DEDUCED_TYPENAME implementation::const_local_iterator const_local_iterator;
-
-        // construct/destroy/copy
-
-        explicit unordered_map(
-                size_type n = boost::unordered_detail::default_initial_bucket_count,
-                const hasher &hf = hasher(),
-                const key_equal &eql = key_equal(),
-                const allocator_type &a = allocator_type())
-            : base(n, hf, eql, a)
-        {
-        }
-
-        explicit unordered_map(allocator_type const& a)
-            : base(boost::unordered_detail::default_initial_bucket_count,
-                hasher(), key_equal(), a)
-        {
-        }
-
-        unordered_map(unordered_map const& other, allocator_type const& a)
-            : base(other.base, a)
-        {
-        }
-
-        template <class InputIterator>
-        unordered_map(InputIterator f, InputIterator l)
-            : base(f, l, boost::unordered_detail::default_initial_bucket_count,
-                hasher(), key_equal(), allocator_type())
-        {
-        }
-
-        template <class InputIterator>
-        unordered_map(InputIterator f, InputIterator l,
-                size_type n,
-                const hasher &hf = hasher(),
-                const key_equal &eql = key_equal(),
-                const allocator_type &a = allocator_type())
-            : base(f, l, n, hf, eql, a)
-        {
-        }
-
-#if defined(BOOST_HAS_RVALUE_REFS)
-        unordered_map(unordered_map&& other)
-            : base(other.base, boost::unordered_detail::move_tag())
-        {
-        }
-
-        unordered_map(unordered_map&& other, allocator_type const& a)
-            : base(other.base, a, boost::unordered_detail::move_tag())
-        {
-        }
-
-        unordered_map& operator=(unordered_map&& x)
-        {
-            base.move(x.base);
-            return *this;
-        }
-#else
-        unordered_map(boost::unordered_detail::move_from<unordered_map<Key, T, Hash, Pred, Alloc> > other)
-            : base(other.source.base, boost::unordered_detail::move_tag())
-        {
-        }
-
-#if !BOOST_WORKAROUND(__BORLANDC__, < 0x0593)
-        unordered_map& operator=(unordered_map x)
-        {
-            base.move(x.base);
-            return *this;
-        }
-#endif
-#endif
-
-    private:
-
-        BOOST_DEDUCED_TYPENAME implementation::iterator_base const&
-            get(const_iterator const& it)
-        {
-            return boost::unordered_detail::iterator_access::get(it);
-        }
-
-    public:
-
-        allocator_type get_allocator() const
-        {
-            return base.get_allocator();
-        }
-
-        // size and capacity
-
-        bool empty() const
-        {
-            return base.empty();
-        }
-
-        size_type size() const
-        {
-            return base.size();
-        }
-
-        size_type max_size() const
-        {
-            return base.max_size();
-        }
-
-        // iterators
-
-        iterator begin()
-        {
-            return iterator(base.data_.begin());
-        }
-
-        const_iterator begin() const
-        {
-            return const_iterator(base.data_.begin());
-        }
-
-        iterator end()
-        {
-            return iterator(base.data_.end());
-        }
-
-        const_iterator end() const
-        {
-            return const_iterator(base.data_.end());
-        }
-
-        const_iterator cbegin() const
-        {
-            return const_iterator(base.data_.begin());
-        }
-
-        const_iterator cend() const
-        {
-            return const_iterator(base.data_.end());
-        }
-
-        // modifiers
-
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
-        template <class... Args>
-        std::pair<iterator, bool> emplace(Args&&... args)
-        {
-            return boost::unordered_detail::pair_cast<iterator, bool>(
-                base.insert(std::forward<Args>(args)...));
-        }
-
-        template <class... Args>
-        iterator emplace(const_iterator hint, Args&&... args)
-        {
-            return iterator(base.insert_hint(get(hint), std::forward<Args>(args)...));
-        }
-#endif
-
-        std::pair<iterator, bool> insert(const value_type& obj)
-        {
-            return boost::unordered_detail::pair_cast<iterator, bool>(
-                    base.insert(obj));
-        }
-
-        iterator insert(const_iterator hint, const value_type& obj)
-        {
-            return iterator(base.insert_hint(get(hint), obj));
-        }
-
-        template <class InputIterator>
-            void insert(InputIterator first, InputIterator last)
-        {
-            base.insert_range(first, last);
-        }
-
-        iterator erase(const_iterator position)
-        {
-            return iterator(base.data_.erase(get(position)));
-        }
-
-        size_type erase(const key_type& k)
-        {
-            return base.erase_key(k);
-        }
-
-        iterator erase(const_iterator first, const_iterator last)
-        {
-            return iterator(base.data_.erase_range(get(first), get(last)));
-        }
-
-        void clear()
-        {
-            base.data_.clear();
-        }
-
-        void swap(unordered_map& other)
-        {
-            base.swap(other.base);
-        }
-
-        // observers
-
-        hasher hash_function() const
-        {
-            return base.hash_function();
-        }
-
-        key_equal key_eq() const
-        {
-            return base.key_eq();
-        }
-
-        mapped_type& operator[](const key_type &k)
-        {
-            return base[k].second;
-        }
-
-        mapped_type& at(const key_type& k)
-        {
-            return base.at(k).second;
-        }
-
-        mapped_type const& at(const key_type& k) const
-        {
-            return base.at(k).second;
-        }
-
-        // lookup
-
-        iterator find(const key_type& k)
-        {
-            return iterator(base.find(k));
-        }
-
-        const_iterator find(const key_type& k) const
-        {
-            return const_iterator(base.find(k));
-        }
-
-        size_type count(const key_type& k) const
-        {
-            return base.count(k);
-        }
-
-        std::pair<iterator, iterator>
-            equal_range(const key_type& k)
-        {
-            return boost::unordered_detail::pair_cast<iterator, iterator>(
-                    base.equal_range(k));
-        }
-
-        std::pair<const_iterator, const_iterator>
-            equal_range(const key_type& k) const
-        {
-            return boost::unordered_detail::pair_cast<const_iterator, const_iterator>(
-                    base.equal_range(k));
-        }
-
-        // bucket interface
-
-        size_type bucket_count() const
-        {
-            return base.bucket_count();
-        }
-
-        size_type max_bucket_count() const
-        {
-            return base.max_bucket_count();
-        }
-
-        size_type bucket_size(size_type n) const
-        {
-            return base.data_.bucket_size(n);
-        }
-
-        size_type bucket(const key_type& k) const
-        {
-            return base.bucket(k);
-        }
-
-        local_iterator begin(size_type n)
-        {
-            return local_iterator(base.data_.begin(n));
-        }
-
-        const_local_iterator begin(size_type n) const
-        {
-            return const_local_iterator(base.data_.begin(n));
-        }
-
-        local_iterator end(size_type n)
-        {
-            return local_iterator(base.data_.end(n));
-        }
-
-        const_local_iterator end(size_type n) const
-        {
-            return const_local_iterator(base.data_.end(n));
-        }
-
-        const_local_iterator cbegin(size_type n) const
-        {
-            return const_local_iterator(base.data_.begin(n));
-        }
-
-        const_local_iterator cend(size_type n) const
-        {
-            return const_local_iterator(base.data_.end(n));
-        }
-
-        // hash policy
-
-        float load_factor() const
-        {
-            return base.load_factor();
-        }
-
-        float max_load_factor() const
-        {
-            return base.max_load_factor();
-        }
-
-        void max_load_factor(float m)
-        {
-            base.max_load_factor(m);
-        }
-
-        void rehash(size_type n)
-        {
-            base.rehash(n);
-        }
-        
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-        friend bool operator==(unordered_map const&, unordered_map const&);
-        friend bool operator!=(unordered_map const&, unordered_map const&);
-#else
-        friend bool operator==<>(unordered_map const&, unordered_map const&);
-        friend bool operator!=<>(unordered_map const&, unordered_map const&);
-#endif
-    }; // class template unordered_map
-
-    template <class K, class T, class H, class P, class A>
-    inline bool operator==(unordered_map<K, T, H, P, A> const& m1,
-        unordered_map<K, T, H, P, A> const& m2)
-    {
-        return boost::unordered_detail::equals(m1.base, m2.base);
-    }
-
-    template <class K, class T, class H, class P, class A>
-    inline bool operator!=(unordered_map<K, T, H, P, A> const& m1,
-        unordered_map<K, T, H, P, A> const& m2)
-    {
-        return !boost::unordered_detail::equals(m1.base, m2.base);
-    }
-
-    template <class K, class T, class H, class P, class A>
-    inline void swap(unordered_map<K, T, H, P, A> &m1,
-            unordered_map<K, T, H, P, A> &m2)
-    {
-        m1.swap(m2);
-    }
-
-    template <class Key, class T, class Hash, class Pred, class Alloc>
-    class unordered_multimap
-    {
-        typedef boost::unordered_detail::hash_types_equivalent_keys<
-            std::pair<const Key, T>, Key, Hash, Pred, Alloc
-        > implementation;
-
-        BOOST_DEDUCED_TYPENAME implementation::hash_table base;
-
-        public:
-
-        // types
-
-        typedef Key key_type;
-        typedef std::pair<const Key, T> value_type;
-        typedef T mapped_type;
-        typedef Hash hasher;
-        typedef Pred key_equal;
-
-        typedef Alloc allocator_type;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::pointer pointer;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::const_pointer const_pointer;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::reference reference;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::const_reference const_reference;
-
-        typedef BOOST_DEDUCED_TYPENAME implementation::size_type size_type;
-        typedef BOOST_DEDUCED_TYPENAME implementation::difference_type difference_type;
-
-        typedef BOOST_DEDUCED_TYPENAME implementation::iterator iterator;
-        typedef BOOST_DEDUCED_TYPENAME implementation::const_iterator const_iterator;
-        typedef BOOST_DEDUCED_TYPENAME implementation::local_iterator local_iterator;
-        typedef BOOST_DEDUCED_TYPENAME implementation::const_local_iterator const_local_iterator;
-
-        // construct/destroy/copy
-
-        explicit unordered_multimap(
-                size_type n = boost::unordered_detail::default_initial_bucket_count,
-                const hasher &hf = hasher(),
-                const key_equal &eql = key_equal(),
-                const allocator_type &a = allocator_type())
-          : base(n, hf, eql, a)
-        {
-        }
-
-        explicit unordered_multimap(allocator_type const& a)
-            : base(boost::unordered_detail::default_initial_bucket_count,
-                hasher(), key_equal(), a)
-        {
-        }
-
-        unordered_multimap(unordered_multimap const& other, allocator_type const& a)
-            : base(other.base, a)
-        {
-        }
-
-        template <class InputIterator>
-        unordered_multimap(InputIterator f, InputIterator l)
-            : base(f, l, boost::unordered_detail::default_initial_bucket_count,
-                hasher(), key_equal(), allocator_type())
-        {
-        }
-
-        template <class InputIterator>
-        unordered_multimap(InputIterator f, InputIterator l,
-                size_type n,
-                const hasher &hf = hasher(),
-                const key_equal &eql = key_equal(),
-                const allocator_type &a = allocator_type())
-          : base(f, l, n, hf, eql, a)
-        {
-        }
-
-#if defined(BOOST_HAS_RVALUE_REFS)
-        unordered_multimap(unordered_multimap&& other)
-            : base(other.base, boost::unordered_detail::move_tag())
-        {
-        }
-
-        unordered_multimap(unordered_multimap&& other, allocator_type const& a)
-            : base(other.base, a, boost::unordered_detail::move_tag())
-        {
-        }
-
-        unordered_multimap& operator=(unordered_multimap&& x)
-        {
-            base.move(x.base);
-            return *this;
-        }
-#else
-        unordered_multimap(boost::unordered_detail::move_from<unordered_multimap<Key, T, Hash, Pred, Alloc> > other)
-            : base(other.source.base, boost::unordered_detail::move_tag())
-        {
-        }
-
-#if !BOOST_WORKAROUND(__BORLANDC__, < 0x0593)
-        unordered_multimap& operator=(unordered_multimap x)
-        {
-            base.move(x.base);
-            return *this;
-        }
-#endif
-#endif
-
-
-    private:
-
-        BOOST_DEDUCED_TYPENAME implementation::iterator_base const&
-            get(const_iterator const& it)
-        {
-            return boost::unordered_detail::iterator_access::get(it);
-        }
-
-    public:
-
-        allocator_type get_allocator() const
-        {
-            return base.get_allocator();
-        }
-
-        // size and capacity
-
-        bool empty() const
-        {
-            return base.empty();
-        }
-
-        size_type size() const
-        {
-            return base.size();
-        }
-
-        size_type max_size() const
-        {
-            return base.max_size();
-        }
-
-        // iterators
-
-        iterator begin()
-        {
-            return iterator(base.data_.begin());
-        }
-
-        const_iterator begin() const
-        {
-            return const_iterator(base.data_.begin());
-        }
-
-        iterator end()
-        {
-            return iterator(base.data_.end());
-        }
-
-        const_iterator end() const
-        {
-            return const_iterator(base.data_.end());
-        }
-
-        const_iterator cbegin() const
-        {
-            return const_iterator(base.data_.begin());
-        }
-
-        const_iterator cend() const
-        {
-            return const_iterator(base.data_.end());
-        }
-
-        // modifiers
-
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
-        template <class... Args>
-        iterator emplace(Args&&... args)
-        {
-            return iterator(base.insert(std::forward<Args>(args)...));
-        }
-
-        template <class... Args>
-        iterator emplace(const_iterator hint, Args&&... args)
-        {
-            return iterator(base.insert_hint(get(hint), std::forward<Args>(args)...));
-        }
-#endif
-
-        iterator insert(const value_type& obj)
-        {
-            return iterator(base.insert(obj));
-        }
-
-        iterator insert(const_iterator hint, const value_type& obj)
-        {
-            return iterator(base.insert_hint(get(hint), obj));
-        }
-
-        template <class InputIterator>
-            void insert(InputIterator first, InputIterator last)
-        {
-            base.insert_range(first, last);
-        }
-
-        iterator erase(const_iterator position)
-        {
-            return iterator(base.data_.erase(get(position)));
-        }
-
-        size_type erase(const key_type& k)
-        {
-            return base.erase_key(k);
-        }
-
-        iterator erase(const_iterator first, const_iterator last)
-        {
-            return iterator(base.data_.erase_range(get(first), get(last)));
-        }
-
-        void clear()
-        {
-            base.data_.clear();
-        }
-
-        void swap(unordered_multimap& other)
-        {
-            base.swap(other.base);
-        }
-
-        // observers
-
-        hasher hash_function() const
-        {
-            return base.hash_function();
-        }
-
-        key_equal key_eq() const
-        {
-            return base.key_eq();
-        }
-
-        // lookup
-
-        iterator find(const key_type& k)
-        {
-            return iterator(base.find(k));
-        }
-
-        const_iterator find(const key_type& k) const
-        {
-            return const_iterator(base.find(k));
-        }
-
-        size_type count(const key_type& k) const
-        {
-            return base.count(k);
-        }
-
-        std::pair<iterator, iterator>
-            equal_range(const key_type& k)
-        {
-            return boost::unordered_detail::pair_cast<iterator, iterator>(
-                    base.equal_range(k));
-        }
-
-        std::pair<const_iterator, const_iterator>
-            equal_range(const key_type& k) const
-        {
-            return boost::unordered_detail::pair_cast<const_iterator, const_iterator>(
-                    base.equal_range(k));
-        }
-
-        // bucket interface
-
-        size_type bucket_count() const
-        {
-            return base.bucket_count();
-        }
-
-        size_type max_bucket_count() const
-        {
-            return base.max_bucket_count();
-        }
-
-        size_type bucket_size(size_type n) const
-        {
-            return base.data_.bucket_size(n);
-        }
-
-        size_type bucket(const key_type& k) const
-        {
-            return base.bucket(k);
-        }
-
-        local_iterator begin(size_type n)
-        {
-            return local_iterator(base.data_.begin(n));
-        }
-
-        const_local_iterator begin(size_type n) const
-        {
-            return const_local_iterator(base.data_.begin(n));
-        }
-
-        local_iterator end(size_type n)
-        {
-            return local_iterator(base.data_.end(n));
-        }
-
-        const_local_iterator end(size_type n) const
-        {
-            return const_local_iterator(base.data_.end(n));
-        }
-
-        const_local_iterator cbegin(size_type n) const
-        {
-            return const_local_iterator(base.data_.begin(n));
-        }
-
-        const_local_iterator cend(size_type n) const
-        {
-            return const_local_iterator(base.data_.end(n));
-        }
-
-        // hash policy
-
-        float load_factor() const
-        {
-            return base.load_factor();
-        }
-
-        float max_load_factor() const
-        {
-            return base.max_load_factor();
-        }
-
-        void max_load_factor(float m)
-        {
-            base.max_load_factor(m);
-        }
-
-        void rehash(size_type n)
-        {
-            base.rehash(n);
-        }
-
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-        friend bool operator==(unordered_multimap const&, unordered_multimap const&);
-        friend bool operator!=(unordered_multimap const&, unordered_multimap const&);
-#else
-        friend bool operator==<>(unordered_multimap const&, unordered_multimap const&);
-        friend bool operator!=<>(unordered_multimap const&, unordered_multimap const&);
-#endif
-    }; // class template unordered_multimap
-
-    template <class K, class T, class H, class P, class A>
-    inline bool operator==(unordered_multimap<K, T, H, P, A> const& m1,
-        unordered_multimap<K, T, H, P, A> const& m2)
-    {
-        return boost::unordered_detail::equals(m1.base, m2.base);
-    }
-
-    template <class K, class T, class H, class P, class A>
-    inline bool operator!=(unordered_multimap<K, T, H, P, A> const& m1,
-        unordered_multimap<K, T, H, P, A> const& m2)
-    {
-        return !boost::unordered_detail::equals(m1.base, m2.base);
-    }
-
-    template <class K, class T, class H, class P, class A>
-    inline void swap(unordered_multimap<K, T, H, P, A> &m1,
-            unordered_multimap<K, T, H, P, A> &m2)
-    {
-        m1.swap(m2);
-    }
-
-} // namespace boost
+#include <boost/unordered/unordered_map.hpp>
 
 #endif // BOOST_UNORDERED_MAP_HPP_INCLUDED

include/boost/unordered_set.hpp

@@ -13,767 +13,6 @@
 # pragma once
 #endif
 
-#include <boost/config.hpp>
-
-#include <functional>
-#include <memory>
-
-#include <boost/functional/hash.hpp>
-#include <boost/unordered/detail/hash_table.hpp>
-
-#if !defined(BOOST_HAS_RVALUE_REFS)
-#include <boost/unordered/detail/move.hpp>
-#endif
-
-namespace boost
-{
-    template <class Value,
-        class Hash = hash<Value>,
-        class Pred = std::equal_to<Value>,
-        class Alloc = std::allocator<Value> >
-    class unordered_set;
-    template <class T, class H, class P, class A>
-    bool operator==(unordered_set<T, H, P, A> const&,
-        unordered_set<T, H, P, A> const&);
-    template <class T, class H, class P, class A>
-    bool operator!=(unordered_set<T, H, P, A> const&,
-        unordered_set<T, H, P, A> const&);
-    template <class T, class H, class P, class A>
-    void swap(unordered_set<T, H, P, A> &m1,
-            unordered_set<T, H, P, A> &m2);
-
-    template <class Value,
-        class Hash = hash<Value>,
-        class Pred = std::equal_to<Value>,
-        class Alloc = std::allocator<Value> >
-    class unordered_multiset;
-    template <class T, class H, class P, class A>
-    bool operator==(unordered_multiset<T, H, P, A> const&,
-        unordered_multiset<T, H, P, A> const&);
-    template <class T, class H, class P, class A>
-    bool operator!=(unordered_multiset<T, H, P, A> const&,
-        unordered_multiset<T, H, P, A> const&);
-    template <class T, class H, class P, class A>
-    void swap(unordered_multiset<T, H, P, A> &m1,
-            unordered_multiset<T, H, P, A> &m2);
-
-    template <class Value, class Hash, class Pred, class Alloc>
-    class unordered_set
-    {
-        typedef boost::unordered_detail::hash_types_unique_keys<
-            Value, Value, Hash, Pred, Alloc
-        > implementation;
-
-        BOOST_DEDUCED_TYPENAME implementation::hash_table base;
-
-    public:
-
-        // types
-
-        typedef Value key_type;
-        typedef Value value_type;
-        typedef Hash hasher;
-        typedef Pred key_equal;
-
-        typedef Alloc allocator_type;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::pointer pointer;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::const_pointer const_pointer;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::reference reference;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::const_reference const_reference;
-
-        typedef BOOST_DEDUCED_TYPENAME implementation::size_type size_type;
-        typedef BOOST_DEDUCED_TYPENAME implementation::difference_type difference_type;
-
-        typedef BOOST_DEDUCED_TYPENAME implementation::const_iterator iterator;
-        typedef BOOST_DEDUCED_TYPENAME implementation::const_iterator const_iterator;
-        typedef BOOST_DEDUCED_TYPENAME implementation::const_local_iterator local_iterator;
-        typedef BOOST_DEDUCED_TYPENAME implementation::const_local_iterator const_local_iterator;
-
-        // construct/destroy/copy
-
-        explicit unordered_set(
-                size_type n = boost::unordered_detail::default_initial_bucket_count,
-                const hasher &hf = hasher(),
-                const key_equal &eql = key_equal(),
-                const allocator_type &a = allocator_type())
-            : base(n, hf, eql, a)
-        {
-        }
-
-        explicit unordered_set(allocator_type const& a)
-            : base(boost::unordered_detail::default_initial_bucket_count,
-                hasher(), key_equal(), a)
-        {
-        }
-
-        unordered_set(unordered_set const& other, allocator_type const& a)
-            : base(other.base, a)
-        {
-        }
-
-        template <class InputIterator>
-        unordered_set(InputIterator f, InputIterator l)
-            : base(f, l, boost::unordered_detail::default_initial_bucket_count,
-                hasher(), key_equal(), allocator_type())
-        {
-        }
-
-        template <class InputIterator>
-        unordered_set(InputIterator f, InputIterator l, size_type n,
-                const hasher &hf = hasher(),
-                const key_equal &eql = key_equal(),
-                const allocator_type &a = allocator_type())
-            : base(f, l, n, hf, eql, a)
-        {
-        }
-
-#if defined(BOOST_HAS_RVALUE_REFS)
-        unordered_set(unordered_set&& other)
-            : base(other.base, boost::unordered_detail::move_tag())
-        {
-        }
-
-        unordered_set(unordered_set&& other, allocator_type const& a)
-            : base(other.base, a, boost::unordered_detail::move_tag())
-        {
-        }
-
-        unordered_set& operator=(unordered_set&& x)
-        {
-            base.move(x.base);
-            return *this;
-        }
-#else
-        unordered_set(boost::unordered_detail::move_from<unordered_set<Value, Hash, Pred, Alloc> > other)
-            : base(other.source.base, boost::unordered_detail::move_tag())
-        {
-        }
-
-#if !BOOST_WORKAROUND(__BORLANDC__, < 0x0593)
-        unordered_set& operator=(unordered_set x)
-        {
-            base.move(x.base);
-            return *this;
-        }
-#endif
-#endif
-
-    private:
-
-        BOOST_DEDUCED_TYPENAME implementation::iterator_base const&
-            get(const_iterator const& it)
-        {
-            return boost::unordered_detail::iterator_access::get(it);
-        }
-
-    public:
-
-        allocator_type get_allocator() const
-        {
-            return base.get_allocator();
-        }
-
-        // size and capacity
-
-        bool empty() const
-        {
-            return base.empty();
-        }
-
-        size_type size() const
-        {
-            return base.size();
-        }
-
-        size_type max_size() const
-        {
-            return base.max_size();
-        }
-
-        // iterators
-
-        iterator begin()
-        {
-            return iterator(base.data_.begin());
-        }
-
-        const_iterator begin() const
-        {
-            return const_iterator(base.data_.begin());
-        }
-
-        iterator end()
-        {
-            return iterator(base.data_.end());
-        }
-
-        const_iterator end() const
-        {
-            return const_iterator(base.data_.end());
-        }
-
-        const_iterator cbegin() const
-        {
-            return const_iterator(base.data_.begin());
-        }
-
-        const_iterator cend() const
-        {
-            return const_iterator(base.data_.end());
-        }
-
-        // modifiers
-
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
-        template <class... Args>
-        std::pair<iterator, bool> emplace(Args&&... args)
-        {
-            return boost::unordered_detail::pair_cast<iterator, bool>(
-                base.insert(std::forward<Args>(args)...));
-        }
-
-        template <class... Args>
-        iterator emplace(const_iterator hint, Args&&... args)
-        {
-            return iterator(
-                base.insert_hint(get(hint), std::forward<Args>(args)...));
-        }
-#endif
-
-        std::pair<iterator, bool> insert(const value_type& obj)
-        {
-            return boost::unordered_detail::pair_cast<iterator, bool>(
-                    base.insert(obj));
-        }
-
-        iterator insert(const_iterator hint, const value_type& obj)
-        {
-            return iterator(base.insert_hint(get(hint), obj));
-        }
-
-        template <class InputIterator>
-            void insert(InputIterator first, InputIterator last)
-        {
-            base.insert_range(first, last);
-        }
-
-        iterator erase(const_iterator position)
-        {
-            return iterator(base.data_.erase(get(position)));
-        }
-
-        size_type erase(const key_type& k)
-        {
-            return base.erase_key(k);
-        }
-
-        iterator erase(const_iterator first, const_iterator last)
-        {
-            return iterator(base.data_.erase_range(get(first), get(last)));
-        }
-
-        void clear()
-        {
-            base.data_.clear();
-        }
-
-        void swap(unordered_set& other)
-        {
-            base.swap(other.base);
-        }
-
-        // observers
-
-        hasher hash_function() const
-        {
-            return base.hash_function();
-        }
-
-        key_equal key_eq() const
-        {
-            return base.key_eq();
-        }
-
-        // lookup
-
-        const_iterator find(const key_type& k) const
-        {
-            return const_iterator(base.find(k));
-        }
-
-        size_type count(const key_type& k) const
-        {
-            return base.count(k);
-        }
-
-        std::pair<const_iterator, const_iterator>
-            equal_range(const key_type& k) const
-        {
-            return boost::unordered_detail::pair_cast<const_iterator, const_iterator>(
-                    base.equal_range(k));
-        }
-
-        // bucket interface
-
-        size_type bucket_count() const
-        {
-            return base.bucket_count();
-        }
-
-        size_type max_bucket_count() const
-        {
-            return base.max_bucket_count();
-        }
-
-        size_type bucket_size(size_type n) const
-        {
-            return base.data_.bucket_size(n);
-        }
-
-        size_type bucket(const key_type& k) const
-        {
-            return base.bucket(k);
-        }
-
-        local_iterator begin(size_type n)
-        {
-            return local_iterator(base.data_.begin(n));
-        }
-
-        const_local_iterator begin(size_type n) const
-        {
-            return const_local_iterator(base.data_.begin(n));
-        }
-
-        local_iterator end(size_type n)
-        {
-            return local_iterator(base.data_.end(n));
-        }
-
-        const_local_iterator end(size_type n) const
-        {
-            return const_local_iterator(base.data_.end(n));
-        }
-
-        const_local_iterator cbegin(size_type n) const
-        {
-            return const_local_iterator(base.data_.begin(n));
-        }
-
-        const_local_iterator cend(size_type n) const
-        {
-            return const_local_iterator(base.data_.end(n));
-        }
-
-        // hash policy
-
-        float load_factor() const
-        {
-            return base.load_factor();
-        }
-
-        float max_load_factor() const
-        {
-            return base.max_load_factor();
-        }
-
-        void max_load_factor(float m)
-        {
-            base.max_load_factor(m);
-        }
-
-        void rehash(size_type n)
-        {
-            base.rehash(n);
-        }
-
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-        friend bool operator==(unordered_set const&, unordered_set const&);
-        friend bool operator!=(unordered_set const&, unordered_set const&);
-#else
-        friend bool operator==<>(unordered_set const&, unordered_set const&);
-        friend bool operator!=<>(unordered_set const&, unordered_set const&);
-#endif
-    }; // class template unordered_set
-
-    template <class T, class H, class P, class A>
-    inline bool operator==(unordered_set<T, H, P, A> const& m1,
-        unordered_set<T, H, P, A> const& m2)
-    {
-        return boost::unordered_detail::equals(m1.base, m2.base);
-    }
-
-    template <class T, class H, class P, class A>
-    inline bool operator!=(unordered_set<T, H, P, A> const& m1,
-        unordered_set<T, H, P, A> const& m2)
-    {
-        return !boost::unordered_detail::equals(m1.base, m2.base);
-    }
-
-    template <class T, class H, class P, class A>
-    inline void swap(unordered_set<T, H, P, A> &m1,
-            unordered_set<T, H, P, A> &m2)
-    {
-        m1.swap(m2);
-    }
-
-    template <class Value, class Hash, class Pred, class Alloc>
-    class unordered_multiset
-    {
-        typedef boost::unordered_detail::hash_types_equivalent_keys<
-            Value, Value, Hash, Pred, Alloc
-        > implementation;
-
-        BOOST_DEDUCED_TYPENAME implementation::hash_table base;
-
-    public:
-
-        //types
-
-        typedef Value key_type;
-        typedef Value value_type;
-        typedef Hash hasher;
-        typedef Pred key_equal;
-
-        typedef Alloc allocator_type;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::pointer pointer;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::const_pointer const_pointer;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::reference reference;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::const_reference const_reference;
-
-        typedef BOOST_DEDUCED_TYPENAME implementation::size_type size_type;
-        typedef BOOST_DEDUCED_TYPENAME implementation::difference_type difference_type;
-
-        typedef BOOST_DEDUCED_TYPENAME implementation::const_iterator iterator;
-        typedef BOOST_DEDUCED_TYPENAME implementation::const_iterator const_iterator;
-        typedef BOOST_DEDUCED_TYPENAME implementation::const_local_iterator local_iterator;
-        typedef BOOST_DEDUCED_TYPENAME implementation::const_local_iterator const_local_iterator;
-
-        // construct/destroy/copy
-
-        explicit unordered_multiset(
-                size_type n = boost::unordered_detail::default_initial_bucket_count,
-                const hasher &hf = hasher(),
-                const key_equal &eql = key_equal(),
-                const allocator_type &a = allocator_type())
-          : base(n, hf, eql, a)
-        {
-        }
-
-        explicit unordered_multiset(allocator_type const& a)
-            : base(boost::unordered_detail::default_initial_bucket_count,
-                hasher(), key_equal(), a)
-        {
-        }
-
-        unordered_multiset(unordered_multiset const& other, allocator_type const& a)
-            : base(other.base, a)
-        {
-        }
-
-        template <class InputIterator>
-        unordered_multiset(InputIterator f, InputIterator l)
-            : base(f, l, boost::unordered_detail::default_initial_bucket_count,
-                hasher(), key_equal(), allocator_type())
-        {
-        }
-
-        template <class InputIterator>
-        unordered_multiset(InputIterator f, InputIterator l, size_type n,
-                const hasher &hf = hasher(),
-                const key_equal &eql = key_equal(),
-                const allocator_type &a = allocator_type())
-          : base(f, l, n, hf, eql, a)
-        {
-        }
-
-#if defined(BOOST_HAS_RVALUE_REFS)
-        unordered_multiset(unordered_multiset&& other)
-            : base(other.base, boost::unordered_detail::move_tag())
-        {
-        }
-
-        unordered_multiset(unordered_multiset&& other, allocator_type const& a)
-            : base(other.base, a, boost::unordered_detail::move_tag())
-        {
-        }
-
-        unordered_multiset& operator=(unordered_multiset&& x)
-        {
-            base.move(x.base);
-            return *this;
-        }
-#else
-        unordered_multiset(boost::unordered_detail::move_from<unordered_multiset<Value, Hash, Pred, Alloc> > other)
-            : base(other.source.base, boost::unordered_detail::move_tag())
-        {
-        }
-
-#if !BOOST_WORKAROUND(__BORLANDC__, < 0x0593)
-        unordered_multiset& operator=(unordered_multiset x)
-        {
-            base.move(x.base);
-            return *this;
-        }
-#endif
-#endif
-
-    private:
-
-        BOOST_DEDUCED_TYPENAME implementation::iterator_base const&
-            get(const_iterator const& it)
-        {
-            return boost::unordered_detail::iterator_access::get(it);
-        }
-
-    public:
-
-        allocator_type get_allocator() const
-        {
-            return base.get_allocator();
-        }
-
-        // size and capacity
-
-        bool empty() const
-        {
-            return base.empty();
-        }
-
-        size_type size() const
-        {
-            return base.size();
-        }
-
-        size_type max_size() const
-        {
-            return base.max_size();
-        }
-
-        // iterators
-
-        iterator begin()
-        {
-            return iterator(base.data_.begin());
-        }
-
-        const_iterator begin() const
-        {
-            return const_iterator(base.data_.begin());
-        }
-
-        iterator end()
-        {
-            return iterator(base.data_.end());
-        }
-
-        const_iterator end() const
-        {
-            return const_iterator(base.data_.end());
-        }
-
-        const_iterator cbegin() const
-        {
-            return const_iterator(base.data_.begin());
-        }
-
-        const_iterator cend() const
-        {
-            return const_iterator(base.data_.end());
-        }
-
-        // modifiers
-
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
-        template <class... Args>
-        iterator emplace(Args&&... args)
-        {
-            return iterator(base.insert(std::forward<Args>(args)...));
-        }
-
-        template <class... Args>
-        iterator emplace(const_iterator hint, Args&&... args)
-        {
-            return iterator(base.insert_hint(get(hint), std::forward<Args>(args)...));
-        }
-#endif
-
-        iterator insert(const value_type& obj)
-        {
-            return iterator(base.insert(obj));
-        }
-
-        iterator insert(const_iterator hint, const value_type& obj)
-        {
-            return iterator(base.insert_hint(get(hint), obj));
-        }
-
-        template <class InputIterator>
-            void insert(InputIterator first, InputIterator last)
-        {
-            base.insert_range(first, last);
-        }
-
-        iterator erase(const_iterator position)
-        {
-            return iterator(base.data_.erase(get(position)));
-        }
-
-        size_type erase(const key_type& k)
-        {
-            return base.erase_key(k);
-        }
-
-        iterator erase(const_iterator first, const_iterator last)
-        {
-            return iterator(base.data_.erase_range(get(first), get(last)));
-        }
-
-        void clear()
-        {
-            base.data_.clear();
-        }
-
-        void swap(unordered_multiset& other)
-        {
-            base.swap(other.base);
-        }
-
-        // observers
-
-        hasher hash_function() const
-        {
-            return base.hash_function();
-        }
-
-        key_equal key_eq() const
-        {
-            return base.key_eq();
-        }
-
-        // lookup
-
-        const_iterator find(const key_type& k) const
-        {
-            return const_iterator(base.find(k));
-        }
-
-        size_type count(const key_type& k) const
-        {
-            return base.count(k);
-        }
-
-        std::pair<const_iterator, const_iterator>
-            equal_range(const key_type& k) const
-        {
-            return boost::unordered_detail::pair_cast<const_iterator, const_iterator>(
-                    base.equal_range(k));
-        }
-
-        // bucket interface
-
-        size_type bucket_count() const
-        {
-            return base.bucket_count();
-        }
-
-        size_type max_bucket_count() const
-        {
-            return base.max_bucket_count();
-        }
-
-        size_type bucket_size(size_type n) const
-        {
-            return base.data_.bucket_size(n);
-        }
-
-        size_type bucket(const key_type& k) const
-        {
-            return base.bucket(k);
-        }
-
-        local_iterator begin(size_type n)
-        {
-            return local_iterator(base.data_.begin(n));
-        }
-
-        const_local_iterator begin(size_type n) const
-        {
-            return const_local_iterator(base.data_.begin(n));
-        }
-
-        local_iterator end(size_type n)
-        {
-            return local_iterator(base.data_.end(n));
-        }
-
-        const_local_iterator end(size_type n) const
-        {
-            return const_local_iterator(base.data_.end(n));
-        }
-
-        const_local_iterator cbegin(size_type n) const
-        {
-            return const_local_iterator(base.data_.begin(n));
-        }
-
-        const_local_iterator cend(size_type n) const
-        {
-            return const_local_iterator(base.data_.end(n));
-        }
-
-        // hash policy
-
-        float load_factor() const
-        {
-            return base.load_factor();
-        }
-
-        float max_load_factor() const
-        {
-            return base.max_load_factor();
-        }
-
-        void max_load_factor(float m)
-        {
-            base.max_load_factor(m);
-        }
-
-        void rehash(size_type n)
-        {
-            base.rehash(n);
-        }
-
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-        friend bool operator==(unordered_multiset const&, unordered_multiset const&);
-        friend bool operator!=(unordered_multiset const&, unordered_multiset const&);
-#else
-        friend bool operator==<>(unordered_multiset const&, unordered_multiset const&);
-        friend bool operator!=<>(unordered_multiset const&, unordered_multiset const&);
-#endif
-    }; // class template unordered_multiset
-
-    template <class T, class H, class P, class A>
-    inline bool operator==(unordered_multiset<T, H, P, A> const& m1,
-        unordered_multiset<T, H, P, A> const& m2)
-    {
-        return boost::unordered_detail::equals(m1.base, m2.base);
-    }
-
-    template <class T, class H, class P, class A>
-    inline bool operator!=(unordered_multiset<T, H, P, A> const& m1,
-        unordered_multiset<T, H, P, A> const& m2)
-    {
-        return !boost::unordered_detail::equals(m1.base, m2.base);
-    }
-
-    template <class T, class H, class P, class A>
-    inline void swap(unordered_multiset<T, H, P, A> &m1,
-            unordered_multiset<T, H, P, A> &m2)
-    {
-        m1.swap(m2);
-    }
-
-} // namespace boost
+#include <boost/unordered/unordered_set.hpp>
 
 #endif // BOOST_UNORDERED_SET_HPP_INCLUDED

test/Jamfile.v2

@@ -3,5 +3,7 @@
 # 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)
 
+import testing ;
+
 build-project unordered ;
 build-project exception ;

test/exception/Jamfile.v2

@@ -10,8 +10,15 @@ alias framework : ;
 
 project unordered-test/exception-tests
     : requirements
-        <toolset>intel-linux:"<cxxflags>-strict_ansi -cxxlib-icc"
-        <toolset>gcc:<cxxflags>"-Wsign-promo -Wunused-parameter"
+        <warnings>all
+        <toolset>intel:<warnings>on
+        <toolset>gcc:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter"
+        <toolset>darwin:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter"
+        #<toolset>gcc:<define>_GLIBCXX_DEBUG
+        #<toolset>darwin:<define>_GLIBCXX_DEBUG
+        #<toolset>msvc:<warnings-as-errors>on
+        #<toolset>gcc:<warnings-as-errors>on
+        #<toolset>darwin:<warnings-as-errors>on
     ;
 
 test-suite unordered-exception

test/exception/assign_exception_tests.cpp

@@ -1,12 +1,18 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
+#include "../helpers/prefix.hpp"
+
 #include "./containers.hpp"
 #include "../helpers/random_values.hpp"
 #include "../helpers/invariants.hpp"
 
+#if defined(BOOST_MSVC)
+#pragma warning(disable:4512) // assignment operator could not be generated
+#endif
+
 test::seed_t seed(12847);
 
 template <class T>
@@ -18,7 +24,8 @@ struct self_assign_base : public test::exception_base
     typedef T data_type;
     T init() const { return T(values.begin(), values.end()); }
     void run(T& x) const { x = x; }
-    void check(T const& x) const { test::check_equivalent_keys(x); }
+    void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const
+        { test::check_equivalent_keys(x); }
 };
 
 template <class T>
@@ -40,15 +47,20 @@ struct assign_base : public test::exception_base
     typedef BOOST_DEDUCED_TYPENAME T::key_equal key_equal;
     typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
 
-    assign_base(unsigned int count1, unsigned int count2, int tag1, int tag2)
-        : x_values(count1), y_values(count2),
-        x(x_values.begin(), x_values.end(), 0, hasher(tag1), key_equal(tag1), allocator_type(tag1)),
-        y(y_values.begin(), y_values.end(), 0, hasher(tag2), key_equal(tag2), allocator_type(tag2)) {}
+    assign_base(unsigned int count1, unsigned int count2, int tag1, int tag2) :
+        x_values(count1),
+        y_values(count2),
+        x(x_values.begin(), x_values.end(), 0, hasher(tag1), key_equal(tag1),
+            allocator_type(tag1)),
+        y(y_values.begin(), y_values.end(), 0, hasher(tag2), key_equal(tag2),
+            allocator_type(tag2))
+    {}
 
     typedef T data_type;
     T init() const { return T(x); }
     void run(T& x1) const { x1 = y; }
-    void check(T const& x1) const { test::check_equivalent_keys(x1); }
+    void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x1) const
+        { test::check_equivalent_keys(x1); }
 };
 
 template <class T>

test/exception/constructor_exception_tests.cpp

@@ -1,12 +1,16 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
+#include "../helpers/prefix.hpp"
+
 #include "./containers.hpp"
 #include "../helpers/random_values.hpp"
 #include "../helpers/input_iterator.hpp"
 
+template <typename T> inline void avoid_unused_warning(T const&) {}
+
 test::seed_t seed(91274);
 
 struct objects
@@ -22,6 +26,7 @@ struct construct_test1 : public objects, test::exception_base
 {
     void run() const {
         T x;
+        avoid_unused_warning(x);
     }
 };
 
@@ -30,6 +35,7 @@ struct construct_test2 : public objects, test::exception_base
 {
     void run() const {
         T x(300);
+        avoid_unused_warning(x);
     }
 };
 
@@ -38,6 +44,7 @@ struct construct_test3 : public objects, test::exception_base
 {
     void run() const {
         T x(0, hash);
+        avoid_unused_warning(x);
     }
 };
 
@@ -46,6 +53,7 @@ struct construct_test4 : public objects, test::exception_base
 {
     void run() const {
         T x(0, hash, equal_to);
+        avoid_unused_warning(x);
     }
 };
 
@@ -54,6 +62,7 @@ struct construct_test5 : public objects, test::exception_base
 {
     void run() const {
         T x(50, hash, equal_to, allocator);
+        avoid_unused_warning(x);
     }
 };
 
@@ -62,6 +71,7 @@ struct construct_test6 : public objects, test::exception_base
 {
     void run() const {
         T x(allocator);
+        avoid_unused_warning(x);
     }
 };
 
@@ -79,6 +89,7 @@ struct range_construct_test1 : public range<T>, objects
 {
     void run() const {
         T x(this->values.begin(), this->values.end());
+        avoid_unused_warning(x);
     }
 };
 
@@ -87,6 +98,7 @@ struct range_construct_test2 : public range<T>, objects
 {
     void run() const {
         T x(this->values.begin(), this->values.end(), 0);
+        avoid_unused_warning(x);
     }
 };
 
@@ -95,6 +107,7 @@ struct range_construct_test3 : public range<T>, objects
 {
     void run() const {
         T x(this->values.begin(), this->values.end(), 0, hash);
+        avoid_unused_warning(x);
     }
 };
 
@@ -103,6 +116,7 @@ struct range_construct_test4 : public range<T>, objects
 {
     void run() const {
         T x(this->values.begin(), this->values.end(), 100, hash, equal_to);
+        avoid_unused_warning(x);
     }
 };
 
@@ -114,7 +128,9 @@ struct range_construct_test5 : public range<T>, objects
     range_construct_test5() : range<T>(60) {}
 
     void run() const {
-        T x(this->values.begin(), this->values.end(), 0, hash, equal_to, allocator);
+        T x(this->values.begin(), this->values.end(), 0,
+            hash, equal_to, allocator);
+        avoid_unused_warning(x);
     }
 };
 
@@ -124,14 +140,39 @@ struct input_range_construct_test : public range<T>, objects
     input_range_construct_test() : range<T>(60) {}
 
     void run() const {
-        T x(test::input_iterator(this->values.begin()),
-                test::input_iterator(this->values.end()),
+        BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
+            begin = this->values.begin(), end = this->values.end();
+        T x(test::input_iterator(begin), test::input_iterator(end),
                 0, hash, equal_to, allocator);
+        avoid_unused_warning(x);
+    }
+};
+
+template <class T>
+struct copy_range_construct_test : public range<T>, objects
+{
+    copy_range_construct_test() : range<T>(60) {}
+
+    void run() const {
+        T x(test::copy_iterator(this->values.begin()),
+                test::copy_iterator(this->values.end()),
+                0, hash, equal_to, allocator);
+        avoid_unused_warning(x);
     }
 };
 
 RUN_EXCEPTION_TESTS(
-    (construct_test1)(construct_test2)(construct_test3)(construct_test4)(construct_test5)(construct_test6)
-    (range_construct_test1)(range_construct_test2)(range_construct_test3)(range_construct_test4)(range_construct_test5)
-    (input_range_construct_test),
+    (construct_test1)
+    (construct_test2)
+    (construct_test3)
+    (construct_test4)
+    (construct_test5)
+    (construct_test6)
+    (range_construct_test1)
+    (range_construct_test2)
+    (range_construct_test3)
+    (range_construct_test4)
+    (range_construct_test5)
+    (input_range_construct_test)
+    (copy_range_construct_test),
     CONTAINER_SEQ)

test/exception/containers.hpp

@@ -1,5 +1,5 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 

test/exception/copy_exception_tests.cpp

@@ -1,11 +1,15 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
+#include "../helpers/prefix.hpp"
+
 #include "./containers.hpp"
 #include "../helpers/random_values.hpp"
 
+template <typename T> inline void avoid_unused_warning(T const&) {}
+
 test::seed_t seed(73041);
 
 template <class T>
@@ -15,6 +19,7 @@ struct copy_test1 : public test::exception_base
 
     void run() const {
         T y(x);
+        avoid_unused_warning(y);
     }
 };
 
@@ -28,6 +33,7 @@ struct copy_test2 : public test::exception_base
 
     void run() const {
         T y(x);
+        avoid_unused_warning(y);
     }
 };
 
@@ -41,6 +47,7 @@ struct copy_test3 : public test::exception_base
 
     void run() const {
         T y(x);
+        avoid_unused_warning(y);
     }
 };
 
@@ -55,6 +62,7 @@ struct copy_with_allocator_test : public test::exception_base
 
     void run() const {
         T y(x, allocator);
+        avoid_unused_warning(y);
     }
 };
 

test/exception/erase_exception_tests.cpp

@@ -1,8 +1,10 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
+#include "../helpers/prefix.hpp"
+
 #include "./containers.hpp"
 #include "../helpers/random_values.hpp"
 #include "../helpers/invariants.hpp"
@@ -22,10 +24,10 @@ struct erase_test_base : public test::exception_base
         return T(values.begin(), values.end());
     }
 
-    void check(T const& x) const {
+    void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const {
         std::string scope(test::scope);
 
-        BOOST_CHECK(scope.find("hash::") != std::string::npos ||
+        BOOST_TEST(scope.find("hash::") != std::string::npos ||
                 scope.find("equal_to::") != std::string::npos ||
                 scope == "operator==(object, object)");
 
@@ -38,7 +40,8 @@ struct erase_by_key_test1 : public erase_test_base<T>
 {
     void run(T& x) const
     {
-        typedef BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator iterator;
+        typedef BOOST_DEDUCED_TYPENAME
+            test::random_values<T>::const_iterator iterator;
 
         for(iterator it = this->values.begin(), end = this->values.end();
                 it != end; ++it)

test/exception/insert_exception_tests.cpp

@@ -1,14 +1,15 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
+#include "../helpers/prefix.hpp"
+
 #include "./containers.hpp"
 #include <string>
 #include "../helpers/random_values.hpp"
 #include "../helpers/invariants.hpp"
 #include "../helpers/strong.hpp"
-#include "../helpers/input_iterator.hpp"
 #include <boost/utility.hpp>
 #include <cmath>
 
@@ -27,16 +28,18 @@ struct insert_test_base : public test::exception_base
         return T();
     }
 
-    void check(T const& x, strong_type const& strong) const {
+    void check BOOST_PREVENT_MACRO_SUBSTITUTION(
+        T const& x, strong_type const& strong) const
+    {
         std::string scope(test::scope);
 
         if(scope.find("hash::operator()") == std::string::npos)
-            strong.test(x);
+            strong.test(x, test::exception::detail::tracker.count_allocations);
         test::check_equivalent_keys(x);
     }
 };
 
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
+#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
 
 template <class T>
 struct emplace_test1 : public insert_test_base<T>
@@ -45,9 +48,10 @@ struct emplace_test1 : public insert_test_base<T>
 
     void run(T& x, strong_type& strong) const {
         for(BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
-                it = this->values.begin(), end = this->values.end(); it != end; ++it)
+            it = this->values.begin(), end = this->values.end();
+            it != end; ++it)
         {
-            strong.store(x);
+            strong.store(x, test::exception::detail::tracker.count_allocations);
             x.emplace(*it);
         }
     }
@@ -62,9 +66,10 @@ struct insert_test1 : public insert_test_base<T>
 
     void run(T& x, strong_type& strong) const {
         for(BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
-                it = this->values.begin(), end = this->values.end(); it != end; ++it)
+            it = this->values.begin(), end = this->values.end();
+            it != end; ++it)
         {
-            strong.store(x);
+            strong.store(x, test::exception::detail::tracker.count_allocations);
             x.insert(*it);
         }
     }
@@ -77,9 +82,10 @@ struct insert_test2 : public insert_test_base<T>
 
     void run(T& x, strong_type& strong) const {
         for(BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
-                it = this->values.begin(), end = this->values.end(); it != end; ++it)
+            it = this->values.begin(), end = this->values.end();
+            it != end; ++it)
         {
-            strong.store(x);
+            strong.store(x, test::exception::detail::tracker.count_allocations);
             x.insert(x.begin(), *it);
         }
     }
@@ -92,7 +98,7 @@ struct insert_test3 : public insert_test_base<T>
         x.insert(this->values.begin(), this->values.end());
     }
 
-    void check(T const& x) const {
+    void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const {
         test::check_equivalent_keys(x);
     }
 };
@@ -104,9 +110,10 @@ struct insert_test4 : public insert_test_base<T>
 
     void run(T& x, strong_type& strong) const {
         for(BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
-                it = this->values.begin(), end = this->values.end(); it != end; ++it)
+            it = this->values.begin(), end = this->values.end();
+            it != end; ++it)
         {
-            strong.store(x);
+            strong.store(x, test::exception::detail::tracker.count_allocations);
             x.insert(it, boost::next(it));
         }
     }
@@ -128,10 +135,10 @@ struct insert_test_rehash1 : public insert_test_base<T>
         size_type bucket_count = x.bucket_count();
         size_type initial_elements = static_cast<size_type>(
             ceil(bucket_count * (double) x.max_load_factor()) - 1);
-        BOOST_REQUIRE(initial_elements < this->values.size());
+        BOOST_TEST(initial_elements < this->values.size());
         x.insert(this->values.begin(),
                 boost::next(this->values.begin(), initial_elements));
-        BOOST_REQUIRE(bucket_count == x.bucket_count());
+        BOOST_TEST(bucket_count == x.bucket_count());
         return x;
     }
 
@@ -141,16 +148,17 @@ struct insert_test_rehash1 : public insert_test_base<T>
         BOOST_DEDUCED_TYPENAME T::const_iterator pos = x.cbegin();
 
         for(BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
-            it = boost::next(this->values.begin(), x.size()), end = this->values.end();
+            it = boost::next(this->values.begin(), x.size()),
+                end = this->values.end();
             it != end && count < 10; ++it, ++count)
         {
-            strong.store(x);
+            strong.store(x, test::exception::detail::tracker.count_allocations);
             pos = x.insert(pos, *it);
         }
 
         // This isn't actually a failure, but it means the test isn't doing its
         // job.
-        BOOST_REQUIRE(x.bucket_count() != bucket_count);
+        BOOST_TEST(x.bucket_count() != bucket_count);
     }
 };
 
@@ -164,23 +172,25 @@ struct insert_test_rehash2 : public insert_test_rehash1<T>
         int count = 0;
 
         for(BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
-            it = boost::next(this->values.begin(), x.size()), end = this->values.end();
+            it = boost::next(this->values.begin(), x.size()),
+                end = this->values.end();
             it != end && count < 10; ++it, ++count)
         {
-            strong.store(x);
+            strong.store(x, test::exception::detail::tracker.count_allocations);
             x.insert(*it);
         }
 
         // This isn't actually a failure, but it means the test isn't doing its
         // job.
-        BOOST_REQUIRE(x.bucket_count() != bucket_count);
+        BOOST_TEST(x.bucket_count() != bucket_count);
     }
 };
 
 template <class T>
 struct insert_test_rehash3 : public insert_test_base<T>
 {
-    BOOST_DEDUCED_TYPENAME T::size_type mutable rehash_bucket_count, original_bucket_count;
+    BOOST_DEDUCED_TYPENAME T::size_type mutable
+        rehash_bucket_count, original_bucket_count;
 
     insert_test_rehash3() : insert_test_base<T>(1000) {}
 
@@ -195,12 +205,13 @@ struct insert_test_rehash3 : public insert_test_base<T>
         rehash_bucket_count = static_cast<size_type>(
             ceil(original_bucket_count * (double) x.max_load_factor())) - 1;
 
-        size_type initial_elements = rehash_bucket_count - 5;
+        size_type initial_elements =
+            rehash_bucket_count > 5 ? rehash_bucket_count - 5 : 1;
 
-        BOOST_REQUIRE(initial_elements < this->values.size());
+        BOOST_TEST(initial_elements < this->values.size());
         x.insert(this->values.begin(),
                 boost::next(this->values.begin(), initial_elements));
-        BOOST_REQUIRE(original_bucket_count == x.bucket_count());
+        BOOST_TEST(original_bucket_count == x.bucket_count());
         return x;
     }
 
@@ -212,12 +223,12 @@ struct insert_test_rehash3 : public insert_test_base<T>
 
         // This isn't actually a failure, but it means the test isn't doing its
         // job.
-        BOOST_REQUIRE(x.bucket_count() != bucket_count);
+        BOOST_TEST(x.bucket_count() != bucket_count);
     }
 
-    void check(T const& x) const {
+    void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const {
         if(x.size() < rehash_bucket_count) {
-            //BOOST_CHECK(x.bucket_count() == original_bucket_count);
+            //BOOST_TEST(x.bucket_count() == original_bucket_count);
         }
         test::check_equivalent_keys(x);
     }
@@ -227,7 +238,7 @@ struct insert_test_rehash3 : public insert_test_base<T>
     (insert_test1)(insert_test2)(insert_test3)(insert_test4) \
     (insert_test_rehash1)(insert_test_rehash2)(insert_test_rehash3)
 
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
+#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
 #define ALL_TESTS (emplace_test1)BASIC_TESTS
 #else
 #define ALL_TESTS BASIC_TESTS

test/exception/rehash_exception_tests.cpp

@@ -1,8 +1,10 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
+#include "../helpers/prefix.hpp"
+
 #include "./containers.hpp"
 #include <string>
 #include "../helpers/random_values.hpp"
@@ -18,7 +20,9 @@ struct rehash_test_base : public test::exception_base
 {
     test::random_values<T> values;
     unsigned int n;
-    rehash_test_base(unsigned int count = 100, unsigned int n = 0) : values(count), n(n) {}
+    rehash_test_base(unsigned int count = 100, unsigned int n = 0)
+        : values(count), n(n)
+    {}
 
     typedef T data_type;
     typedef test::strong<T> strong_type;
@@ -28,7 +32,9 @@ struct rehash_test_base : public test::exception_base
         return x;
     }
 
-    void check(T const& x, strong_type const& strong) const {
+    void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x,
+        strong_type const& strong) const
+    {
         std::string scope(test::scope);
 
         if(scope.find("hash::operator()") == std::string::npos &&

test/exception/swap_exception_tests.cpp

@@ -1,12 +1,18 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
+#include "../helpers/prefix.hpp"
+
 #include "./containers.hpp"
 #include "../helpers/random_values.hpp"
 #include "../helpers/invariants.hpp"
 
+#if defined(BOOST_MSVC)
+#pragma warning(disable:4512) // assignment operator could not be generated
+#endif
+
 test::seed_t seed(9387);
 
 template <class T>
@@ -18,16 +24,15 @@ struct self_swap_base : public test::exception_base
     typedef T data_type;
     T init() const { return T(values.begin(), values.end()); }
     void run(T& x) const { x.swap(x); }
-    void check(T const& x) const {
+    void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const {
         std::string scope(test::scope);
 
-#if BOOST_UNORDERED_SWAP_METHOD != 2
-        BOOST_CHECK(
-                scope == "hash::operator(hash)" ||
+        // TODO: In C++11 exceptions are only allowed in the swap function.
+        BOOST_TEST(
+                scope == "hash::hash(hash)" ||
                 scope == "hash::operator=(hash)" ||
-                scope == "equal_to::operator(equal_to)" ||
+                scope == "equal_to::equal_to(equal_to)" ||
                 scope == "equal_to::operator=(equal_to)");
-#endif
 
         test::check_equivalent_keys(x);
     }
@@ -73,16 +78,15 @@ struct swap_base : public test::exception_base
             d.x.swap(d.y);
         } catch (std::runtime_error) {}
     }
-    void check(data_type const& d) const {
+    void check BOOST_PREVENT_MACRO_SUBSTITUTION(data_type const& d) const {
         std::string scope(test::scope);
 
-#if BOOST_UNORDERED_SWAP_METHOD != 2
-        BOOST_CHECK(
-                scope == "hash::operator(hash)" ||
+        // TODO: In C++11 exceptions are only allowed in the swap function.
+        BOOST_TEST(
+                scope == "hash::hash(hash)" ||
                 scope == "hash::operator=(hash)" ||
-                scope == "equal_to::operator(equal_to)" ||
+                scope == "equal_to::equal_to(equal_to)" ||
                 scope == "equal_to::operator=(equal_to)");
-#endif
         
         test::check_equivalent_keys(d.x);
         test::check_equivalent_keys(d.y);

test/helpers/allocator.hpp

@@ -1,5 +1,5 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
@@ -58,8 +58,8 @@ namespace test
             return (std::numeric_limits<size_type>::max)();
         }
 
-        bool operator==(malloc_allocator const& x) const { return true; }
-        bool operator!=(malloc_allocator const& x) const { return false; }
+        bool operator==(malloc_allocator const&) const { return true; }
+        bool operator!=(malloc_allocator const&) const { return false; }
 
 #if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
         template <class T> void deallocate(T* p, size_type) {

test/helpers/check_return_type.hpp

@@ -1,5 +1,5 @@
 
-// Copyright 2005-2008 Daniel James.
+// Copyright 2005-2009 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)
 

test/helpers/count.hpp

@@ -1,11 +1,13 @@
 
-// Copyright 2008 Daniel James.
+// Copyright 2008-2009 Daniel James.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or move at http://www.boost.org/LICENSE_1_0.txt)
 
 #if !defined(BOOST_UNORDERED_TEST_HELPERS_COUNT_HEAD)
 #define BOOST_UNORDERED_TEST_HELPERS_COUNT_HEAD
 
+#include <iostream>
+
 namespace test {
     struct object_count {
         int instances;
@@ -36,6 +38,18 @@ namespace test {
         bool operator!=(object_count const& x) const {
             return !(*this == x);
         }
+        
+        friend std::ostream& operator<<(std::ostream& out,
+            object_count const& c)
+        {
+            out
+                << "[instances: "
+                << c.instances
+                << ", constructions: "
+                << c.constructions
+                << "]";
+            return out;
+        }
     };
 
     template <class T>
@@ -61,6 +75,13 @@ namespace test {
     namespace {
         object_count& global_object_count = globally_counted_object::count_;
     }
+    
+    struct check_instances {
+        int instances;
+        
+        check_instances() : instances(global_object_count.instances) {}
+        ~check_instances() { BOOST_TEST(global_object_count.instances == instances); }
+    };
 }
 
 #endif

test/helpers/equivalent.hpp

@@ -1,5 +1,5 @@
 
-// Copyright 2005-2008 Daniel James.
+// Copyright 2005-2009 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)
 
@@ -21,12 +21,16 @@ namespace test
     }
 
     template <class T>
-    bool equivalent_impl(boost::hash<T> const&, boost::hash<T> const&, derived_type) {
+    bool equivalent_impl(boost::hash<T> const&, boost::hash<T> const&,
+        derived_type)
+    {
         return true;
     }
 
     template <class T>
-    bool equivalent_impl(std::equal_to<T> const&, std::equal_to<T> const&, derived_type) {
+    bool equivalent_impl(std::equal_to<T> const&, std::equal_to<T> const&,
+        derived_type)
+    {
         return true;
     }
 

test/helpers/exception_test.hpp

@@ -1,5 +1,5 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
@@ -8,64 +8,54 @@
 
 #include "./test.hpp"
 
-#if defined(BOOST_UNORDERED_FULL_TEST)
-#   define BOOST_TEST_MAIN
-#   include <boost/test/exception_safety.hpp>
-#   include <boost/test/unit_test.hpp>
-#endif
-
 #include <boost/preprocessor/seq/for_each_product.hpp>
 #include <boost/preprocessor/seq/elem.hpp>
 #include <boost/preprocessor/cat.hpp>
 
-#if defined(BOOST_UNORDERED_FULL_TEST)
-#   define UNORDERED_EXCEPTION_TEST_CASE(name, test_func, type) \
-        UNORDERED_AUTO_TEST(name) \
-        { \
-            test_func< type > fixture; \
-            ::test::exception_safety(fixture, BOOST_STRINGIZE(test_func<type>)); \
-        }
-#    define UNORDERED_EPOINT_IMPL BOOST_ITEST_EPOINT
-#else
-#   define UNORDERED_EXCEPTION_TEST_CASE(name, test_func, type) \
-        UNORDERED_AUTO_TEST(name) \
-        { \
-            test_func< type > fixture; \
-            ::test::lightweight::exception_safety(fixture, BOOST_STRINGIZE(test_func<type>)); \
-        }
+#   define UNORDERED_EXCEPTION_TEST_CASE(name, test_func, type)             \
+        UNORDERED_AUTO_TEST(name)                                           \
+        {                                                                   \
+            test_func< type > fixture;                                      \
+            ::test::lightweight::exception_safety(                          \
+                fixture, BOOST_STRINGIZE(test_func<type>));                 \
+        }                                                                   \
+
 #    define UNORDERED_EPOINT_IMPL ::test::lightweight::epoint
-#endif
 
 #define UNORDERED_EXCEPTION_TEST_POSTFIX RUN_TESTS()
 
-#define RUN_EXCEPTION_TESTS(test_seq, param_seq) \
-    BOOST_PP_SEQ_FOR_EACH_PRODUCT(RUN_EXCEPTION_TESTS_OP, (test_seq)(param_seq)) \
-    RUN_TESTS()
+#define RUN_EXCEPTION_TESTS(test_seq, param_seq)                            \
+    BOOST_PP_SEQ_FOR_EACH_PRODUCT(RUN_EXCEPTION_TESTS_OP,                   \
+        (test_seq)(param_seq))                                              \
+    RUN_TESTS()                                                             \
 
-#define RUN_EXCEPTION_TESTS_OP(r, product) \
-    UNORDERED_EXCEPTION_TEST_CASE( \
-        BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(0, product), \
-            BOOST_PP_CAT(_, BOOST_PP_SEQ_ELEM(1, product)) \
-        ), \
-        BOOST_PP_SEQ_ELEM(0, product), \
-        BOOST_PP_SEQ_ELEM(1, product) \
-    )
+#define RUN_EXCEPTION_TESTS_OP(r, product)                                  \
+    UNORDERED_EXCEPTION_TEST_CASE(                                          \
+        BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(0, product),                         \
+            BOOST_PP_CAT(_, BOOST_PP_SEQ_ELEM(1, product))                  \
+        ),                                                                  \
+        BOOST_PP_SEQ_ELEM(0, product),                                      \
+        BOOST_PP_SEQ_ELEM(1, product)                                       \
+    )                                                                       \
 
-#define UNORDERED_SCOPE(scope_name) \
-    for(::test::scope_guard unordered_test_guard( \
-            BOOST_STRINGIZE(scope_name)); \
-        !unordered_test_guard.dismissed(); \
-        unordered_test_guard.dismiss())
+#define UNORDERED_SCOPE(scope_name)                                         \
+    for(::test::scope_guard unordered_test_guard(                           \
+            BOOST_STRINGIZE(scope_name));                                   \
+        !unordered_test_guard.dismissed();                                  \
+        unordered_test_guard.dismiss())                                     \
 
-#define UNORDERED_EPOINT(name) \
-    if(::test::exceptions_enabled) { \
-        UNORDERED_EPOINT_IMPL(name); \
-    }
+#define UNORDERED_EPOINT(name)                                              \
+    if(::test::exceptions_enabled) {                                        \
+        UNORDERED_EPOINT_IMPL(name);                                        \
+    }                                                                       \
 
-#define ENABLE_EXCEPTIONS \
-    ::test::exceptions_enable BOOST_PP_CAT(ENABLE_EXCEPTIONS_, __LINE__)(true)
-#define DISABLE_EXCEPTIONS \
-    ::test::exceptions_enable BOOST_PP_CAT(ENABLE_EXCEPTIONS_, __LINE__)(false)
+#define ENABLE_EXCEPTIONS                                                   \
+    ::test::exceptions_enable BOOST_PP_CAT(                                 \
+        ENABLE_EXCEPTIONS_, __LINE__)(true)                                 \
+
+#define DISABLE_EXCEPTIONS                                                  \
+    ::test::exceptions_enable BOOST_PP_CAT(                                 \
+        ENABLE_EXCEPTIONS_, __LINE__)(false)                                \
 
 namespace test {
     static char const* scope = "";
@@ -126,25 +116,28 @@ namespace test {
             template <class T> void test(T const&) const {}
         };
         data_type init() const { return data_type(); }
-        void check() const {}
+        void check BOOST_PREVENT_MACRO_SUBSTITUTION() const {}
     };
 
     template <class T, class P1, class P2, class T2>
-    inline void call_ignore_extra_parameters(void (T::*fn)() const, T2 const& obj,
+    inline void call_ignore_extra_parameters(
+            void (T::*fn)() const, T2 const& obj,
             P1&, P2&)
     {
         (obj.*fn)();
     }
 
     template <class T, class P1, class P2, class T2>
-    inline void call_ignore_extra_parameters(void (T::*fn)(P1&) const, T2 const& obj,
+    inline void call_ignore_extra_parameters(
+            void (T::*fn)(P1&) const, T2 const& obj,
             P1& p1, P2&)
     {
         (obj.*fn)(p1);
     }
 
     template <class T, class P1, class P2, class T2>
-    inline void call_ignore_extra_parameters(void (T::*fn)(P1&, P2&) const, T2 const& obj,
+    inline void call_ignore_extra_parameters(
+            void (T::*fn)(P1&, P2&) const, T2 const& obj,
             P1& p1, P2& p2)
     {
         (obj.*fn)(p1, p2);
@@ -159,6 +152,9 @@ namespace test {
     class test_runner
     {
         Test const& test_;
+
+        test_runner(test_runner const&);
+        test_runner& operator=(test_runner const&);
     public:
         test_runner(Test const& t) : test_(t) {}
         void operator()() const {
@@ -169,25 +165,23 @@ namespace test {
             strong.store(x);
             try {
                 ENABLE_EXCEPTIONS;
-                call_ignore_extra_parameters<Test, BOOST_DEDUCED_TYPENAME Test::data_type, BOOST_DEDUCED_TYPENAME Test::strong_type>(&Test::run, test_, x, strong);
+                call_ignore_extra_parameters<
+                    Test,
+                    BOOST_DEDUCED_TYPENAME Test::data_type,
+                    BOOST_DEDUCED_TYPENAME Test::strong_type
+                >(&Test::run, test_, x, strong);
             }
             catch(...) {
-                call_ignore_extra_parameters<Test, BOOST_DEDUCED_TYPENAME Test::data_type const, BOOST_DEDUCED_TYPENAME Test::strong_type const>(&Test::check, test_,
-                        constant(x), constant(strong));
+                call_ignore_extra_parameters<
+                    Test,
+                    BOOST_DEDUCED_TYPENAME Test::data_type const,
+                    BOOST_DEDUCED_TYPENAME Test::strong_type const
+                >(&Test::check, test_, constant(x), constant(strong));
                 throw;
             }
         }
     };
-    
-    
 
-#if defined(BOOST_UNORDERED_FULL_TEST)
-    template <class Test>
-    void exception_safety(Test const& f, char const* name) {
-        test_runner<Test> runner(f);
-        ::boost::itest::exception_safety(runner, name);
-    }
-#else
     // Quick exception testing based on lightweight test
 
     namespace lightweight {
@@ -237,7 +231,6 @@ namespace test {
             } while(!success);
         }
     }
-#endif
 }
 
 #endif

test/helpers/fwd.hpp

@@ -1,5 +1,5 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 

test/helpers/generators.hpp

@@ -1,5 +1,5 @@
 
-// Copyright 2005-2008 Daniel James.
+// Copyright 2005-2009 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)
 

test/helpers/helpers.hpp

@@ -1,5 +1,5 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
@@ -19,13 +19,15 @@ namespace test
         }
 
         template <class T>
-        static key_type const& get_key(std::pair<key_type, T> const& x, char = 0)
+        static key_type const& get_key(
+            std::pair<key_type, T> const& x, char = 0)
         {
             return x.first;
         }
 
         template <class T>
-        static key_type const& get_key(std::pair<key_type const, T> const& x, unsigned char = 0)
+        static key_type const& get_key(std::pair<key_type const, T> const& x,
+            unsigned char = 0)
         {
             return x.first;
         }

test/helpers/input_iterator.hpp

@@ -1,34 +1,164 @@
 
-// Copyright 2005-2008 Daniel James.
+// Copyright 2005-2010 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)
 
 #if !defined(BOOST_UNORDERED_TEST_HELPERS_INPUT_ITERATOR_HEADER)
 #define BOOST_UNORDERED_TEST_HELPERS_INPUT_ITERATOR_HEADER
 
-#include <boost/iterator_adaptors.hpp>
+#include <boost/config.hpp>
+#include <boost/iterator.hpp>
+#include <boost/iterator/iterator_traits.hpp>
 
 namespace test
 {
     template <class Iterator>
-    struct input_iterator_adaptor
-        : boost::iterator_adaptor<
-            input_iterator_adaptor<Iterator>, Iterator,
-            boost::use_default, std::input_iterator_tag>
+    struct proxy
     {
-        typedef boost::iterator_adaptor<
-            input_iterator_adaptor<Iterator>, Iterator,
-            boost::use_default, std::input_iterator_tag> base;
+        typedef BOOST_DEDUCED_TYPENAME Iterator::value_type value_type;
 
-        explicit input_iterator_adaptor(Iterator it = Iterator())
-            : base(it) {}
+        explicit proxy(value_type const& v) : v_(v) {}
+        proxy(proxy const& x) : v_(x.v_) {}
+        operator value_type const&() const { return v_; }
+        
+        value_type v_;
+    private:
+        proxy& operator=(proxy const&);
     };
 
     template <class Iterator>
-    input_iterator_adaptor<Iterator> input_iterator(Iterator it)
+    struct input_iterator_adaptor
+        : public boost::iterator<
+            std::input_iterator_tag,
+            BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type,
+            std::ptrdiff_t,
+            BOOST_DEDUCED_TYPENAME boost::iterator_pointer<Iterator>::type,
+            proxy<Iterator>
+        >
+    {
+        typedef BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type
+            value_type;
+    
+        input_iterator_adaptor()
+            : base_() {}
+        explicit input_iterator_adaptor(Iterator& it)
+            : base_(&it) {}
+        proxy<Iterator> operator*() const {
+            return proxy<Iterator>(**base_);
+        }
+        value_type* operator->() const {
+            return &**base_;
+        }
+        input_iterator_adaptor& operator++() {
+            ++*base_; return *this;
+        }
+        //input_iterator_adaptor operator++(int) {
+        //}
+        bool operator==(input_iterator_adaptor const& x) const {
+            return *base_ == *x.base_;
+        }
+        bool operator!=(input_iterator_adaptor const& x) const {
+            return *base_ != *x.base_;
+        }
+    private:
+        Iterator* base_;
+    };
+
+    template <class Iterator>
+    input_iterator_adaptor<Iterator> input_iterator(Iterator& it)
     {
         return input_iterator_adaptor<Iterator>(it);
     }
+
+    template <class Iterator>
+    struct copy_iterator_adaptor
+        : public boost::iterator<
+            BOOST_DEDUCED_TYPENAME boost::iterator_category<Iterator>::type,
+            BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type,
+            BOOST_DEDUCED_TYPENAME boost::iterator_difference<Iterator>::type,
+            BOOST_DEDUCED_TYPENAME boost::iterator_pointer<Iterator>::type,
+            proxy<Iterator>
+        >
+    {
+        typedef BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type
+            value_type;
+        typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<Iterator>::type
+            difference_type;
+    
+        copy_iterator_adaptor()
+            : base_() {}
+        explicit copy_iterator_adaptor(Iterator const& it)
+            : base_(it) {}
+        value_type operator*() const {
+            return *base_;
+        }
+        value_type* operator->() const {
+            return &*base_;
+        }
+        value_type operator[](difference_type d) {
+            return base_[d];
+        }
+        copy_iterator_adaptor& operator++() {
+            ++base_; return *this;
+        }
+        copy_iterator_adaptor operator++(int) {
+            copy_iterator_adaptor tmp(*this); ++base_; return tmp;
+        }
+        copy_iterator_adaptor& operator--() {
+            --base_; return *this;
+        }
+        copy_iterator_adaptor operator--(int) {
+            copy_iterator_adaptor tmp(*this); --base_; return tmp;
+        }
+        copy_iterator_adaptor operator+=(difference_type x) {
+            base_ += x;
+            return *this;
+        }
+        copy_iterator_adaptor operator-=(difference_type x) {
+            base_ -= x;
+            return *this;
+        }
+        copy_iterator_adaptor operator+(difference_type n) {
+            return copy_iterator_adaptor(base_+n);
+        }
+        copy_iterator_adaptor operator-(difference_type n) {
+            return copy_iterator_adaptor(base_-n);
+        }
+        friend copy_iterator_adaptor operator+(
+                difference_type n, copy_iterator_adaptor x) {
+            return x+n;
+        }
+        difference_type operator-(copy_iterator_adaptor const& other) {
+            return base_-other.base_;
+        }
+        bool operator==(copy_iterator_adaptor const& x) const {
+            return base_ == x.base_;
+        }
+        bool operator!=(copy_iterator_adaptor const& x) const {
+            return base_ != x.base_;
+        }
+        bool operator<(copy_iterator_adaptor const& x) const {
+            return base_ < x.base_;
+        }
+        bool operator>(copy_iterator_adaptor const& x) const {
+            return base_ > x.base_;
+        }
+        bool operator<=(copy_iterator_adaptor const& x) const {
+            return base_ <= x.base_;
+        }
+        bool operator>=(copy_iterator_adaptor const& x) const {
+            return base_ >= x.base_;
+        }
+    private:
+        Iterator base_;
+    };
+
+    template <class Iterator>
+    copy_iterator_adaptor<Iterator> copy_iterator(Iterator const& it)
+    {
+        return copy_iterator_adaptor<Iterator>(it);
+    }
+
 }
 
 #endif

test/helpers/invariants.hpp

@@ -1,5 +1,5 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
@@ -17,7 +17,9 @@
 
 #if defined(BOOST_MSVC)
 #pragma warning(push)
-#pragma warning(disable:4127) // conditional expression is constant
+#pragma warning(disable:4127)   // conditional expression is constant
+#pragma warning(disable:4267)   // conversion from 'size_t' to 'unsigned int',
+                                // possible loss of data
 #endif
 
 namespace test
@@ -29,12 +31,14 @@ namespace test
         typedef BOOST_DEDUCED_TYPENAME X::key_type key_type;
         // Boost.Test was reporting memory leaks for std::set on g++-3.3.
         // So I work around it by using malloc.
-        std::set<key_type, std::less<key_type>, test::malloc_allocator<key_type> > found_;
+        std::set<key_type, std::less<key_type>,
+            test::malloc_allocator<key_type> > found_;
 
-        BOOST_DEDUCED_TYPENAME X::const_iterator it = x1.begin(), end = x1.end();
+        BOOST_DEDUCED_TYPENAME X::const_iterator
+            it = x1.begin(), end = x1.end();
         BOOST_DEDUCED_TYPENAME X::size_type size = 0;
         while(it != end) {
-            // First test that the current key has not occured before, required
+            // First test that the current key has not occurred before, required
             // to test either that keys are unique or that equivalent keys are
             // adjacent. (6.3.1/6)
             key_type key = get_key<X>(*it);
@@ -61,36 +65,34 @@ namespace test
                 std::cerr<<x1.count(key)<<","<<count<<"\n";
             }
 
-            // I'm not bothering with the following test for now, as the
-            // previous test is probably more enough to catch the kind of
-            // errors that this would catch (if an element was in the wrong
-            // bucket it not be found by the call to count, if elements are not
-            // adjacent then they would be caught when checking against
-            // found_.
-
-            // // Check that the keys are in the correct bucket and are
-            // // adjacent in the bucket.
-            // BOOST_DEDUCED_TYPENAME X::size_type bucket = x1.bucket(key);
-            // BOOST_DEDUCED_TYPENAME X::const_local_iterator lit = x1.begin(bucket), lend = x1.end(bucket);
-            // for(; lit != lend && !eq(get_key<X>(*lit), key); ++lit) continue;
-            // if(lit == lend)
-            //     BOOST_ERROR("Unable to find element with a local_iterator");
-            // unsigned int count2 = 0;
-            // for(; lit != lend && eq(get_key<X>(*lit), key); ++lit) ++count2;
-            // if(count != count2)
-            //     BOOST_ERROR("Element count doesn't match local_iterator.");
-            // for(; lit != lend; ++lit) {
-            //     if(eq(get_key<X>(*lit), key)) {
-            //         BOOST_ERROR("Non-adjacent element with equivalent key in bucket.");
-            //         break;
-            //     }
-            // }
+            // Check that the keys are in the correct bucket and are
+            // adjacent in the bucket.
+            BOOST_DEDUCED_TYPENAME X::size_type bucket = x1.bucket(key);
+            BOOST_DEDUCED_TYPENAME X::const_local_iterator
+                lit = x1.begin(bucket), lend = x1.end(bucket);
+            for(; lit != lend && !eq(get_key<X>(*lit), key); ++lit) continue;
+            if(lit == lend)
+                BOOST_ERROR("Unable to find element with a local_iterator");
+            unsigned int count2 = 0;
+            for(; lit != lend && eq(get_key<X>(*lit), key); ++lit) ++count2;
+            if(count != count2)
+                BOOST_ERROR("Element count doesn't match local_iterator.");
+            for(; lit != lend; ++lit) {
+                if(eq(get_key<X>(*lit), key)) {
+                    BOOST_ERROR("Non-adjacent element with equivalent key "
+                        "in bucket.");
+                    break;
+                }
+            }
         };
 
         // Finally, check that size matches up.
-        if(x1.size() != size)
+        if(x1.size() != size) {
             BOOST_ERROR("x1.size() doesn't match actual size.");
-        float load_factor = static_cast<float>(size) / static_cast<float>(x1.bucket_count());
+            std::cout<<x1.size()<<"/"<<size<<std::endl;
+        }
+        float load_factor =
+            static_cast<float>(size) / static_cast<float>(x1.bucket_count());
         using namespace std;
         if(fabs(x1.load_factor() - load_factor) > x1.load_factor() / 64)
             BOOST_ERROR("x1.load_factor() doesn't match actual load_factor.");

test/helpers/list.hpp

@@ -1,5 +1,5 @@
 
-// Copyright 2008 Daniel James.
+// Copyright 2008-2009 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)
 
@@ -17,18 +17,38 @@
 
 namespace test
 {
+    template <typename It1, typename It2>
+    bool equal(It1 begin, It1 end, It2 compare)
+    {
+        for(;begin != end; ++begin, ++compare)
+            if(*begin != *compare) return false;
+        return true;
+    }
+
+    template <typename It1, typename It2, typename Pred>
+    bool equal(It1 begin, It1 end, It2 compare, Pred predicate)
+    {
+        for(;begin != end; ++begin, ++compare)
+            if(!predicate(*begin, *compare)) return false;
+        return true;
+    }
+
+
     template <typename T> class list;
 
     namespace test_detail
     {
-        template <typename T> struct list_node;
+        template <typename T> class list_node;
         template <typename T> class list_data;
         template <typename T> class list_iterator;
         template <typename T> class list_const_iterator;
 
         template <typename T>
-        struct list_node
+        class list_node
         {
+            list_node(list_node const&);
+            list_node& operator=(list_node const&);
+        public:
             T value_;
             list_node* next_;
                     
@@ -74,14 +94,14 @@ namespace test
 
             node* ptr_;
         public:
-            list_iterator() : ptr_(0) {};
+            list_iterator() : ptr_(0) {}
             explicit list_iterator(node* x) : ptr_(x) {}
 
             T& operator*() const { return ptr_->value_; }
             T* operator->() const { return &ptr_->value_; }
             list_iterator& operator++() {
                 ptr_ = ptr_->next_; return *this; }
-            list_iterator& operator++(int) {
+            list_iterator operator++(int) {
                 list_iterator tmp = *this; ptr_ = ptr_->next_; return tmp; }
             bool operator==(const_iterator y) const { return ptr_ == y.ptr_; }
             bool operator!=(const_iterator y) const { return ptr_ != y.ptr_; }
@@ -106,12 +126,29 @@ namespace test
 
             T const& operator*() const { return ptr_->value_; }
             T const* operator->() const { return &ptr_->value_; }
-            list_const_iterator& operator++() {
-                ptr_ = ptr_->next_; return *this; }
-            list_const_iterator& operator++(int) {
-                list_const_iterator tmp = *this; ptr_ = ptr_->next_; return tmp; }
-            bool operator==(const_iterator y) const { return ptr_ == y.ptr_; }
-            bool operator!=(const_iterator y) const { return ptr_ != y.ptr_; }
+
+            list_const_iterator& operator++()
+            {
+                ptr_ = ptr_->next_;
+                return *this;
+            }
+
+            list_const_iterator operator++(int)
+            {
+                list_const_iterator tmp = *this;
+                ptr_ = ptr_->next_;
+                return tmp;
+            }
+
+            bool operator==(const_iterator y) const
+            {
+                return ptr_ == y.ptr_;
+            }
+
+            bool operator!=(const_iterator y) const
+            {
+                return ptr_ != y.ptr_;
+            }
         };
     }
 
@@ -144,6 +181,7 @@ namespace test
         list& operator=(list const& other) {
             clear();
             insert(other.begin(), other.end());
+            return *this;
         }
 
         iterator begin() { return iterator(data_.first_); }
@@ -218,7 +256,7 @@ namespace test
 
         bool operator==(list const& y) const {
             return size() == y.size() &&
-                std::equal(begin(), end(), y.begin());
+                test::equal(begin(), end(), y.begin());
         }
 
         bool operator!=(list const& y) const {
@@ -242,14 +280,28 @@ namespace test
         node** merge_adjacent_ranges(node** first, node** second,
                 node** third, Less less)
         {
-            while(first != second) {
-                if(less((*second)->value_, (*first)->value_)) {
-                    swap_adjacent_ranges(first, second, third);
-                    std::swap(second, third);
+            for(;;) {
+                for(;;) {
+                    if(first == second) return third;
+                    if(less((*second)->value_, (*first)->value_)) break;
+                    first = &(*first)->next_;
                 }
+
+                swap_adjacent_ranges(first, second, third);
+                first = &(*first)->next_;
+                
+                // Since the two ranges we just swapped, the order is now:
+                // first...third...second
+                
+                for(;;) {
+                    if(first == third) return second;
+                    if(!less((*first)->value_, (*third)->value_)) break;
+                    first = &(*first)->next_;
+                }
+
+                swap_adjacent_ranges(first, third, second);
                 first = &(*first)->next_;
             }
-            return third;
         }
         
         void swap_adjacent_ranges(node** first, node** second, node** third)

test/helpers/memory.hpp

@@ -1,5 +1,5 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
@@ -18,11 +18,6 @@ namespace test
 {
     namespace detail
     {
-        // This annoymous namespace won't cause ODR violations as I won't
-        // be linking multiple translation units together. I'll probably
-        // move this into a cpp file before a full release, but for now it's
-        // the most convenient way.
-
         struct memory_area {
             void const* start;
             void const* end;
@@ -67,18 +62,20 @@ namespace test
 #if defined(BOOST_MPL_CFG_MSVC_ETI_BUG)
         template <>
         struct allocator_memory_type_gen<int> {
-            typedef std::map<memory_area, memory_track, memory_area_compare> type;
+            typedef std::map<memory_area, memory_track, memory_area_compare>
+                type;
         };
 #endif
 
         template <class Alloc = std::allocator<int> >
         struct memory_tracker {
             typedef BOOST_DEDUCED_TYPENAME
-                boost::unordered_detail::rebind_wrap<Alloc,
+                ::boost::unordered::detail::rebind_wrap<Alloc,
                     std::pair<memory_area const, memory_track> >::type
                 allocator_type;
 
-            typedef BOOST_DEDUCED_TYPENAME allocator_memory_type_gen<allocator_type>::type
+            typedef BOOST_DEDUCED_TYPENAME
+                allocator_memory_type_gen<allocator_type>::type
                 allocated_memory_type;
 
             allocated_memory_type allocated_memory;
@@ -103,7 +100,7 @@ namespace test
 
             void allocator_unref()
             {
-                BOOST_CHECK(count_allocators > 0);
+                BOOST_TEST(count_allocators > 0);
                 if(count_allocators > 0) {
                     --count_allocators;
                     if(count_allocators == 0) {
@@ -111,19 +108,21 @@ namespace test
                         bool no_constructions_left = (count_constructions == 0);
                         bool allocated_memory_empty = allocated_memory.empty();
 
-                        // Clearing the data before the checks terminate the tests.
+                        // Clearing the data before the checks terminate the
+                        // tests.
                         count_allocations = 0;
                         count_constructions = 0;
                         allocated_memory.clear();
 
-                        BOOST_CHECK(no_allocations_left);
-                        BOOST_CHECK(no_constructions_left);
-                        BOOST_CHECK(allocated_memory_empty);
+                        BOOST_TEST(no_allocations_left);
+                        BOOST_TEST(no_constructions_left);
+                        BOOST_TEST(allocated_memory_empty);
                     }
                 }
             }
 
-            void track_allocate(void *ptr, std::size_t n, std::size_t size, int tag)
+            void track_allocate(void *ptr, std::size_t n, std::size_t size,
+                int tag)
             {
                 if(n == 0) {
                     BOOST_ERROR("Allocating 0 length array.");
@@ -137,34 +136,74 @@ namespace test
                 }
             }
 
-            void track_deallocate(void* ptr, std::size_t n, std::size_t size, int tag)
+            void track_deallocate(void* ptr, std::size_t n, std::size_t size,
+                int tag, bool check_tag_ = true)
             {
-                BOOST_DEDUCED_TYPENAME allocated_memory_type::iterator pos
-                    = allocated_memory.find(memory_area(ptr, (char*) ptr + n * size));
+                BOOST_DEDUCED_TYPENAME allocated_memory_type::iterator pos =
+                    allocated_memory.find(
+                        memory_area(ptr, (char*) ptr + n * size));
                 if(pos == allocated_memory.end()) {
                     BOOST_ERROR("Deallocating unknown pointer.");
                 } else {
-                    BOOST_CHECK(pos->first.start == ptr);
-                    BOOST_CHECK(pos->first.end == (char*) ptr + n * size);
-                    BOOST_CHECK(pos->second.tag_ == tag);
+                    BOOST_TEST(pos->first.start == ptr);
+                    BOOST_TEST(pos->first.end == (char*) ptr + n * size);
+                    if (check_tag_) BOOST_TEST(pos->second.tag_ == tag);
                     allocated_memory.erase(pos);
                 }
-                BOOST_CHECK(count_allocations > 0);
+                BOOST_TEST(count_allocations > 0);
                 if(count_allocations > 0) --count_allocations;
             }
 
-            void track_construct(void* /*ptr*/, std::size_t /*size*/, int /*tag*/)
+            void track_construct(void* /*ptr*/, std::size_t /*size*/,
+                int /*tag*/)
             {
                 ++count_constructions;
             }
 
-            void track_destroy(void* /*ptr*/, std::size_t /*size*/, int /*tag*/)
+            void track_destroy(void* /*ptr*/, std::size_t /*size*/,
+                int /*tag*/)
             {
-                BOOST_CHECK(count_constructions > 0);
+                BOOST_TEST(count_constructions > 0);
                 if(count_constructions > 0) --count_constructions;
             }
         };
     }
+
+    namespace detail
+    {
+        // This won't be a problem as I'm only using a single compile unit
+        // in each test (this is actually required by the minimal test
+        // framework).
+        // 
+        // boostinspect:nounnamed
+        namespace {
+            test::detail::memory_tracker<std::allocator<int> > tracker;
+        }
+    }
+    
+    template <int Value>
+    struct bool_type {
+        enum { value = (Value ? true : false) };
+    };
+
+    struct true_type {
+        enum { value = true };
+    };
+
+    struct false_type {
+        enum { value = false };
+    };
+
+    struct convert_from_anything
+    {
+        template <typename T>
+        convert_from_anything(T const&) {}
+    };
+
+    int selected_count(convert_from_anything)
+    {
+        return 0;
+    }
 }
 
 #endif

test/helpers/metafunctions.hpp

@@ -1,5 +1,5 @@
 
-// Copyright 2005-2008 Daniel James.
+// Copyright 2005-2009 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)
 

test/helpers/prefix.hpp

@@ -0,0 +1,11 @@
+
+// Copyright 2009 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)
+
+#if defined(_WIN32_WCE)
+// The standard windows mobile headers trigger this warning so I disable it
+// before doing anything else.
+#pragma warning(disable:4201)   // nonstandard extension used :
+                                // nameless struct/union
+#endif

test/helpers/random_values.hpp

@@ -1,5 +1,5 @@
 
-// Copyright 2005-2008 Daniel James.
+// Copyright 2005-2009 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)
 
@@ -71,7 +71,9 @@ namespace test
                     type_ == generate_collisions ?
                     generate(int_ptr) % 10 : 1;
                     count; --count) {
-                    x.push_back(std::pair<key_type const, mapped_type>(key, generate(mapped_ptr)));
+                    x.push_back(
+                        std::pair<key_type const, mapped_type>(
+                            key, generate(mapped_ptr)));
                 }
             }
         }

test/helpers/strong.hpp

@@ -1,5 +1,5 @@
 
-// Copyright 2005-2008 Daniel James.
+// Copyright 2005-2009 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)
 
@@ -20,18 +20,22 @@ namespace test
     {
         typedef test::list<BOOST_DEDUCED_TYPENAME X::value_type> values_type;
         values_type values_;
+        unsigned int allocations_;
     public:
-        void store(X const& x) {
+        void store(X const& x, unsigned int allocations = 0) {
             DISABLE_EXCEPTIONS;
             values_.clear();
             values_.insert(x.cbegin(), x.cend());
+            allocations_ = allocations;
         }
 
-        void test(X const& x) const {
+        void test(X const& x, unsigned int allocations = 0) const {
             if(!(x.size() == values_.size() &&
-                    std::equal(x.cbegin(), x.cend(), values_.begin(),
+                    test::equal(x.cbegin(), x.cend(), values_.begin(),
                         test::equivalent)))
                 BOOST_ERROR("Strong exception safety failure.");
+            if(allocations != allocations_)
+                BOOST_ERROR("Strong exception failure: extra allocations.");
         }
     };
 }

test/helpers/test.hpp

@@ -1,36 +1,30 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
 #if !defined(BOOST_UNORDERED_TEST_TEST_HEADER)
 #define BOOST_UNORDERED_TEST_TEST_HEADER
 
-#if defined(BOOST_UNORDERED_FULL_TEST)
-
-#include <boost/test/test_tools.hpp>
-#define UNORDERED_AUTO_TEST(x) BOOST_AUTO_TEST_CASE(x)
-#define RUN_TESTS()
-
-#else
-
-#include <boost/test/minimal.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <boost/preprocessor/cat.hpp>
 #include <boost/preprocessor/stringize.hpp>
 #include <iostream>
 
-#define UNORDERED_AUTO_TEST(x) \
-    struct BOOST_PP_CAT(x, _type) : public ::test::registered_test_base { \
-        BOOST_PP_CAT(x, _type)() \
-            : ::test::registered_test_base(BOOST_PP_STRINGIZE(x)) \
-        { \
-            ::test::test_list::add_test(this); \
-        } \
-        void run(); \
-    }; \
-    BOOST_PP_CAT(x, _type) x; \
-    void BOOST_PP_CAT(x, _type)::run()
-#define RUN_TESTS() int test_main(int, char**) { ::test::test_list::run_tests(); return 0; }
+#define UNORDERED_AUTO_TEST(x)                                              \
+    struct BOOST_PP_CAT(x, _type) : public ::test::registered_test_base {   \
+        BOOST_PP_CAT(x, _type)()                                            \
+            : ::test::registered_test_base(BOOST_PP_STRINGIZE(x))           \
+        {                                                                   \
+            ::test::test_list::add_test(this);                              \
+        }                                                                   \
+        void run();                                                         \
+    };                                                                      \
+    BOOST_PP_CAT(x, _type) x;                                               \
+    void BOOST_PP_CAT(x, _type)::run()                                      \
+
+#define RUN_TESTS() int main(int, char**)                                   \
+    { ::test::test_list::run_tests(); return boost::report_errors(); }      \
 
 namespace test {
     struct registered_test_base {
@@ -74,8 +68,6 @@ namespace test {
     }
 }
 
-#endif
-
 #include <boost/preprocessor/seq/for_each_product.hpp>
 #include <boost/preprocessor/seq/fold_left.hpp>
 #include <boost/preprocessor/seq/to_tuple.hpp>
@@ -83,20 +75,22 @@ namespace test {
 #include <boost/preprocessor/cat.hpp>
 
 // Run test with every combination of the parameters (a sequence of sequences)
-#define UNORDERED_TEST(name, parameters) \
-    BOOST_PP_SEQ_FOR_EACH_PRODUCT(UNORDERED_TEST_OP, ((name)) parameters)
+#define UNORDERED_TEST(name, parameters)                                    \
+    BOOST_PP_SEQ_FOR_EACH_PRODUCT(UNORDERED_TEST_OP, ((name)) parameters)   \
 
-#define UNORDERED_TEST_OP(r, product) \
-    UNORDERED_TEST_OP2( \
-        BOOST_PP_SEQ_HEAD(product), \
-        BOOST_PP_SEQ_TAIL(product))
+#define UNORDERED_TEST_OP(r, product)                                       \
+    UNORDERED_TEST_OP2(                                                     \
+        BOOST_PP_SEQ_HEAD(product),                                         \
+        BOOST_PP_SEQ_TAIL(product))                                         \
 
-#define UNORDERED_TEST_OP2(name, params) \
-    UNORDERED_AUTO_TEST(BOOST_PP_SEQ_FOLD_LEFT(UNORDERED_TEST_OP_JOIN, name, params)) { \
-        name BOOST_PP_SEQ_TO_TUPLE(params); \
-    }
+#define UNORDERED_TEST_OP2(name, params)                                    \
+    UNORDERED_AUTO_TEST(                                                    \
+        BOOST_PP_SEQ_FOLD_LEFT(UNORDERED_TEST_OP_JOIN, name, params))       \
+    {                                                                       \
+        name BOOST_PP_SEQ_TO_TUPLE(params);                                 \
+    }                                                                       \
 
-#define UNORDERED_TEST_OP_JOIN(s, state, elem) \
-    BOOST_PP_CAT(state, BOOST_PP_CAT(_, elem))
+#define UNORDERED_TEST_OP_JOIN(s, state, elem)                              \
+    BOOST_PP_CAT(state, BOOST_PP_CAT(_, elem))                              \
 
 #endif

test/helpers/tracker.hpp

@@ -1,5 +1,5 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
@@ -27,7 +27,8 @@ namespace test
 {
     template <class X>
     struct equals_to_compare2
-        : public boost::mpl::identity<std::less<BOOST_DEDUCED_TYPENAME X::first_argument_type> >
+        : public boost::mpl::identity<
+            std::less<BOOST_DEDUCED_TYPENAME X::first_argument_type> >
     {
     };
 
@@ -49,8 +50,8 @@ namespace test
         value_list values2(x2.begin(), x2.end());
         values1.sort();
         values2.sort();
-        BOOST_CHECK(values1.size() == values2.size() &&
-                std::equal(values1.begin(), values1.end(), values2.begin(),
+        BOOST_TEST(values1.size() == values2.size() &&
+                test::equal(values1.begin(), values1.end(), values2.begin(),
                     test::equivalent));
     }
 
@@ -61,38 +62,56 @@ namespace test
         test::list<T> values2(x2.first, x2.second);
         values1.sort();
         values2.sort();
-        BOOST_CHECK(values1.size() == values2.size() &&
-                std::equal(values1.begin(), values1.end(), values2.begin(), test::equivalent));
+        BOOST_TEST(values1.size() == values2.size() &&
+                test::equal(values1.begin(), values1.end(),
+                    values2.begin(), test::equivalent));
     }
 
     template <class X>
-    struct ordered_set
-        : public boost::mpl::if_<
+    struct ordered_set : public
+        boost::mpl::if_<
             test::has_unique_keys<X>,
-            std::set<BOOST_DEDUCED_TYPENAME X::value_type,
-                BOOST_DEDUCED_TYPENAME equals_to_compare<BOOST_DEDUCED_TYPENAME X::key_equal>::type>,
-            std::multiset<BOOST_DEDUCED_TYPENAME X::value_type,
-                BOOST_DEDUCED_TYPENAME equals_to_compare<BOOST_DEDUCED_TYPENAME X::key_equal>::type>
-            > {};
+            std::set<
+                BOOST_DEDUCED_TYPENAME X::value_type,
+                BOOST_DEDUCED_TYPENAME equals_to_compare<
+                    BOOST_DEDUCED_TYPENAME X::key_equal
+                >::type
+            >,
+            std::multiset<
+                BOOST_DEDUCED_TYPENAME X::value_type,
+                BOOST_DEDUCED_TYPENAME equals_to_compare<
+                    BOOST_DEDUCED_TYPENAME X::key_equal
+                >::type
+            >
+        > {};
 
     template <class X>
-    struct ordered_map
-        : public boost::mpl::if_<
+    struct ordered_map : public
+        boost::mpl::if_<
             test::has_unique_keys<X>,
-            std::map<BOOST_DEDUCED_TYPENAME X::key_type, BOOST_DEDUCED_TYPENAME X::mapped_type,
-                BOOST_DEDUCED_TYPENAME equals_to_compare<BOOST_DEDUCED_TYPENAME X::key_equal>::type>,
-            std::multimap<BOOST_DEDUCED_TYPENAME X::key_type, BOOST_DEDUCED_TYPENAME X::mapped_type,
-                BOOST_DEDUCED_TYPENAME equals_to_compare<BOOST_DEDUCED_TYPENAME X::key_equal>::type>
-            > {};
+            std::map<
+                BOOST_DEDUCED_TYPENAME X::key_type,
+                BOOST_DEDUCED_TYPENAME X::mapped_type,
+                BOOST_DEDUCED_TYPENAME equals_to_compare<
+                    BOOST_DEDUCED_TYPENAME X::key_equal
+                >::type
+            >,
+            std::multimap<
+                BOOST_DEDUCED_TYPENAME X::key_type,
+                BOOST_DEDUCED_TYPENAME X::mapped_type,
+                BOOST_DEDUCED_TYPENAME equals_to_compare<
+                    BOOST_DEDUCED_TYPENAME X::key_equal
+                >::type
+            >
+        > {};
 
     template <class X>
-    struct ordered_base
-        : public boost::mpl::eval_if<
+    struct ordered_base : public
+        boost::mpl::eval_if<
             test::is_set<X>,
             test::ordered_set<X>,
-            test::ordered_map<X> >
-    {
-    };
+            test::ordered_map<X>
+        > {};
 
     template <class X>
     class ordered : public ordered_base<X>::type
@@ -114,7 +133,8 @@ namespace test
             compare_range(x, *this);
         }
 
-        void compare_key(X const& x, BOOST_DEDUCED_TYPENAME X::value_type const& val)
+        void compare_key(X const& x,
+            BOOST_DEDUCED_TYPENAME X::value_type const& val)
         {
             compare_pairs(
                 x.equal_range(get_key<X>(val)),
@@ -132,7 +152,8 @@ namespace test
     };
 
     template <class Equals>
-    BOOST_DEDUCED_TYPENAME equals_to_compare<Equals>::type create_compare(Equals const&)
+    BOOST_DEDUCED_TYPENAME
+        equals_to_compare<Equals>::type create_compare(Equals const&)
     {
         BOOST_DEDUCED_TYPENAME equals_to_compare<Equals>::type x;
         return x;

test/objects/cxx11_allocator.hpp

@@ -0,0 +1,301 @@
+
+// Copyright 2006-2011 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)
+
+#if !defined(BOOST_UNORDERED_TEST_CXX11_ALLOCATOR_HEADER)
+#define BOOST_UNORDERED_TEST_CXX11_ALLOCATOR_HEADER
+
+#include <boost/config.hpp>
+#include <boost/limits.hpp>
+#include <cstddef>
+
+#include "../helpers/fwd.hpp"
+#include "../helpers/memory.hpp"
+
+namespace test
+{
+    struct allocator_false
+    {
+        enum {
+            is_select_on_copy = 0,
+            is_propagate_on_swap = 0,
+            is_propagate_on_assign = 0,
+            is_propagate_on_move = 0
+        };
+    };
+
+    struct allocator_flags_all
+    {
+        enum {
+            is_select_on_copy = 1,
+            is_propagate_on_swap = 1,
+            is_propagate_on_assign = 1,
+            is_propagate_on_move = 1
+        };
+    };
+    
+    struct select_copy : allocator_false
+    { enum { is_select_on_copy = 1 }; };
+    struct propagate_swap : allocator_false
+    { enum { is_propagate_on_swap = 1 }; };
+    struct propagate_assign : allocator_false
+    { enum { is_propagate_on_assign = 1 }; };
+    struct propagate_move : allocator_false
+    { enum { is_propagate_on_move = 1 }; };
+
+    struct no_select_copy : allocator_flags_all
+    { enum { is_select_on_copy = 0 }; };
+    struct no_propagate_swap : allocator_flags_all
+    { enum { is_propagate_on_swap = 0 }; };
+    struct no_propagate_assign : allocator_flags_all
+    { enum { is_propagate_on_assign = 0 }; };
+    struct no_propagate_move : allocator_flags_all
+    { enum { is_propagate_on_move = 0 }; };
+    
+    template <typename Flag>
+    struct swap_allocator_base
+    {
+        struct propagate_on_container_swap {
+            enum { value = Flag::is_propagate_on_swap }; };
+    };
+
+    template <typename Flag>
+    struct assign_allocator_base
+    {
+        struct propagate_on_container_copy_assignment {
+            enum { value = Flag::is_propagate_on_assign }; };
+    };
+
+    template <typename Flag>
+    struct move_allocator_base
+    {
+        struct propagate_on_container_move_assignment {
+            enum { value = Flag::is_propagate_on_move }; };
+    };
+
+    namespace
+    {
+        // boostinspect:nounnamed
+        bool force_equal_allocator_value = false;
+    }
+
+    struct force_equal_allocator
+    {
+        bool old_value_;
+    
+        explicit force_equal_allocator(bool value)
+            : old_value_(force_equal_allocator_value)
+        { force_equal_allocator_value = value; }
+        
+        ~force_equal_allocator()
+        { force_equal_allocator_value = old_value_; }
+    };
+
+    template <typename T>
+    struct cxx11_allocator_base
+    {
+        int tag_;
+        int selected_;
+
+        typedef std::size_t size_type;
+        typedef std::ptrdiff_t difference_type;
+        typedef T* pointer;
+        typedef T const* const_pointer;
+        typedef T& reference;
+        typedef T const& const_reference;
+        typedef T value_type;
+
+        explicit cxx11_allocator_base(int t)
+            : tag_(t), selected_(0)
+        {
+            detail::tracker.allocator_ref();
+        }
+        
+        template <typename Y> cxx11_allocator_base(
+                cxx11_allocator_base<Y> const& x)
+            : tag_(x.tag_), selected_(x.selected_)
+        {
+            detail::tracker.allocator_ref();
+        }
+
+        cxx11_allocator_base(cxx11_allocator_base const& x)
+            : tag_(x.tag_), selected_(x.selected_)
+        {
+            detail::tracker.allocator_ref();
+        }
+
+        ~cxx11_allocator_base()
+        {
+            detail::tracker.allocator_unref();
+        }
+
+        pointer address(reference r)
+        {
+            return pointer(&r);
+        }
+
+        const_pointer address(const_reference r)
+        {
+            return const_pointer(&r);
+        }
+
+        pointer allocate(size_type n) {
+            pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
+            detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
+            return ptr;
+        }
+
+        pointer allocate(size_type n, void const* u)
+        {
+            pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
+            detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
+            return ptr;
+        }
+
+        void deallocate(pointer p, size_type n)
+        {
+            // Only checking tags when propagating swap.
+            // Note that tags will be tested
+            // properly in the normal allocator.
+            detail::tracker.track_deallocate((void*) p, n, sizeof(T), tag_,
+                 !force_equal_allocator_value);
+            ::operator delete((void*) p);
+        }
+
+        void construct(T* p, T const& t) {
+            detail::tracker.track_construct((void*) p, sizeof(T), tag_);
+            new(p) T(t);
+        }
+
+#if defined(BOOST_UNORDERED_VARIADIC_MOVE)
+        template<typename... Args> void construct(T* p, Args&&... args) {
+            detail::tracker.track_construct((void*) p, sizeof(T), tag_);
+            new(p) T(boost::forward<Args>(args)...);
+        }
+#endif
+
+        void destroy(T* p) {
+            detail::tracker.track_destroy((void*) p, sizeof(T), tag_);
+            p->~T();
+        }
+
+        size_type max_size() const {
+            return (std::numeric_limits<size_type>::max)();
+        }
+    };
+
+    template <typename T, typename Flags = propagate_swap,
+        typename Enable = void>
+    struct cxx11_allocator;
+
+    template <typename T, typename Flags>
+    struct cxx11_allocator<
+        T, Flags,
+        typename boost::disable_if_c<Flags::is_select_on_copy>::type
+    > : public cxx11_allocator_base<T>,
+        public swap_allocator_base<Flags>,
+        public assign_allocator_base<Flags>,
+        public move_allocator_base<Flags>,
+        Flags
+    {
+        template <typename U> struct rebind {
+            typedef cxx11_allocator<U, Flags> other;
+        };
+
+        explicit cxx11_allocator(int t = 0)
+            : cxx11_allocator_base<T>(t)
+        {
+        }
+        
+        template <typename Y> cxx11_allocator(
+                cxx11_allocator<Y, Flags> const& x)
+            : cxx11_allocator_base<T>(x)
+        {
+        }
+
+        cxx11_allocator(cxx11_allocator const& x)
+            : cxx11_allocator_base<T>(x)
+        {
+        }
+
+        // When not propagating swap, allocators are always equal
+        // to avoid undefined behaviour.
+        bool operator==(cxx11_allocator const& x) const
+        {
+            return force_equal_allocator_value || (this->tag_ == x.tag_);
+        }
+
+        bool operator!=(cxx11_allocator const& x) const
+        {
+            return !(*this == x);
+        }
+    };
+
+    template <typename T, typename Flags>
+    struct cxx11_allocator<
+        T, Flags,
+        typename boost::enable_if_c<Flags::is_select_on_copy>::type
+    > : public cxx11_allocator_base<T>,
+        public swap_allocator_base<Flags>,
+        public assign_allocator_base<Flags>,
+        public move_allocator_base<Flags>,
+        Flags
+    {
+        cxx11_allocator select_on_container_copy_construction() const
+        {
+            cxx11_allocator tmp(*this);
+            ++tmp.selected_;
+            return tmp;
+        }
+
+        template <typename U> struct rebind {
+            typedef cxx11_allocator<U, Flags> other;
+        };
+
+        explicit cxx11_allocator(int t = 0)
+            : cxx11_allocator_base<T>(t)
+        {
+        }
+        
+        template <typename Y> cxx11_allocator(
+                cxx11_allocator<Y, Flags> const& x)
+            : cxx11_allocator_base<T>(x)
+        {
+        }
+
+        cxx11_allocator(cxx11_allocator const& x)
+            : cxx11_allocator_base<T>(x)
+        {
+        }
+
+        // When not propagating swap, allocators are always equal
+        // to avoid undefined behaviour.
+        bool operator==(cxx11_allocator const& x) const
+        {
+            return force_equal_allocator_value || (this->tag_ == x.tag_);
+        }
+
+        bool operator!=(cxx11_allocator const& x) const
+        {
+            return !(*this == x);
+        }
+    };
+
+    template <typename T, typename Flags>
+    bool equivalent_impl(
+            cxx11_allocator<T, Flags> const& x,
+            cxx11_allocator<T, Flags> const& y,
+            test::derived_type)
+    {
+        return x.tag_ == y.tag_;
+    }
+
+    template <typename T, typename Flags>
+    int selected_count(cxx11_allocator<T, Flags> const& x)
+    {
+        return x.selected_;
+    }
+}
+
+#endif

test/objects/exception.hpp

@@ -1,5 +1,5 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
@@ -34,6 +34,16 @@ namespace exception
     template <class T> class allocator;
     object generate(object const*);
 
+    struct true_type
+    {
+        enum { value = true };
+    };
+
+    struct false_type
+    {
+        enum { value = false };
+    };
+
     class object
     {
     public:
@@ -340,24 +350,24 @@ namespace exception
         }
 
         void construct(pointer p, T const& t) {
-            UNORDERED_SCOPE(allocator::construct(pointer, T)) {
+            UNORDERED_SCOPE(allocator::construct(T*, T)) {
                 UNORDERED_EPOINT("Mock allocator construct function.");
                 new(p) T(t);
             }
             detail::tracker.track_construct((void*) p, sizeof(T), tag_);
         }
 
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
-        template<class... Args> void construct(pointer p, Args&&... args) {
+#if defined(BOOST_UNORDERED_VARIADIC_MOVE)
+        template<class... Args> void construct(T* p, Args&&... args) {
             UNORDERED_SCOPE(allocator::construct(pointer, Args&&...)) {
                 UNORDERED_EPOINT("Mock allocator construct function.");
-                new(p) T(std::forward<Args>(args)...);
+                new(p) T(boost::forward<Args>(args)...);
             }
             detail::tracker.track_construct((void*) p, sizeof(T), tag_);
         }
 #endif
 
-        void destroy(pointer p) {
+        void destroy(T* p) {
             detail::tracker.track_destroy((void*) p, sizeof(T), tag_);
             p->~T();
         }
@@ -368,6 +378,10 @@ namespace exception
             }
             return (std::numeric_limits<std::size_t>::max)();
         }
+
+        typedef true_type propagate_on_container_copy_assignment;
+        typedef true_type propagate_on_container_move_assignment;
+        typedef true_type propagate_on_container_swap;
     };
 
     template <class T>

test/objects/fwd.hpp

@@ -1,5 +1,5 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 

test/objects/minimal.hpp

@@ -1,5 +1,5 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
@@ -11,6 +11,8 @@
 #define BOOST_UNORDERED_OBJECTS_MINIMAL_HEADER
 
 #include <cstddef>
+#include <boost/move/move.hpp>
+#include <utility>
 
 #if defined(BOOST_MSVC)
 #pragma warning(push)
@@ -21,21 +23,40 @@ namespace test
 {
 namespace minimal
 {
+    class destructible;
     class copy_constructible;
     class copy_constructible_equality_comparable;
     class default_copy_constructible;
     class assignable;
 
+    struct ampersand_operator_used {};
+
     template <class T> class hash;
     template <class T> class equal_to;
     template <class T> class ptr;
     template <class T> class const_ptr;
     template <class T> class allocator;
+    template <class T> class cxx11_allocator;
+
+    struct constructor_param
+    {
+        operator int() const { return 0; }
+    };
+
+    class destructible
+    {
+    public:
+        destructible(constructor_param const&) {}
+        ~destructible() {}
+    private:
+        destructible(destructible const&);
+        destructible& operator=(destructible const&);
+    };
 
     class copy_constructible
     {
     public:
-        static copy_constructible create() { return copy_constructible(); }
+        copy_constructible(constructor_param const&) {}
         copy_constructible(copy_constructible const&) {}
         ~copy_constructible() {}
     private:
@@ -46,91 +67,210 @@ namespace minimal
     class copy_constructible_equality_comparable
     {
     public:
-        static copy_constructible_equality_comparable create() { return copy_constructible_equality_comparable(); }
-        copy_constructible_equality_comparable(copy_constructible_equality_comparable const&) {}
-        ~copy_constructible_equality_comparable() {}
+        copy_constructible_equality_comparable(constructor_param const&) {}
+
+        copy_constructible_equality_comparable(
+            copy_constructible_equality_comparable const&)
+        {
+        }
+
+        ~copy_constructible_equality_comparable()
+        {
+        }
+
     private:
-        copy_constructible_equality_comparable& operator=(copy_constructible_equality_comparable const&);
+        copy_constructible_equality_comparable& operator=(
+            copy_constructible_equality_comparable const&);
         copy_constructible_equality_comparable() {}
+        ampersand_operator_used operator&() const { return ampersand_operator_used(); }
     };
 
-    bool operator==(copy_constructible_equality_comparable, copy_constructible_equality_comparable) {
+    bool operator==(
+        copy_constructible_equality_comparable,
+        copy_constructible_equality_comparable)
+    {
         return true;
     }
 
-    bool operator!=(copy_constructible_equality_comparable, copy_constructible_equality_comparable) {
+    bool operator!=(
+        copy_constructible_equality_comparable,
+        copy_constructible_equality_comparable)
+    {
         return false;
     }
 
     class default_copy_constructible
     {
     public:
-        static default_copy_constructible create() { return default_copy_constructible(); }
-        default_copy_constructible() {}
-        default_copy_constructible(default_copy_constructible const&) {}
-        ~default_copy_constructible() {}
+        default_copy_constructible(constructor_param const&) {}
+
+        default_copy_constructible()
+        {
+        }
+
+        default_copy_constructible(default_copy_constructible const&)
+        {
+        }
+
+        ~default_copy_constructible()
+        {
+        }
+
     private:
-        default_copy_constructible& operator=(default_copy_constructible const&);
+        default_copy_constructible& operator=(
+            default_copy_constructible const&);
+        ampersand_operator_used operator&() const {
+            return ampersand_operator_used(); }
     };
 
     class assignable
     {
     public:
-        static assignable create() { return assignable(); }
+        assignable(constructor_param const&) {}
         assignable(assignable const&) {}
         assignable& operator=(assignable const&) { return *this; }
         ~assignable() {}
+
     private:
         assignable() {}
+        // TODO: This messes up a concept check in the tests.
+        //ampersand_operator_used operator&() const { return ampersand_operator_used(); }
     };
 
+    struct movable_init {};
+
+    class movable1
+    {
+        BOOST_MOVABLE_BUT_NOT_COPYABLE(movable1)
+
+    public:
+        movable1(constructor_param const&) {}
+        movable1() {}
+        explicit movable1(movable_init) {}
+        movable1(BOOST_RV_REF(movable1)) {}
+        movable1& operator=(BOOST_RV_REF(movable1));
+        ~movable1() {}
+    };
+
+#if !defined(BOOST_NO_RVALUE_REFERENCES)
+    class movable2
+    {
+    public:
+        movable2(constructor_param const&) {}
+        explicit movable2(movable_init) {}
+        movable2(movable2&&) {}
+        ~movable2() {}
+    private:
+        movable2() {}
+        movable2(movable2 const&);
+        movable2& operator=(movable2 const&);
+    };
+#else
+    typedef movable1 movable2;
+#endif
+
     template <class T>
     class hash
     {
     public:
-        static hash create() { return hash<T>(); }
+        hash(constructor_param const&) {}
         hash() {}
         hash(hash const&) {}
         hash& operator=(hash const&) { return *this; }
         ~hash() {}
 
         std::size_t operator()(T const&) const { return 0; }
+    private:
+        ampersand_operator_used operator&() const { return ampersand_operator_used(); }
     };
 
     template <class T>
     class equal_to
     {
     public:
-        static equal_to create() { return equal_to<T>(); }
+        equal_to(constructor_param const&) {}
         equal_to() {}
         equal_to(equal_to const&) {}
         equal_to& operator=(equal_to const&) { return *this; }
         ~equal_to() {}
 
         bool operator()(T const&, T const&) const { return true; }
+    private:
+        ampersand_operator_used operator&() const { return ampersand_operator_used(); }
     };
 
     template <class T> class ptr;
     template <class T> class const_ptr;
 
+    struct void_ptr
+    {
+#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+        template <typename T>
+        friend class ptr;
+    private:
+#endif
+
+        void* ptr_;
+
+    public:
+        void_ptr() : ptr_(0) {}
+
+        template <typename T>
+        explicit void_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
+
+        // I'm not using the safe bool idiom because the containers should be
+        // able to cope with bool conversions.
+        operator bool() const { return !!ptr_; }
+
+        bool operator==(void_ptr const& x) const { return ptr_ == x.ptr_; }
+        bool operator!=(void_ptr const& x) const { return ptr_ != x.ptr_; }
+    };
+
+    class void_const_ptr
+    {
+#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+        template <typename T>
+        friend class const_ptr;
+    private:
+#endif
+
+        void* ptr_;
+
+    public:
+        void_const_ptr() : ptr_(0) {}
+
+        template <typename T>
+        explicit void_const_ptr(const_ptr<T> const& x) : ptr_(x.ptr_) {}
+
+        // I'm not using the safe bool idiom because the containers should be
+        // able to cope with bool conversions.
+        operator bool() const { return !!ptr_; }
+
+        bool operator==(void_const_ptr const& x) const { return ptr_ == x.ptr_; }
+        bool operator!=(void_const_ptr const& x) const { return ptr_ != x.ptr_; }
+    };
+
     template <class T>
     class ptr
     {
         friend class allocator<T>;
         friend class const_ptr<T>;
+        friend struct void_ptr;
 
         T* ptr_;
 
         ptr(T* x) : ptr_(x) {}
     public:
         ptr() : ptr_(0) {}
+        explicit ptr(void_ptr const& x) : ptr_((T*) x.ptr_) {}
 
         T& operator*() const { return *ptr_; }
         T* operator->() const { return ptr_; }
         ptr& operator++() { ++ptr_; return *this; }
         ptr operator++(int) { ptr tmp(*this); ++ptr_; return tmp; }
         ptr operator+(std::ptrdiff_t s) const { return ptr<T>(ptr_ + s); }
-        friend ptr operator+(std::ptrdiff_t s, ptr p) { return ptr<T>(s + p.ptr_); }
+        friend ptr operator+(std::ptrdiff_t s, ptr p)
+            { return ptr<T>(s + p.ptr_); }
         T& operator[](std::ptrdiff_t s) const { return ptr_[s]; }
         bool operator!() const { return !ptr_; }
         
@@ -144,19 +284,16 @@ namespace minimal
         bool operator>(ptr const& x) const { return ptr_ > x.ptr_; }
         bool operator<=(ptr const& x) const { return ptr_ <= x.ptr_; }
         bool operator>=(ptr const& x) const { return ptr_ >= x.ptr_; }
-
-        bool operator==(const_ptr<T> const& x) const { return ptr_ == x.ptr_; }
-        bool operator!=(const_ptr<T> const& x) const { return ptr_ != x.ptr_; }
-        bool operator<(const_ptr<T> const& x) const { return ptr_ < x.ptr_; }
-        bool operator>(const_ptr<T> const& x) const { return ptr_ > x.ptr_; }
-        bool operator<=(const_ptr<T> const& x) const { return ptr_ <= x.ptr_; }
-        bool operator>=(const_ptr<T> const& x) const { return ptr_ >= x.ptr_; }
+    private:
+        // TODO:
+        //ampersand_operator_used operator&() const { return ampersand_operator_used(); }
     };
 
     template <class T>
     class const_ptr
     {
         friend class allocator<T>;
+        friend struct const_void_ptr;
 
         T const* ptr_;
 
@@ -164,30 +301,29 @@ namespace minimal
     public:
         const_ptr() : ptr_(0) {}
         const_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
+        explicit const_ptr(void_const_ptr const& x) : ptr_((T const*) x.ptr_) {}
 
         T const& operator*() const { return *ptr_; }
         T const* operator->() const { return ptr_; }
         const_ptr& operator++() { ++ptr_; return *this; }
         const_ptr operator++(int) { const_ptr tmp(*this); ++ptr_; return tmp; }
-        const_ptr operator+(std::ptrdiff_t s) const { return const_ptr(ptr_ + s); }
-        friend const_ptr operator+(std::ptrdiff_t s, const_ptr p) { return ptr<T>(s + p.ptr_); }
+        const_ptr operator+(std::ptrdiff_t s) const
+            { return const_ptr(ptr_ + s); }
+        friend const_ptr operator+(std::ptrdiff_t s, const_ptr p)
+            { return ptr<T>(s + p.ptr_); }
         T const& operator[](int s) const { return ptr_[s]; }
         bool operator!() const { return !ptr_; }
         operator bool() const { return !!ptr_; }
 
-        bool operator==(ptr<T> const& x) const { return ptr_ == x.ptr_; }
-        bool operator!=(ptr<T> const& x) const { return ptr_ != x.ptr_; }
-        bool operator<(ptr<T> const& x) const { return ptr_ < x.ptr_; }
-        bool operator>(ptr<T> const& x) const { return ptr_ > x.ptr_; }
-        bool operator<=(ptr<T> const& x) const { return ptr_ <= x.ptr_; }
-        bool operator>=(ptr<T> const& x) const { return ptr_ >= x.ptr_; }
-
         bool operator==(const_ptr const& x) const { return ptr_ == x.ptr_; }
         bool operator!=(const_ptr const& x) const { return ptr_ != x.ptr_; }
         bool operator<(const_ptr const& x) const { return ptr_ < x.ptr_; }
         bool operator>(const_ptr const& x) const { return ptr_ > x.ptr_; }
         bool operator<=(const_ptr const& x) const { return ptr_ <= x.ptr_; }
         bool operator>=(const_ptr const& x) const { return ptr_ >= x.ptr_; }
+    private:
+        // TODO:
+        //ampersand_operator_used operator&() const { return ampersand_operator_used(); }
     };
 
     template <class T>
@@ -196,6 +332,8 @@ namespace minimal
     public:
         typedef std::size_t size_type;
         typedef std::ptrdiff_t difference_type;
+        typedef void_ptr void_pointer;
+        typedef void_const_ptr const_void_pointer;
         typedef ptr<T> pointer;
         typedef const_ptr<T> const_pointer;
         typedef T& reference;
@@ -227,24 +365,26 @@ namespace minimal
             ::operator delete((void*) p.ptr_);
         }
 
-        void construct(pointer p, T const& t) { new((void*)p.ptr_) T(t); }
+        void construct(T* p, T const& t) { new((void*)p) T(t); }
 
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
-        template<class... Args> void construct(pointer p, Args&&... args) {
-            new((void*)p.ptr_) T(std::forward<Args>(args)...);
+#if defined(BOOST_UNORDERED_VARIADIC_MOVE)
+        template<class... Args> void construct(T* p, Args&&... args) {
+            new((void*)p) T(boost::forward<Args>(args)...);
         }
 #endif
 
-        void destroy(pointer p) { ((T*)p.ptr_)->~T(); }
+        void destroy(T* p) { p->~T(); }
 
         size_type max_size() const { return 1000; }
 
 #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) || \
-        BOOST_WORKAROUND(MSVC, <= 1300)
+        BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
     public: allocator& operator=(allocator const&) { return *this;}
 #else
     private: allocator& operator=(allocator const&);
 #endif
+    private:
+        ampersand_operator_used operator&() const { return ampersand_operator_used(); }
     };
 
     template <class T>
@@ -263,6 +403,69 @@ namespace minimal
     void swap(allocator<T>&, allocator<T>&)
     {
     }
+
+    // C++11 allocator
+    //
+    // Not a fully minimal C++11 allocator, just what I support. Hopefully will
+    // cut down further in the future.
+
+    template <class T>
+    class cxx11_allocator
+    {
+    public:
+        typedef T value_type;
+        template <class U> struct rebind { typedef cxx11_allocator<U> other; };
+
+        cxx11_allocator() {}
+        template <class Y> cxx11_allocator(cxx11_allocator<Y> const&) {}
+        cxx11_allocator(cxx11_allocator const&) {}
+        ~cxx11_allocator() {}
+
+        T* address(T& r) { return &r; }
+        T const* address(T const& r) { return &r; }
+
+        T* allocate(std::size_t n) {
+            return static_cast<T*>(::operator new(n * sizeof(T)));
+        }
+
+        template <class Y>
+        T* allocate(std::size_t n, const_ptr<Y> u) {
+            return static_cast<T*>(::operator new(n * sizeof(T)));
+        }
+
+        void deallocate(T* p, std::size_t) {
+            ::operator delete((void*) p);
+        }
+
+        void construct(T* p, T const& t) { new((void*)p) T(t); }
+
+#if defined(BOOST_UNORDERED_VARIADIC_MOVE)
+        template<class... Args> void construct(T* p, Args&&... args) {
+            new((void*)p) T(boost::forward<Args>(args)...);
+        }
+#endif
+
+        void destroy(T* p) { p->~T(); }
+
+        std::size_t max_size() const { return 1000u; }
+    };
+
+    template <class T>
+    inline bool operator==(cxx11_allocator<T> const&, cxx11_allocator<T> const&)
+    {
+        return true;
+    }
+
+    template <class T>
+    inline bool operator!=(cxx11_allocator<T> const&, cxx11_allocator<T> const&)
+    {
+        return false;
+    }
+
+    template <class T>
+    void swap(cxx11_allocator<T>&, cxx11_allocator<T>&)
+    {
+    }
 }
 }
 
@@ -272,7 +475,9 @@ namespace boost {
 namespace test {
 namespace minimal {
 #endif
-    std::size_t hash_value(test::minimal::copy_constructible_equality_comparable) {
+    std::size_t hash_value(
+        test::minimal::copy_constructible_equality_comparable)
+    {
         return 1;
     }
 #if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)

test/objects/test.hpp

@@ -1,5 +1,5 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
@@ -9,24 +9,24 @@
 #include <boost/config.hpp>
 #include <boost/limits.hpp>
 #include <cstddef>
-#include <iostream>
 #include "../helpers/fwd.hpp"
 #include "../helpers/count.hpp"
 #include "../helpers/memory.hpp"
-#include <map>
 
 namespace test
 {
     // Note that the default hash function will work for any equal_to (but not
     // very well).
     class object;
+    class implicitly_convertible;
     class hash;
     class less;
     class equal_to;
     template <class T> class allocator;
     object generate(object const*);
-
-    class object : globally_counted_object
+    implicitly_convertible generate(implicitly_convertible const*);
+    
+    class object : private globally_counted_object
     {
         friend class hash;
         friend class equal_to;
@@ -64,6 +64,31 @@ namespace test
         }
     };
 
+    class implicitly_convertible : private globally_counted_object
+    {
+        int tag1_, tag2_;
+    public:
+
+        explicit implicitly_convertible(int t1 = 0, int t2 = 0)
+            : tag1_(t1), tag2_(t2)
+            {}
+
+        operator object() const
+        {
+            return object(tag1_, tag2_);
+        }
+
+        friend implicitly_convertible generate(implicitly_convertible const*) {
+            int* x = 0;
+            return implicitly_convertible(generate(x), generate(x));
+        }
+
+        friend std::ostream& operator<<(std::ostream& out, implicitly_convertible const& o)
+        {
+            return out<<"("<<o.tag1_<<","<<o.tag2_<<")";
+        }
+    };
+
     class hash
     {
         int type_;
@@ -93,6 +118,10 @@ namespace test
             return x1.type_ != x2.type_;
         }
     };
+    
+    std::size_t hash_value(test::object const& x) {
+        return hash()(x);
+    }
 
     class less
     {
@@ -154,18 +183,6 @@ namespace test
         }
     };
 
-    namespace detail
-    {
-        // This won't be a problem as I'm only using a single compile unit
-        // in each test (this is actually require by the minimal test
-        // framework).
-        // 
-        // boostinspect:nounnamed
-        namespace {
-            test::detail::memory_tracker<std::allocator<int> > tracker;
-        }
-    }
-
     template <class T>
     class allocator
     {
@@ -186,13 +203,37 @@ namespace test
 
         template <class U> struct rebind { typedef allocator<U> other; };
 
-        explicit allocator(int t = 0) : tag_(t) { detail::tracker.allocator_ref(); }
-        template <class Y> allocator(allocator<Y> const& x) : tag_(x.tag_) { detail::tracker.allocator_ref(); }
-        allocator(allocator const& x) : tag_(x.tag_) { detail::tracker.allocator_ref(); }
-        ~allocator() { detail::tracker.allocator_unref(); }
+        explicit allocator(int t = 0) : tag_(t)
+        {
+            detail::tracker.allocator_ref();
+        }
+        
+        template <class Y> allocator(allocator<Y> const& x)
+            : tag_(x.tag_)
+        {
+            detail::tracker.allocator_ref();
+        }
 
-        pointer address(reference r) { return pointer(&r); }
-        const_pointer address(const_reference r) { return const_pointer(&r); }
+        allocator(allocator const& x)
+            : tag_(x.tag_)
+        {
+            detail::tracker.allocator_ref();
+        }
+
+        ~allocator()
+        {
+            detail::tracker.allocator_unref();
+        }
+
+        pointer address(reference r)
+        {
+            return pointer(&r);
+        }
+
+        const_pointer address(const_reference r)
+        {
+            return const_pointer(&r);
+        }
 
         pointer allocate(size_type n) {
             pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
@@ -213,19 +254,19 @@ namespace test
             ::operator delete((void*) p);
         }
 
-        void construct(pointer p, T const& t) {
+        void construct(T* p, T const& t) {
             detail::tracker.track_construct((void*) p, sizeof(T), tag_);
             new(p) T(t);
         }
 
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
-        template<class... Args> void construct(pointer p, Args&&... args) {
+#if defined(BOOST_UNORDERED_VARIADIC_MOVE)
+        template<class... Args> void construct(T* p, Args&&... args) {
             detail::tracker.track_construct((void*) p, sizeof(T), tag_);
-            new(p) T(std::forward<Args>(args)...);
+            new(p) T(boost::forward<Args>(args)...);
         }
 #endif
 
-        void destroy(pointer p) {
+        void destroy(T* p) {
             detail::tracker.track_destroy((void*) p, sizeof(T), tag_);
             p->~T();
         }
@@ -243,50 +284,21 @@ namespace test
         {
             return tag_ != x.tag_;
         }
+
+        enum {
+            is_select_on_copy = false,
+            is_propagate_on_swap = false,
+            is_propagate_on_assign = false,
+            is_propagate_on_move = false
+        };
     };
 
     template <class T>
-    bool equivalent_impl(allocator<T> const& x, allocator<T> const& y, test::derived_type) {
+    bool equivalent_impl(allocator<T> const& x, allocator<T> const& y,
+        test::derived_type)
+    {
         return x == y;
     }
-
-#if BOOST_WORKAROUND(__GNUC__, < 3)
-    void swap(test::object& x, test::object& y) {
-        test::object tmp;
-        tmp = x;
-        x = y;
-        y = tmp;
-    }
-
-    void swap(test::hash& x, test::hash& y) {
-        test::hash tmp;
-        tmp = x;
-        x = y;
-        y = tmp;
-    }
-
-    void swap(test::less& x, test::less& y) {
-        test::less tmp;
-        tmp = x;
-        x = y;
-        y = tmp;
-    }
-
-    void swap(test::equal_to& x, test::equal_to& y) {
-        test::equal_to tmp;
-        tmp = x;
-        x = y;
-        y = tmp;
-    }
-
-    template <class T>
-    void swap(test::allocator<T>& x, test::allocator<T>& y) {
-        test::allocator<T> tmp;
-        tmp = x;
-        x = y;
-        y = tmp;
-    }
-#endif
 }
 
 #endif

test/unordered/Jamfile.v2

@@ -7,23 +7,39 @@ import testing ;
 
 project unordered-test/unordered
     : requirements
-        <toolset>intel-linux:"<cxxflags>-strict_ansi -cxxlib-icc"
-        <toolset>gcc:<cxxflags>"-Wsign-promo -Wunused-parameter"
-        #<toolset>msvc:<cxxflags>/W4
+        <warnings>all
+        <toolset>intel:<warnings>on
+        # Would be nice to define -Wundef, but I'm getting warnings from
+        # Boost.Preprocessor on trunk.
+        <toolset>gcc:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter -Wconversion -Wno-long-long"
+        <toolset>darwin:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter -Wconversion"
+        #<toolset>gcc:<define>_GLIBCXX_DEBUG
+        #<toolset>darwin:<define>_GLIBCXX_DEBUG
+        #<toolset>msvc:<warnings-as-errors>on
+        <toolset>gcc:<warnings-as-errors>on
+        <toolset>darwin:<warnings-as-errors>on
     ;
 
 test-suite unordered
     :
+        [ run fwd_set_test.cpp ]
+        [ run fwd_map_test.cpp ]
+        [ run allocator_traits.cpp ]
+        [ run minimal_allocator.cpp ]
         [ run compile_set.cpp ]
         [ run compile_map.cpp ]
         [ run link_test_1.cpp link_test_2.cpp ]
+        [ run incomplete_test.cpp ]
         [ run simple_tests.cpp ]
         [ run equivalent_keys_tests.cpp ]
         [ run constructor_tests.cpp ]
         [ run copy_tests.cpp ]
-        [ run move_tests.cpp : : : <test-info>always_show_run_output ]
+        [ run move_tests.cpp ]
         [ run assign_tests.cpp ]
         [ run insert_tests.cpp ]
+        [ run insert_tests.cpp : :
+            : <define>BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT
+            : insert_deprecated ]
         [ run insert_stable_tests.cpp ]
         [ run unnecessary_copy_tests.cpp ]
         [ run erase_tests.cpp ]
@@ -34,5 +50,22 @@ test-suite unordered
         [ run load_factor_tests.cpp ]
         [ run rehash_tests.cpp ]
         [ run equality_tests.cpp ]
-        [ run swap_tests.cpp : : : <define>BOOST_UNORDERED_SWAP_METHOD=2 ]
+        [ run equality_deprecated.cpp ]
+        [ run swap_tests.cpp ]
+
+        [ run compile_set.cpp : :
+            : <define>BOOST_UNORDERED_USE_MOVE
+            : bmove_compile_set ]
+        [ run compile_map.cpp : :
+            : <define>BOOST_UNORDERED_USE_MOVE
+            : bmove_compile_map ]
+        [ run copy_tests.cpp : :
+            : <define>BOOST_UNORDERED_USE_MOVE
+            : bmove_copy ]
+        [ run move_tests.cpp : :
+            : <define>BOOST_UNORDERED_USE_MOVE
+            : bmove_move ]
+        [ run assign_tests.cpp : :
+            : <define>BOOST_UNORDERED_USE_MOVE
+            : bmove_assign ]
     ;

test/unordered/allocator_traits.cpp

@@ -0,0 +1,254 @@
+
+// Copyright 2011 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)
+
+#include <boost/unordered/detail/allocator_helpers.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/limits.hpp>
+
+// Boilerplate
+
+#define ALLOCATOR_METHODS(name)                                             \
+    template <typename U> struct rebind {                                   \
+        typedef name<U> other;                                              \
+    };                                                                      \
+                                                                            \
+    name() {}                                                               \
+    template <typename Y> name(name<Y> const&) {}                           \
+    T* address(T& r) { return &r;}                                          \
+    T const* address(T const& r) { return &r; }                             \
+    T* allocate(std::size_t n)                                              \
+    { return static_cast<T*>(::operator new(n * sizeof(T))); }              \
+    T* allocate(std::size_t n, void const* u)                               \
+    { return static_cast<T*>(::operator new(n * sizeof(T))); }              \
+    void deallocate(T* p, std::size_t n) { ::operator delete((void*) p); }  \
+    void construct(T* p, T const& t) { new(p) T(t); }                       \
+    void destroy(T* p) { p->~T(); }                                         \
+    std::size_t max_size() const                                            \
+    { return (std::numeric_limits<std::size_t>::max)(); }                   \
+    bool operator==(name<T> const&) { return true; }                        \
+    bool operator!=(name<T> const&) { return false; }                       \
+/**/
+
+#define ALLOCATOR_METHODS_TYPEDEFS(name)                                    \
+    template <typename U> struct rebind {                                   \
+        typedef name<U> other;                                              \
+    };                                                                      \
+                                                                            \
+    name() {}                                                               \
+    template <typename Y> name(name<Y> const&) {}                           \
+    pointer address(T& r) { return &r;}                                     \
+    const_pointer address(T const& r) { return &r; }                        \
+    pointer allocate(std::size_t n)                                         \
+    { return pointer(::operator new(n * sizeof(T))); }                      \
+    pointer allocate(std::size_t n, void const* u)                          \
+    { return pointer(::operator new(n * sizeof(T))); }                      \
+    void deallocate(pointer p, std::size_t n)                               \
+    { ::operator delete((void*) p); }                                       \
+    void construct(T* p, T const& t) { new(p) T(t); }                       \
+    void destroy(T* p) { p->~T(); }                                         \
+    size_type max_size() const                                              \
+    { return (std::numeric_limits<size_type>::max)(); }                     \
+    bool operator==(name<T> const&) { return true; }                        \
+    bool operator!=(name<T> const&) { return false; }                       \
+/**/
+
+struct yes_type { enum { value = true }; };
+struct no_type { enum { value = false }; };
+
+// For tracking calls...
+
+static int selected;
+void reset() {
+    selected = 0;
+}
+
+template <typename Allocator>
+int call_select()
+{
+    typedef boost::unordered::detail::allocator_traits<Allocator> traits;
+    Allocator a;
+
+    reset();
+    BOOST_TEST(traits::select_on_container_copy_construction(a) == a);
+    return selected;
+}
+
+// Empty allocator test
+
+template <typename T>
+struct empty_allocator
+{
+    typedef T value_type;
+    ALLOCATOR_METHODS(empty_allocator)
+};
+
+void test_empty_allocator()
+{
+    typedef empty_allocator<int> allocator;
+    typedef boost::unordered::detail::allocator_traits<allocator> traits;
+#if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS
+    BOOST_MPL_ASSERT((boost::is_same<traits::size_type,
+        std::make_unsigned<std::ptrdiff_t>::type>));
+#else
+    BOOST_MPL_ASSERT((boost::is_same<traits::size_type, std::size_t>));
+#endif
+    BOOST_MPL_ASSERT((boost::is_same<traits::difference_type, std::ptrdiff_t>));
+    BOOST_MPL_ASSERT((boost::is_same<traits::pointer, int*>));
+    BOOST_MPL_ASSERT((boost::is_same<traits::const_pointer, int const*>));
+    BOOST_MPL_ASSERT((boost::is_same<traits::value_type, int>));
+    BOOST_TEST(!traits::propagate_on_container_copy_assignment::value);
+    BOOST_TEST(!traits::propagate_on_container_move_assignment::value);
+    BOOST_TEST(!traits::propagate_on_container_swap::value);
+    BOOST_TEST(call_select<allocator>() == 0);
+}
+
+// allocator 1
+
+template <typename T>
+struct allocator1
+{
+    typedef T value_type;
+    ALLOCATOR_METHODS(allocator1)
+    
+    typedef yes_type propagate_on_container_copy_assignment;
+    typedef yes_type propagate_on_container_move_assignment;
+    typedef yes_type propagate_on_container_swap;
+    
+    allocator1<T> select_on_container_copy_construction() const {
+        ++selected;
+        return allocator1<T>();
+    }
+};
+
+void test_allocator1()
+{
+    typedef allocator1<int> allocator;
+    typedef boost::unordered::detail::allocator_traits<allocator> traits;
+#if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS
+    BOOST_MPL_ASSERT((boost::is_same<typename traits::size_type,
+        std::make_unsigned<std::ptrdiff_t>::type>));
+#else
+    BOOST_MPL_ASSERT((boost::is_same<traits::size_type, std::size_t>));
+#endif
+    BOOST_MPL_ASSERT((boost::is_same<traits::difference_type, std::ptrdiff_t>));
+    BOOST_MPL_ASSERT((boost::is_same<traits::pointer, int*>));
+    BOOST_MPL_ASSERT((boost::is_same<traits::const_pointer, int const*>));
+    BOOST_MPL_ASSERT((boost::is_same<traits::value_type, int>));
+    BOOST_TEST(traits::propagate_on_container_copy_assignment::value);
+    BOOST_TEST(traits::propagate_on_container_move_assignment::value);
+    BOOST_TEST(traits::propagate_on_container_swap::value);
+    BOOST_TEST(call_select<allocator>() == 1);
+}
+
+// allocator 2
+
+template <typename Alloc>
+struct allocator2_base
+{
+    Alloc select_on_container_copy_construction() const {
+        ++selected;
+        return Alloc();
+    }
+};
+
+template <typename T>
+struct allocator2 : allocator2_base<allocator2<T> >
+{
+    typedef T value_type;
+    typedef T* pointer;
+    typedef T const* const_pointer;
+    typedef std::size_t size_type;
+    
+    ALLOCATOR_METHODS(allocator2)
+    
+    typedef no_type propagate_on_container_copy_assignment;
+    typedef no_type propagate_on_container_move_assignment;
+    typedef no_type propagate_on_container_swap;
+};
+
+void test_allocator2()
+{
+    typedef allocator2<int> allocator;
+    typedef boost::unordered::detail::allocator_traits<allocator> traits;
+    BOOST_MPL_ASSERT((boost::is_same<traits::size_type, std::size_t>));
+    BOOST_MPL_ASSERT((boost::is_same<traits::difference_type, std::ptrdiff_t>));
+    BOOST_MPL_ASSERT((boost::is_same<traits::pointer, int*>));
+    BOOST_MPL_ASSERT((boost::is_same<traits::const_pointer, int const*>));
+    BOOST_MPL_ASSERT((boost::is_same<traits::value_type, int>));
+    BOOST_TEST(!traits::propagate_on_container_copy_assignment::value);
+    BOOST_TEST(!traits::propagate_on_container_move_assignment::value);
+    BOOST_TEST(!traits::propagate_on_container_swap::value);
+    BOOST_TEST(call_select<allocator>() == 1);
+}
+
+// allocator 3
+
+template <typename T>
+struct ptr
+{
+    T* value_;
+    
+    ptr(void* v) : value_((T*) v) {}
+    T& operator*() const { return *value_; }
+};
+
+template <>
+struct ptr<void>
+{
+    void* value_;
+    ptr(void* v) : value_(v) {}
+};
+
+template <>
+struct ptr<const void>
+{
+    void const* value_;
+    ptr(void const* v) : value_(v) {}
+};
+
+template <typename T>
+struct allocator3
+{
+    typedef T value_type;
+    typedef ptr<T> pointer;
+    typedef ptr<T const> const_pointer;
+    typedef unsigned short size_type;
+
+    ALLOCATOR_METHODS_TYPEDEFS(allocator3)
+    
+    typedef yes_type propagate_on_container_copy_assignment;
+    typedef no_type propagate_on_container_move_assignment;
+
+    allocator3<T> select_on_container_copy_construction() const {
+        ++selected;
+        return allocator3<T>();
+    }
+};
+
+void test_allocator3()
+{
+    typedef allocator3<int> allocator;
+    typedef boost::unordered::detail::allocator_traits<allocator> traits;
+    BOOST_MPL_ASSERT((boost::is_same<traits::size_type, unsigned short>));
+    BOOST_MPL_ASSERT((boost::is_same<traits::difference_type, std::ptrdiff_t>));
+    BOOST_MPL_ASSERT((boost::is_same<traits::pointer, ptr<int> >));
+    BOOST_MPL_ASSERT((boost::is_same<traits::const_pointer, ptr<int const> >));
+    BOOST_MPL_ASSERT((boost::is_same<traits::value_type, int>));
+    BOOST_TEST(traits::propagate_on_container_copy_assignment::value);
+    BOOST_TEST(!traits::propagate_on_container_move_assignment::value);
+    BOOST_TEST(!traits::propagate_on_container_swap::value);
+    BOOST_TEST(call_select<allocator>() == 1);
+}
+
+int main()
+{
+    test_empty_allocator();
+    test_allocator1();
+    test_allocator2();
+    test_allocator3();
+    return boost::report_errors();
+}

test/unordered/assign_tests.cpp

@@ -1,39 +1,51 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
+#include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
 #include "../helpers/test.hpp"
 #include "../objects/test.hpp"
+#include "../objects/cxx11_allocator.hpp"
 #include "../helpers/random_values.hpp"
 #include "../helpers/tracker.hpp"
 #include "../helpers/equivalent.hpp"
 
 #include <iostream>
 
+#if defined(BOOST_MSVC)
+#pragma warning(disable:4127) // conditional expression is constant
+#endif
+
 namespace assign_tests {
 
 test::seed_t seed(96785);
 
 template <class T>
-void assign_tests1(T*, test::random_generator generator = test::default_generator)
+void assign_tests1(T*,
+    test::random_generator generator = test::default_generator)
 {
     BOOST_DEDUCED_TYPENAME T::hasher hf;
     BOOST_DEDUCED_TYPENAME T::key_equal eq;
 
     std::cerr<<"assign_tests1.1\n";
     {
+        test::check_instances check_;
+
         T x;
         x = x;
-        BOOST_CHECK(x.empty());
-        BOOST_CHECK(test::equivalent(x.hash_function(), hf));
-        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
+        BOOST_TEST(x.empty());
+        BOOST_TEST(test::equivalent(x.hash_function(), hf));
+        BOOST_TEST(test::equivalent(x.key_eq(), eq));
     }
 
     std::cerr<<"assign_tests1.2\n";
     {
+        test::check_instances check_;
+
         test::random_values<T> v(1000, generator);
         T x(v.begin(), v.end());
 
@@ -45,14 +57,18 @@ void assign_tests1(T*, test::random_generator generator = test::default_generato
 
         T y;
         y.max_load_factor(x.max_load_factor() / 20);
+        float mlf = x.max_load_factor();
         y = x;
+        tracker.compare(x);
         tracker.compare(y);
-        BOOST_CHECK(x.max_load_factor() == y.max_load_factor());
+        BOOST_TEST(x.max_load_factor() == mlf);
+        BOOST_TEST(y.max_load_factor() == mlf);
     }
 }
 
 template <class T>
-void assign_tests2(T*, test::random_generator generator = test::default_generator)
+void assign_tests2(T*,
+    test::random_generator generator = test::default_generator)
 {
     BOOST_DEDUCED_TYPENAME T::hasher hf1(1);
     BOOST_DEDUCED_TYPENAME T::hasher hf2(2);
@@ -60,49 +76,155 @@ void assign_tests2(T*, test::random_generator generator = test::default_generato
     BOOST_DEDUCED_TYPENAME T::key_equal eq2(2);
     BOOST_DEDUCED_TYPENAME T::allocator_type al1(1);
     BOOST_DEDUCED_TYPENAME T::allocator_type al2(2);
-
+    
+    typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
+    
     std::cerr<<"assign_tests2.1\n";
     {
+        test::check_instances check_;
+
         test::random_values<T> v(1000, generator);
         T x1(v.begin(), v.end(), 0, hf1, eq1);
         T x2(0, hf2, eq2);
         x2 = x1;
-        BOOST_CHECK(test::equivalent(x2.hash_function(), hf1));
-        BOOST_CHECK(test::equivalent(x2.key_eq(), eq1));
+        BOOST_TEST(test::equivalent(x2.hash_function(), hf1));
+        BOOST_TEST(test::equivalent(x2.key_eq(), eq1));
         test::check_container(x2, v);
     }
 
     std::cerr<<"assign_tests2.2\n";
     {
+        test::check_instances check_;
+
         test::random_values<T> v1(100, generator), v2(100, generator);
         T x1(v1.begin(), v1.end(), 0, hf1, eq1, al1);
         T x2(v2.begin(), v2.end(), 0, hf2, eq2, al2);
         x2 = x1;
-        BOOST_CHECK(test::equivalent(x2.hash_function(), hf1));
-        BOOST_CHECK(test::equivalent(x2.key_eq(), eq1));
-        BOOST_CHECK(test::equivalent(x2.get_allocator(), al2));
+        BOOST_TEST(test::equivalent(x2.hash_function(), hf1));
+        BOOST_TEST(test::equivalent(x2.key_eq(), eq1));
+        if (allocator_type::is_propagate_on_assign) {
+            BOOST_TEST(test::equivalent(x2.get_allocator(), al1));
+            BOOST_TEST(!test::equivalent(x2.get_allocator(), al2));
+        }
+        else {
+            BOOST_TEST(test::equivalent(x2.get_allocator(), al2));
+            BOOST_TEST(!test::equivalent(x2.get_allocator(), al1));
+        }
         test::check_container(x2, v1);
     }
 }
 
-boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_set;
-boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multiset;
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_map;
-boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multimap;
+boost::unordered_set<test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_set;
+boost::unordered_multiset<test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_multiset;
+boost::unordered_map<test::object, test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_map;
+boost::unordered_multimap<test::object, test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_multimap;
+
+boost::unordered_set<test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::propagate_assign> >*
+    test_set_prop_assign;
+boost::unordered_multiset<test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::propagate_assign> >*
+    test_multiset_prop_assign;
+boost::unordered_map<test::object, test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::propagate_assign> >*
+    test_map_prop_assign;
+boost::unordered_multimap<test::object, test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::propagate_assign> >*
+    test_multimap_prop_assign;
+
+boost::unordered_set<test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::no_propagate_assign> >*
+    test_set_no_prop_assign;
+boost::unordered_multiset<test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::no_propagate_assign> >*
+    test_multiset_no_prop_assign;
+boost::unordered_map<test::object, test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::no_propagate_assign> >*
+    test_map_no_prop_assign;
+boost::unordered_multimap<test::object, test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::no_propagate_assign> >*
+    test_multimap_no_prop_assign;
 
 using test::default_generator;
 using test::generate_collisions;
 
-UNORDERED_TEST(assign_tests1,
-    ((test_set)(test_multiset)(test_map)(test_multimap))
+template <typename T>
+bool is_propagate(T*)
+{
+    return T::allocator_type::is_propagate_on_assign;
+}
+
+UNORDERED_AUTO_TEST(check_traits)
+{
+    BOOST_TEST(!is_propagate(test_set));
+    BOOST_TEST(is_propagate(test_set_prop_assign));
+    BOOST_TEST(!is_propagate(test_set_no_prop_assign));
+}
+
+UNORDERED_TEST(assign_tests1, (
+        (test_set)(test_multiset)(test_map)(test_multimap)
+        (test_set_prop_assign)(test_multiset_prop_assign)(test_map_prop_assign)(test_multimap_prop_assign)
+        (test_set_no_prop_assign)(test_multiset_no_prop_assign)(test_map_no_prop_assign)(test_multimap_no_prop_assign)
+    )
     ((default_generator)(generate_collisions))
 )
 
-UNORDERED_TEST(assign_tests2,
-    ((test_set)(test_multiset)(test_map)(test_multimap))
+UNORDERED_TEST(assign_tests2, (
+        (test_set)(test_multiset)(test_map)(test_multimap)
+        (test_set_prop_assign)(test_multiset_prop_assign)(test_map_prop_assign)(test_multimap_prop_assign)
+        (test_set_no_prop_assign)(test_multiset_no_prop_assign)(test_map_no_prop_assign)(test_multimap_no_prop_assign)
+    )
     ((default_generator)(generate_collisions))
 )
 
+#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+
+UNORDERED_AUTO_TEST(assign_default_initializer_list) {
+    std::cerr<<"Initializer List Tests\n";
+    std::initializer_list<std::pair<int const, int> > init;
+    boost::unordered_map<int, int> x1;
+    x1[25] = 3;
+    x1[16] = 10;
+    BOOST_TEST(!x1.empty());
+    x1 = init;
+    BOOST_TEST(x1.empty());
+}
+
+#endif
+
+#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST) && \
+    !defined(BOOST_NO_INITIALIZER_LISTS)
+
+UNORDERED_AUTO_TEST(assign_initializer_list)
+{
+    std::cerr<<"Initializer List Tests\n";
+
+    boost::unordered_set<int> x;
+    x.insert(10);
+    x.insert(20);
+    x = { 1, 2, -10 };
+    BOOST_TEST(x.find(10) == x.end());
+    BOOST_TEST(x.find(-10) != x.end());
+}
+
+#endif
+
 }
 
 RUN_TESTS()

test/unordered/at_tests.cpp

@@ -1,8 +1,10 @@
 
-// Copyright 2007-2008 Daniel James.
+// Copyright 2007-2009 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)
 
+#include "../helpers/prefix.hpp"
+
 #include <boost/unordered_map.hpp>
 #include "../helpers/test.hpp"
 #include <string>
@@ -16,8 +18,8 @@ UNORDERED_AUTO_TEST(at_tests) {
     x["one"] = 1;
     x["two"] = 2;
 
-    BOOST_CHECK(x.at("one") == 1);
-    BOOST_CHECK(x.at("two") == 2);
+    BOOST_TEST(x.at("one") == 1);
+    BOOST_TEST(x.at("two") == 2);
 
     try {
         x.at("three");

test/unordered/bucket_tests.cpp

@@ -1,8 +1,10 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
+#include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
 #include "../helpers/test.hpp"
@@ -11,6 +13,11 @@
 #include "../helpers/random_values.hpp"
 #include "../helpers/helpers.hpp"
 
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1400)
+#pragma warning(disable:4267) // conversion from 'size_t' to 'unsigned int',
+                              // possible loss of data.
+#endif
+
 namespace bucket_tests {
 
 test::seed_t seed(54635);
@@ -18,13 +25,15 @@ test::seed_t seed(54635);
 template <class X>
 void tests(X* = 0, test::random_generator generator = test::default_generator)
 {
+    test::check_instances check_;
+
     typedef BOOST_DEDUCED_TYPENAME X::size_type size_type;
     typedef BOOST_DEDUCED_TYPENAME X::const_local_iterator const_local_iterator;
     test::random_values<X> v(1000, generator);
 
     X x(v.begin(), v.end());
 
-    BOOST_CHECK(x.bucket_count() < x.max_bucket_count());
+    BOOST_TEST(x.bucket_count() < x.max_bucket_count());
     std::cerr<<x.bucket_count()<<"<"<<x.max_bucket_count()<<"\n";
 
     for(BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator
@@ -32,28 +41,44 @@ void tests(X* = 0, test::random_generator generator = test::default_generator)
     {
         size_type bucket = x.bucket(test::get_key<X>(*it));
 
-        BOOST_CHECK(bucket < x.bucket_count());
+        BOOST_TEST(bucket < x.bucket_count());
         if(bucket < x.max_bucket_count()) {
             // lit? lend?? I need a new naming scheme.
             const_local_iterator lit = x.begin(bucket), lend = x.end(bucket);
-            while(lit != lend && test::get_key<X>(*it) != test::get_key<X>(*lit)) ++lit;
-            BOOST_CHECK(lit != lend);
+            while(lit != lend
+                && test::get_key<X>(*it) != test::get_key<X>(*lit))
+            {
+                ++lit;
+            }
+            BOOST_TEST(lit != lend);
         }
     }
 
     for(size_type i = 0; i < x.bucket_count(); ++i) {
-        BOOST_CHECK(x.bucket_size(i) == (size_type) std::distance(x.begin(i), x.end(i)));
-        BOOST_CHECK(x.bucket_size(i) == (size_type) std::distance(x.cbegin(i), x.cend(i)));
+        BOOST_TEST(x.bucket_size(i) == static_cast<size_type>(
+                std::distance(x.begin(i), x.end(i))));
+        BOOST_TEST(x.bucket_size(i) == static_cast<size_type>(
+                std::distance(x.cbegin(i), x.cend(i))));
         X const& x_ref = x;
-        BOOST_CHECK(x.bucket_size(i) == (size_type) std::distance(x_ref.begin(i), x_ref.end(i)));
-        BOOST_CHECK(x.bucket_size(i) == (size_type) std::distance(x_ref.cbegin(i), x_ref.cend(i)));
+        BOOST_TEST(x.bucket_size(i) == static_cast<size_type>(
+                std::distance(x_ref.begin(i), x_ref.end(i))));
+        BOOST_TEST(x.bucket_size(i) == static_cast<size_type>(
+                std::distance(x_ref.cbegin(i), x_ref.cend(i))));
     }
 }
 
-boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_set;
-boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multiset;
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_map;
-boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multimap;
+boost::unordered_set<test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_set;
+boost::unordered_multiset<test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_multiset;
+boost::unordered_map<test::object, test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_map;
+boost::unordered_multimap<test::object, test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_multimap;
 
 UNORDERED_TEST(tests, ((test_set)(test_multiset)(test_map)(test_multimap)))
 

test/unordered/compile_map.cpp

@@ -1,11 +1,13 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
 // This test creates the containers with members that meet their minimum
 // requirements. Makes sure everything compiles and is defined correctly.
 
+#include "../helpers/prefix.hpp"
+
 #include <boost/unordered_map.hpp>
 
 #include <iostream>
@@ -15,6 +17,19 @@
 
 // Explicit instantiation to catch compile-time errors
 
+template class boost::unordered_map<
+    int,
+    int,
+    boost::hash<int>,
+    std::equal_to<int>,
+    test::minimal::allocator<std::pair<int const, int> > >;
+template class boost::unordered_multimap<
+    int,
+    int,
+    boost::hash<int>,
+    std::equal_to<int>,
+    test::minimal::allocator<std::pair<int const, int> > >;
+
 template class boost::unordered_map<
     test::minimal::assignable,
     test::minimal::default_copy_constructible,
@@ -30,16 +45,21 @@ template class boost::unordered_multimap<
 
 UNORDERED_AUTO_TEST(test0)
 {
+    test::minimal::constructor_param x;
+
     typedef std::pair<test::minimal::assignable const,
             test::minimal::copy_constructible> value_type;
-    value_type value(
-            test::minimal::assignable::create(),
-            test::minimal::copy_constructible::create());
+    value_type value(x, x);
 
     std::cout<<"Test unordered_map.\n";
 
     boost::unordered_map<int, int> int_map;
 
+    boost::unordered_map<int, int,
+        boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<std::pair<int const, int> >
+        > int_map2;
+
     boost::unordered_map<
         test::minimal::assignable,
         test::minimal::copy_constructible,
@@ -48,12 +68,18 @@ UNORDERED_AUTO_TEST(test0)
         test::minimal::allocator<value_type> > map;
 
     container_test(int_map, std::pair<int const, int>(0, 0));
+    container_test(int_map2, std::pair<int const, int>(0, 0));
     container_test(map, value);
 
     std::cout<<"Test unordered_multimap.\n";
 
     boost::unordered_multimap<int, int> int_multimap;
 
+    boost::unordered_multimap<int, int,
+        boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<std::pair<int const, int> >
+        > int_multimap2;
+
     boost::unordered_multimap<
         test::minimal::assignable,
         test::minimal::copy_constructible,
@@ -62,35 +88,49 @@ UNORDERED_AUTO_TEST(test0)
         test::minimal::allocator<value_type> > multimap;
 
     container_test(int_multimap, std::pair<int const, int>(0, 0));
+    container_test(int_multimap2, std::pair<int const, int>(0, 0));
     container_test(multimap, value);
 }
 
 UNORDERED_AUTO_TEST(equality_tests) {
-    typedef std::pair<test::minimal::assignable const,
+    typedef std::pair<
+            test::minimal::copy_constructible_equality_comparable const,
             test::minimal::copy_constructible> value_type;
 
     boost::unordered_map<int, int> int_map;
 
+    boost::unordered_map<int, int,
+        boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<std::pair<int const, int> >
+        > int_map2;
+
     boost::unordered_map<
-        test::minimal::assignable,
         test::minimal::copy_constructible_equality_comparable,
-        test::minimal::hash<test::minimal::assignable>,
-        test::minimal::equal_to<test::minimal::assignable>,
+        test::minimal::copy_constructible_equality_comparable,
+        test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
+        test::minimal::equal_to<test::minimal::copy_constructible_equality_comparable>,
         test::minimal::allocator<value_type> > map;
 
     equality_test(int_map);
+    equality_test(int_map2);
     equality_test(map);
 
     boost::unordered_multimap<int, int> int_multimap;
 
+    boost::unordered_multimap<int, int,
+        boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<std::pair<int const, int> >
+        > int_multimap2;
+
     boost::unordered_multimap<
-        test::minimal::assignable,
         test::minimal::copy_constructible_equality_comparable,
-        test::minimal::hash<test::minimal::assignable>,
-        test::minimal::equal_to<test::minimal::assignable>,
+        test::minimal::copy_constructible_equality_comparable,
+        test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
+        test::minimal::equal_to<test::minimal::copy_constructible_equality_comparable>,
         test::minimal::allocator<value_type> > multimap;
 
     equality_test(int_multimap);
+    equality_test(int_multimap2);
     equality_test(multimap);
 }
 
@@ -104,30 +144,47 @@ UNORDERED_AUTO_TEST(test1) {
 
     boost::unordered_map<int, int> map;
 
+    boost::unordered_map<int, int,
+        boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<std::pair<int const, int> >
+        > map2;
+
     unordered_unique_test(map, map_value);
     unordered_map_test(map, value, value);
-    unordered_test(map, value, map_value, hash, equal_to);
+    unordered_copyable_test(map, value, map_value, hash, equal_to);
     unordered_map_functions(map, value, value);
 
+    unordered_unique_test(map2, map_value);
+    unordered_map_test(map2, value, value);
+    unordered_copyable_test(map2, value, map_value, hash, equal_to);
+    unordered_map_functions(map2, value, value);
+
     std::cout<<"Test unordered_multimap.\n";
 
     boost::unordered_multimap<int, int> multimap;
 
+    boost::unordered_multimap<int, int,
+        boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<std::pair<int const, int> >
+        > multimap2;
+
     unordered_equivalent_test(multimap, map_value);
     unordered_map_test(multimap, value, value);
-    unordered_test(multimap, value, map_value, hash, equal_to);
+    unordered_copyable_test(multimap, value, map_value, hash, equal_to);
+
+    unordered_equivalent_test(multimap2, map_value);
+    unordered_map_test(multimap2, value, value);
+    unordered_copyable_test(multimap2, value, map_value, hash, equal_to);
 }
 
 UNORDERED_AUTO_TEST(test2)
 {
-    test::minimal::assignable assignable
-        = test::minimal::assignable::create();
-    test::minimal::copy_constructible copy_constructible
-        = test::minimal::copy_constructible::create();
-    test::minimal::hash<test::minimal::assignable> hash
-        = test::minimal::hash<test::minimal::assignable>::create();
-    test::minimal::equal_to<test::minimal::assignable> equal_to
-        = test::minimal::equal_to<test::minimal::assignable>::create();
+    test::minimal::constructor_param x;
+
+    test::minimal::assignable assignable(x);
+    test::minimal::copy_constructible copy_constructible(x);
+    test::minimal::hash<test::minimal::assignable> hash(x);
+    test::minimal::equal_to<test::minimal::assignable> equal_to(x);
 
     typedef std::pair<test::minimal::assignable const,
             test::minimal::copy_constructible> map_value_type;
@@ -144,8 +201,7 @@ UNORDERED_AUTO_TEST(test2)
 
     unordered_unique_test(map, map_value);
     unordered_map_test(map, assignable, copy_constructible);
-    unordered_test(map, assignable, map_value, hash, equal_to);
-
+    unordered_copyable_test(map, assignable, map_value, hash, equal_to);
 
     boost::unordered_map<
         test::minimal::assignable,
@@ -169,7 +225,7 @@ UNORDERED_AUTO_TEST(test2)
 
     unordered_equivalent_test(multimap, map_value);
     unordered_map_test(multimap, assignable, copy_constructible);
-    unordered_test(multimap, assignable, map_value, hash, equal_to);
+    unordered_copyable_test(multimap, assignable, map_value, hash, equal_to);
 }
 
 RUN_TESTS()

test/unordered/compile_set.cpp

@@ -1,11 +1,13 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
 // This test creates the containers with members that meet their minimum
 // requirements. Makes sure everything compiles and is defined correctly.
 
+#include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 
 #include <iostream>
@@ -15,6 +17,17 @@
 
 // Explicit instantiation to catch compile-time errors
 
+template class boost::unordered_set<
+    int,
+    boost::hash<int>,
+    std::equal_to<int>,
+    test::minimal::allocator<int> >;
+template class boost::unordered_multiset<
+    int,
+    boost::hash<int>,
+    std::equal_to<int>,
+    test::minimal::allocator<int> >;
+
 template class boost::unordered_set<
     test::minimal::assignable,
     test::minimal::hash<test::minimal::assignable>,
@@ -28,10 +41,19 @@ template class boost::unordered_multiset<
 
 UNORDERED_AUTO_TEST(test0)
 {
-    test::minimal::assignable assignable = test::minimal::assignable::create();
+    test::minimal::constructor_param x;
+
+    test::minimal::assignable assignable(x);
 
     std::cout<<"Test unordered_set.\n";
+
     boost::unordered_set<int> int_set;
+
+    boost::unordered_set<int,
+        boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<int>
+        > int_set2;
+
     boost::unordered_set<
         test::minimal::assignable,
         test::minimal::hash<test::minimal::assignable>,
@@ -39,10 +61,18 @@ UNORDERED_AUTO_TEST(test0)
         test::minimal::allocator<test::minimal::assignable> > set;
 
     container_test(int_set, 0);
+    container_test(int_set2, 0);
     container_test(set, assignable);
 
     std::cout<<"Test unordered_multiset.\n";
+
     boost::unordered_multiset<int> int_multiset;
+
+    boost::unordered_multiset<int,
+        boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<int>
+        > int_multiset2;
+
     boost::unordered_multiset<
         test::minimal::assignable,
         test::minimal::hash<test::minimal::assignable>,
@@ -50,32 +80,45 @@ UNORDERED_AUTO_TEST(test0)
         test::minimal::allocator<test::minimal::assignable> > multiset;
 
     container_test(int_multiset, 0);
+    container_test(int_multiset2, 0);
     container_test(multiset, assignable);
 }
 
 UNORDERED_AUTO_TEST(equality_tests) {
-    typedef test::minimal::assignable value_type;
+    typedef test::minimal::copy_constructible_equality_comparable value_type;
 
     boost::unordered_set<int> int_set;
 
+    boost::unordered_set<int,
+        boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<int>
+        > int_set2;
+
     boost::unordered_set<
-        test::minimal::assignable,
-        test::minimal::hash<test::minimal::assignable>,
-        test::minimal::equal_to<test::minimal::assignable>,
+        test::minimal::copy_constructible_equality_comparable,
+        test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
+        test::minimal::equal_to<test::minimal::copy_constructible_equality_comparable>,
         test::minimal::allocator<value_type> > set;
 
     equality_test(int_set);
+    equality_test(int_set2);
     equality_test(set);
 
     boost::unordered_multiset<int> int_multiset;
 
+    boost::unordered_multiset<int,
+        boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<int>
+        > int_multiset2;
+
     boost::unordered_multiset<
-        test::minimal::assignable,
-        test::minimal::hash<test::minimal::assignable>,
-        test::minimal::equal_to<test::minimal::assignable>,
+        test::minimal::copy_constructible_equality_comparable,
+        test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
+        test::minimal::equal_to<test::minimal::copy_constructible_equality_comparable>,
         test::minimal::allocator<value_type> > multiset;
 
     equality_test(int_multiset);
+    equality_test(int_multiset2);
     equality_test(multiset);
 }
 
@@ -85,33 +128,49 @@ UNORDERED_AUTO_TEST(test1)
     std::equal_to<int> equal_to;
     int value = 0;
 
-    std::cout<<"Test unordered_set.\n";
+    std::cout<<"Test unordered_set." << std::endl;
 
     boost::unordered_set<int> set;
     
+    boost::unordered_set<int,
+        boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<int>
+        > set2;
+
     unordered_unique_test(set, value);
     unordered_set_test(set, value);
-    unordered_test(set, value, value, hash, equal_to);
+    unordered_copyable_test(set, value, value, hash, equal_to);
 
-    std::cout<<"Test unordered_multiset.\n";
+    unordered_unique_test(set2, value);
+    unordered_set_test(set2, value);
+    unordered_copyable_test(set2, value, value, hash, equal_to);
+
+    std::cout<<"Test unordered_multiset." << std::endl;
 
     boost::unordered_multiset<int> multiset;
     
+    boost::unordered_multiset<int,
+        boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<int>
+        > multiset2;
+
     unordered_equivalent_test(multiset, value);
     unordered_set_test(multiset, value);
-    unordered_test(multiset, value, value, hash, equal_to);
+    unordered_copyable_test(multiset, value, value, hash, equal_to);
+
+    unordered_equivalent_test(multiset2, value);
+    unordered_set_test(multiset2, value);
+    unordered_copyable_test(multiset2, value, value, hash, equal_to);
 }
 
 UNORDERED_AUTO_TEST(test2)
 {
-    test::minimal::assignable assignable
-        = test::minimal::assignable::create();
-    test::minimal::copy_constructible copy_constructible
-        = test::minimal::copy_constructible::create();
-    test::minimal::hash<test::minimal::assignable> hash
-        = test::minimal::hash<test::minimal::assignable>::create();
-    test::minimal::equal_to<test::minimal::assignable> equal_to
-        = test::minimal::equal_to<test::minimal::assignable>::create();
+    test::minimal::constructor_param x;
+ 
+    test::minimal::assignable assignable(x);
+    test::minimal::copy_constructible copy_constructible(x);
+    test::minimal::hash<test::minimal::assignable> hash(x);
+    test::minimal::equal_to<test::minimal::assignable> equal_to(x);
 
     std::cout<<"Test unordered_set.\n";
 
@@ -123,7 +182,7 @@ UNORDERED_AUTO_TEST(test2)
 
     unordered_unique_test(set, assignable);
     unordered_set_test(set, assignable);
-    unordered_test(set, assignable, assignable, hash, equal_to);
+    unordered_copyable_test(set, assignable, assignable, hash, equal_to);
 
     std::cout<<"Test unordered_multiset.\n";
 
@@ -135,7 +194,100 @@ UNORDERED_AUTO_TEST(test2)
 
     unordered_equivalent_test(multiset, assignable);
     unordered_set_test(multiset, assignable);
-    unordered_test(multiset, assignable, assignable, hash, equal_to);
+    unordered_copyable_test(multiset, assignable, assignable, hash, equal_to);
+}
+
+UNORDERED_AUTO_TEST(movable1_tests)
+{
+    test::minimal::constructor_param x;
+
+    test::minimal::movable1 movable1(x);
+    test::minimal::hash<test::minimal::movable1> hash(x);
+    test::minimal::equal_to<test::minimal::movable1> equal_to(x);
+
+    std::cout<<"Test unordered_set.\n";
+
+    boost::unordered_set<
+        test::minimal::movable1,
+        test::minimal::hash<test::minimal::movable1>,
+        test::minimal::equal_to<test::minimal::movable1>,
+        test::minimal::allocator<test::minimal::movable1> > set;
+
+    //unordered_unique_test(set, movable1);
+    unordered_set_test(set, movable1);
+    unordered_movable_test(set, movable1, movable1, hash, equal_to);
+
+    std::cout<<"Test unordered_multiset.\n";
+
+    boost::unordered_multiset<
+        test::minimal::movable1,
+        test::minimal::hash<test::minimal::movable1>,
+        test::minimal::equal_to<test::minimal::movable1>,
+        test::minimal::allocator<test::minimal::movable1> > multiset;
+
+    //unordered_equivalent_test(multiset, movable1);
+    unordered_set_test(multiset, movable1);
+    unordered_movable_test(multiset, movable1, movable1, hash, equal_to);
+}
+
+UNORDERED_AUTO_TEST(movable2_tests)
+{
+    test::minimal::constructor_param x;
+
+    test::minimal::movable2 movable2(x);
+    test::minimal::hash<test::minimal::movable2> hash(x);
+    test::minimal::equal_to<test::minimal::movable2> equal_to(x);
+
+    std::cout<<"Test unordered_set.\n";
+
+    boost::unordered_set<
+        test::minimal::movable2,
+        test::minimal::hash<test::minimal::movable2>,
+        test::minimal::equal_to<test::minimal::movable2>,
+        test::minimal::allocator<test::minimal::movable2> > set;
+
+    //unordered_unique_test(set, movable2);
+    unordered_set_test(set, movable2);
+    unordered_movable_test(set, movable2, movable2, hash, equal_to);
+
+    std::cout<<"Test unordered_multiset.\n";
+
+    boost::unordered_multiset<
+        test::minimal::movable2,
+        test::minimal::hash<test::minimal::movable2>,
+        test::minimal::equal_to<test::minimal::movable2>,
+        test::minimal::allocator<test::minimal::movable2> > multiset;
+
+    //unordered_equivalent_test(multiset, movable2);
+    unordered_set_test(multiset, movable2);
+    unordered_movable_test(multiset, movable2, movable2, hash, equal_to);
+}
+
+UNORDERED_AUTO_TEST(destructible_tests)
+{
+    test::minimal::constructor_param x;
+
+    test::minimal::destructible destructible(x);
+    test::minimal::hash<test::minimal::destructible> hash(x);
+    test::minimal::equal_to<test::minimal::destructible> equal_to(x);
+
+    std::cout<<"Test unordered_set.\n";
+
+    boost::unordered_set<
+        test::minimal::destructible,
+        test::minimal::hash<test::minimal::destructible>,
+        test::minimal::equal_to<test::minimal::destructible> > set;
+
+    unordered_destructible_test(set);
+
+    std::cout<<"Test unordered_multiset.\n";
+
+    boost::unordered_multiset<
+        test::minimal::destructible,
+        test::minimal::hash<test::minimal::destructible>,
+        test::minimal::equal_to<test::minimal::destructible> > multiset;
+
+    unordered_destructible_test(multiset);
 }
 
 RUN_TESTS()

test/unordered/compile_tests.hpp

@@ -1,11 +1,13 @@
 
-// Copyright 2005-2008 Daniel James.
+// Copyright 2005-2009 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)
 
 #if defined(BOOST_MSVC)
 #pragma warning(push)
 #pragma warning(disable:4100) // unreferenced formal parameter
+#pragma warning(disable:4610) // class can never be instantiated
+#pragma warning(disable:4510) // default constructor could not be generated
 #endif
 
 #include <boost/concept_check.hpp>
@@ -20,12 +22,14 @@
 #include <boost/type_traits/is_convertible.hpp>
 #include <boost/iterator/iterator_traits.hpp>
 #include <boost/limits.hpp>
+#include <boost/utility/swap.hpp>
 #include "../helpers/check_return_type.hpp"
 
 typedef long double comparison_type;
 
 template <class T> void sink(T const&) {}
 template <class T> T rvalue(T const& v) { return v; }
+template <class T> T rvalue_default() { return T(); }
 
 template <class X, class T>
 void container_test(X& r, T const&)
@@ -35,10 +39,15 @@ void container_test(X& r, T const&)
     typedef BOOST_DEDUCED_TYPENAME X::difference_type difference_type;
     typedef BOOST_DEDUCED_TYPENAME X::size_type size_type;
 
-    typedef BOOST_DEDUCED_TYPENAME boost::iterator_value<iterator>::type iterator_value_type;
-    typedef BOOST_DEDUCED_TYPENAME boost::iterator_value<const_iterator>::type const_iterator_value_type;
-    typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<iterator>::type iterator_difference_type;
-    typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<const_iterator>::type const_iterator_difference_type;
+    typedef BOOST_DEDUCED_TYPENAME
+        boost::iterator_value<iterator>::type iterator_value_type;
+    typedef BOOST_DEDUCED_TYPENAME
+        boost::iterator_value<const_iterator>::type const_iterator_value_type;
+    typedef BOOST_DEDUCED_TYPENAME
+        boost::iterator_difference<iterator>::type iterator_difference_type;
+    typedef BOOST_DEDUCED_TYPENAME
+        boost::iterator_difference<const_iterator>::type
+            const_iterator_difference_type;
 
     typedef BOOST_DEDUCED_TYPENAME X::value_type value_type;
     typedef BOOST_DEDUCED_TYPENAME X::reference reference;
@@ -87,10 +96,10 @@ void container_test(X& r, T const&)
     // I'm not sure about either of these tests...
     size_type max_diff((std::numeric_limits<difference_type>::max)());
     difference_type converted_diff(max_diff);
-    BOOST_CHECK((std::numeric_limits<difference_type>::max)()
+    BOOST_TEST((std::numeric_limits<difference_type>::max)()
             == converted_diff);
 
-    BOOST_CHECK(
+    BOOST_TEST(
         static_cast<comparison_type>(
             (std::numeric_limits<size_type>::max)()) >
         static_cast<comparison_type>(
@@ -98,19 +107,54 @@ void container_test(X& r, T const&)
 
     // I don't test the runtime post-conditions here.
     X u;
-    BOOST_CHECK(u.size() == 0);
-    BOOST_CHECK(X().size() == 0);
+    BOOST_TEST(u.size() == 0);
+    BOOST_TEST(X().size() == 0);
 
     X a,b;
+    X a_const;
 
     sink(X(a));
     X u2(a);
     X u3 = a;
 
+    a.swap(b);
+    boost::swap(a, b);
+    test::check_return_type<X>::equals_ref(r = a);
+
+    // Allocator
+
+    typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
+    test::check_return_type<allocator_type>::equals(a_const.get_allocator());
+    
+    // Avoid unused variable warnings:
+
+    sink(u);
+    sink(u2);
+    sink(u3);
+}
+
+template <class X>
+void unordered_destructible_test(X&)
+{
+    typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
+    typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
+    typedef BOOST_DEDUCED_TYPENAME X::size_type size_type;
+
+    X x1;
+
+#if !defined(BOOST_NO_RVALUE_REFERENCES)
+    X x2(rvalue_default<X>());
+    X x3 = rvalue_default<X>();
+    // This can only be done if propagate_on_container_move_assignment::value
+    // is true.
+    // x2 = rvalue_default<X>();
+#endif
+
     X* ptr = new X();
     X& a1 = *ptr;
     (&a1)->~X();
 
+    X a,b;
     X const a_const;
     test::check_return_type<iterator>::equals(a.begin());
     test::check_return_type<const_iterator>::equals(a_const.begin());
@@ -122,7 +166,8 @@ void container_test(X& r, T const&)
     test::check_return_type<const_iterator>::equals(a_const.cend());
 
     a.swap(b);
-    test::check_return_type<X>::equals_ref(r = a);
+    boost::swap(a, b);
+ 
     test::check_return_type<size_type>::equals(a.size());
     test::check_return_type<size_type>::equals(a.max_size());
     test::check_return_type<bool>::convertible(a.empty());
@@ -147,18 +192,18 @@ void unordered_map_test(X& r, Key const& k, T const& v)
 {
     typedef BOOST_DEDUCED_TYPENAME X::value_type value_type;
     typedef BOOST_DEDUCED_TYPENAME X::key_type key_type;
-    BOOST_MPL_ASSERT((boost::is_same<value_type, std::pair<key_type const, T> >));
+
+    BOOST_MPL_ASSERT((
+        boost::is_same<value_type, std::pair<key_type const, T> >));
 
     r.insert(std::pair<Key const, T>(k, v));
 
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
     Key k_lvalue(k);
     T v_lvalue(v);
 
     r.emplace(k, v);
     r.emplace(k_lvalue, v_lvalue);
     r.emplace(rvalue(k), rvalue(v));
-#endif
 }
 
 template <class X>
@@ -168,6 +213,8 @@ void equality_test(X& r)
 
     test::check_return_type<bool>::equals(a == b);
     test::check_return_type<bool>::equals(a != b);
+    test::check_return_type<bool>::equals(boost::operator==(a, b));
+    test::check_return_type<bool>::equals(boost::operator!=(a, b));
 }
 
 template <class X, class T>
@@ -175,9 +222,7 @@ void unordered_unique_test(X& r, T const& t)
 {
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
     test::check_return_type<std::pair<iterator, bool> >::equals(r.insert(t));
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
     test::check_return_type<std::pair<iterator, bool> >::equals(r.emplace(t));
-#endif
 }
 
 template <class X, class T>
@@ -185,9 +230,7 @@ void unordered_equivalent_test(X& r, T const& t)
 {
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
     test::check_return_type<iterator>::equals(r.insert(t));
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
     test::check_return_type<iterator>::equals(r.emplace(t));
-#endif
 }
 
 template <class X, class Key, class T>
@@ -203,9 +246,11 @@ void unordered_map_functions(X&, Key const& k, T const&)
     test::check_return_type<mapped_type const>::equals_ref(b.at(k));
 }
 
-template <class X, class Key, class T, class Hash, class Pred>
-void unordered_test(X&, Key& k, T& t, Hash& hf, Pred& eq)
+template <class X, class Key, class Hash, class Pred>
+void unordered_test(X& x, Key& k, Hash& hf, Pred& eq)
 {
+    unordered_destructible_test(x);
+
     typedef BOOST_DEDUCED_TYPENAME X::key_type key_type;
     typedef BOOST_DEDUCED_TYPENAME X::hasher hasher;
     typedef BOOST_DEDUCED_TYPENAME X::key_equal key_equal;
@@ -216,29 +261,61 @@ void unordered_test(X&, Key& k, T& t, Hash& hf, Pred& eq)
     typedef BOOST_DEDUCED_TYPENAME X::local_iterator local_iterator;
     typedef BOOST_DEDUCED_TYPENAME X::const_local_iterator const_local_iterator;
 
-    typedef BOOST_DEDUCED_TYPENAME boost::BOOST_ITERATOR_CATEGORY<iterator>::type iterator_category;
-    typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<iterator>::type iterator_difference;
-    typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<iterator>::type iterator_pointer;
-    typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference<iterator>::type iterator_reference;
+    typedef BOOST_DEDUCED_TYPENAME
+        boost::BOOST_ITERATOR_CATEGORY<iterator>::type
+        iterator_category;
+    typedef BOOST_DEDUCED_TYPENAME
+        boost::iterator_difference<iterator>::type
+        iterator_difference;
+    typedef BOOST_DEDUCED_TYPENAME
+        boost::iterator_pointer<iterator>::type
+        iterator_pointer;
+    typedef BOOST_DEDUCED_TYPENAME
+        boost::iterator_reference<iterator>::type
+        iterator_reference;
 
-    typedef BOOST_DEDUCED_TYPENAME boost::BOOST_ITERATOR_CATEGORY<local_iterator>::type local_iterator_category;
-    typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<local_iterator>::type local_iterator_difference;
-    typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<local_iterator>::type local_iterator_pointer;
-    typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference<local_iterator>::type local_iterator_reference;
+    typedef BOOST_DEDUCED_TYPENAME
+        boost::BOOST_ITERATOR_CATEGORY<local_iterator>::type
+        local_iterator_category;
+    typedef BOOST_DEDUCED_TYPENAME
+        boost::iterator_difference<local_iterator>::type
+        local_iterator_difference;
+    typedef BOOST_DEDUCED_TYPENAME
+        boost::iterator_pointer<local_iterator>::type
+        local_iterator_pointer;
+    typedef BOOST_DEDUCED_TYPENAME
+        boost::iterator_reference<local_iterator>::type
+        local_iterator_reference;
 
-    typedef BOOST_DEDUCED_TYPENAME boost::BOOST_ITERATOR_CATEGORY<const_iterator>::type const_iterator_category;
-    typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<const_iterator>::type const_iterator_difference;
-    typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<const_iterator>::type const_iterator_pointer;
-    typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference<const_iterator>::type const_iterator_reference;
+    typedef BOOST_DEDUCED_TYPENAME
+        boost::BOOST_ITERATOR_CATEGORY<const_iterator>::type
+        const_iterator_category;
+    typedef BOOST_DEDUCED_TYPENAME
+        boost::iterator_difference<const_iterator>::type
+        const_iterator_difference;
+    typedef BOOST_DEDUCED_TYPENAME
+        boost::iterator_pointer<const_iterator>::type
+        const_iterator_pointer;
+    typedef BOOST_DEDUCED_TYPENAME
+        boost::iterator_reference<const_iterator>::type
+        const_iterator_reference;
 
-    typedef BOOST_DEDUCED_TYPENAME boost::BOOST_ITERATOR_CATEGORY<const_local_iterator>::type const_local_iterator_category;
-    typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<const_local_iterator>::type const_local_iterator_difference;
-    typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<const_local_iterator>::type const_local_iterator_pointer;
-    typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference<const_local_iterator>::type const_local_iterator_reference;
+    typedef BOOST_DEDUCED_TYPENAME
+        boost::BOOST_ITERATOR_CATEGORY<const_local_iterator>::type
+        const_local_iterator_category;
+    typedef BOOST_DEDUCED_TYPENAME
+        boost::iterator_difference<const_local_iterator>::type
+        const_local_iterator_difference;
+    typedef BOOST_DEDUCED_TYPENAME
+        boost::iterator_pointer<const_local_iterator>::type
+        const_local_iterator_pointer;
+    typedef BOOST_DEDUCED_TYPENAME
+        boost::iterator_reference<const_local_iterator>::type
+        const_local_iterator_reference;
 
     BOOST_MPL_ASSERT((boost::is_same<Key, key_type>));
-    boost::function_requires<boost::CopyConstructibleConcept<key_type> >();
-    boost::function_requires<boost::AssignableConcept<key_type> >();
+    //boost::function_requires<boost::CopyConstructibleConcept<key_type> >();
+    //boost::function_requires<boost::AssignableConcept<key_type> >();
 
     BOOST_MPL_ASSERT((boost::is_same<Hash, hasher>));
     test::check_return_type<std::size_t>::equals(hf(k));
@@ -247,16 +324,25 @@ void unordered_test(X&, Key& k, T& t, Hash& hf, Pred& eq)
     test::check_return_type<bool>::convertible(eq(k, k));
 
     boost::function_requires<boost::InputIteratorConcept<local_iterator> >();
-    BOOST_MPL_ASSERT((boost::is_same<local_iterator_category, iterator_category>));
-    BOOST_MPL_ASSERT((boost::is_same<local_iterator_difference, iterator_difference>));
-    BOOST_MPL_ASSERT((boost::is_same<local_iterator_pointer, iterator_pointer>));
-    BOOST_MPL_ASSERT((boost::is_same<local_iterator_reference, iterator_reference>));
+    BOOST_MPL_ASSERT((boost::is_same<local_iterator_category,
+        iterator_category>));
+    BOOST_MPL_ASSERT((boost::is_same<local_iterator_difference,
+        iterator_difference>));
+    BOOST_MPL_ASSERT((boost::is_same<local_iterator_pointer,
+        iterator_pointer>));
+    BOOST_MPL_ASSERT((boost::is_same<local_iterator_reference,
+        iterator_reference>));
 
-    boost::function_requires<boost::InputIteratorConcept<const_local_iterator> >();
-    BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_category, const_iterator_category>));
-    BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_difference, const_iterator_difference>));
-    BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_pointer, const_iterator_pointer>));
-    BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_reference, const_iterator_reference>));
+    boost::function_requires<
+        boost::InputIteratorConcept<const_local_iterator> >();
+    BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_category,
+        const_iterator_category>));
+    BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_difference,
+        const_iterator_difference>));
+    BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_pointer,
+        const_iterator_pointer>));
+    BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_reference,
+        const_iterator_reference>));
 
     X(10, hf, eq);
     X a(10, hf, eq);
@@ -267,47 +353,18 @@ void unordered_test(X&, Key& k, T& t, Hash& hf, Pred& eq)
     X();
     X a4;
 
-    BOOST_DEDUCED_TYPENAME X::value_type* i = 0;
-    BOOST_DEDUCED_TYPENAME X::value_type* j = 0;
-
-    X(i, j, 10, hf, eq);
-    X a5(i, j, 10, hf, eq);
-    X(i, j, 10, hf);
-    X a6(i, j, 10, hf);
-    X(i, j, 10);
-    X a7(i, j, 10);
-    X(i, j);
-    X a8(i, j);
-
-    X const b;
-    sink(X(b));
-    X a9(b);
-    a = b;
-
-    test::check_return_type<hasher>::equals(b.hash_function());
-    test::check_return_type<key_equal>::equals(b.key_eq());
-
-    const_iterator q = a.cbegin();
-    test::check_return_type<iterator>::equals(a.insert(q, t));
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
-    test::check_return_type<iterator>::equals(a.emplace(q, t));
-#endif
-
-    a.insert(i, j);
     test::check_return_type<size_type>::equals(a.erase(k));
 
-    BOOST_CHECK(a.empty());
-    if(a.empty()) {
-        a.insert(t);
-        q = a.cbegin();
-        test::check_return_type<iterator>::equals(a.erase(q));
-    }
-
     const_iterator q1 = a.cbegin(), q2 = a.cend();
     test::check_return_type<iterator>::equals(a.erase(q1, q2));
 
     a.clear();
 
+    X const b;
+
+    test::check_return_type<hasher>::equals(b.hash_function());
+    test::check_return_type<key_equal>::equals(b.key_eq());
+
     test::check_return_type<iterator>::equals(a.find(k));
     test::check_return_type<const_iterator>::equals(b.find(k));
     test::check_return_type<size_type>::equals(b.count(k));
@@ -334,4 +391,125 @@ void unordered_test(X&, Key& k, T& t, Hash& hf, Pred& eq)
     test::check_return_type<float>::equals(b.max_load_factor());
     a.max_load_factor((float) 2.0);
     a.rehash(100);
+    
+    // Avoid unused variable warnings:
+
+    sink(a);
+    sink(a2);
+    sink(a3);
+    sink(a4);
+}
+
+template <class X, class Key, class T, class Hash, class Pred>
+void unordered_copyable_test(X& x, Key& k, T& t, Hash& hf, Pred& eq)
+{
+    unordered_test(x, k, hf, eq);
+
+    typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
+    typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
+
+    X a;
+
+    BOOST_DEDUCED_TYPENAME X::value_type* i = 0;
+    BOOST_DEDUCED_TYPENAME X::value_type* j = 0;
+
+    X(i, j, 10, hf, eq);
+
+    X a5(i, j, 10, hf, eq);
+    X(i, j, 10, hf);
+    X a6(i, j, 10, hf);
+    X(i, j, 10);
+    X a7(i, j, 10);
+    X(i, j);
+    X a8(i, j);
+
+    X const b;
+    sink(X(b));
+    X a9(b);
+    a = b;
+
+    const_iterator q = a.cbegin();
+
+    test::check_return_type<iterator>::equals(a.insert(q, t));
+    test::check_return_type<iterator>::equals(a.emplace_hint(q, t));
+
+    a.insert(i, j);
+
+    X a10;
+    a10.insert(t);
+    q = a10.cbegin();
+    test::check_return_type<iterator>::equals(a10.erase(q));
+
+    // Avoid unused variable warnings:
+
+    sink(a);
+    sink(a5);
+    sink(a6);
+    sink(a7);
+    sink(a8);
+    sink(a9);
+}
+
+template <class X, class Key, class T, class Hash, class Pred>
+void unordered_movable_test(X& x, Key& k, T& /* t */, Hash& hf, Pred& eq)
+{
+    unordered_test(x, k, hf, eq);
+
+    typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
+    typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
+
+#if !defined(BOOST_NO_RVALUE_REFERENCES)
+    X x1(rvalue_default<X>());
+    X x2(boost::move(x1));
+    x1 = rvalue_default<X>();
+    x2 = boost::move(x1);
+#endif
+
+    test::minimal::constructor_param* i = 0; 
+    test::minimal::constructor_param* j = 0;
+
+    X(i, j, 10, hf, eq);
+    X a5(i, j, 10, hf, eq);
+    X(i, j, 10, hf);
+    X a6(i, j, 10, hf);
+    X(i, j, 10);
+    X a7(i, j, 10);
+    X(i, j);
+    X a8(i, j);
+
+    X a;
+
+    const_iterator q = a.cbegin();
+
+    test::minimal::constructor_param v;
+    a.emplace(v);
+    test::check_return_type<iterator>::equals(a.emplace_hint(q, v));
+
+    T v1(v);
+    a.emplace(boost::move(v1));
+    T v2(v);
+    a.insert(boost::move(v2));
+    T v3(v);
+    test::check_return_type<iterator>::equals(
+            a.emplace_hint(q, boost::move(v3)));
+    T v4(v);
+    test::check_return_type<iterator>::equals(
+            a.insert(q, boost::move(v4)));
+
+    a.insert(i, j);
+
+    X a10;
+    T v5(v);
+    a10.insert(boost::move(v5));
+    q = a10.cbegin();
+    test::check_return_type<iterator>::equals(a10.erase(q));
+
+    // Avoid unused variable warnings:
+
+    sink(a);
+    sink(a5);
+    sink(a6);
+    sink(a7);
+    sink(a8);
+    sink(a10);
 }

test/unordered/constructor_tests.cpp

@@ -1,8 +1,10 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2010 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)
 
+#include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
 #include "../helpers/test.hpp"
@@ -13,14 +15,13 @@
 #include "../helpers/input_iterator.hpp"
 #include "../helpers/invariants.hpp"
 
-#include <iostream>
-
 namespace constructor_tests {
 
 test::seed_t seed(356730);
 
 template <class T>
-void constructor_tests1(T*, test::random_generator generator = test::default_generator)
+void constructor_tests1(T*,
+    test::random_generator generator = test::default_generator)
 {
     BOOST_DEDUCED_TYPENAME T::hasher hf;
     BOOST_DEDUCED_TYPENAME T::key_equal eq;
@@ -28,129 +29,151 @@ void constructor_tests1(T*, test::random_generator generator = test::default_gen
 
     std::cerr<<"Construct 1\n";
     {
+        test::check_instances check_;
+
         T x(0, hf, eq);
-        BOOST_CHECK(x.empty());
-        BOOST_CHECK(test::equivalent(x.hash_function(), hf));
-        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
-        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
+        BOOST_TEST(x.empty());
+        BOOST_TEST(test::equivalent(x.hash_function(), hf));
+        BOOST_TEST(test::equivalent(x.key_eq(), eq));
+        BOOST_TEST(test::equivalent(x.get_allocator(), al));
         test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 2\n";
     {
+        test::check_instances check_;
+
         T x(100, hf);
-        BOOST_CHECK(x.empty());
-        BOOST_CHECK(x.bucket_count() >= 100);
-        BOOST_CHECK(test::equivalent(x.hash_function(), hf));
-        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
-        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
+        BOOST_TEST(x.empty());
+        BOOST_TEST(x.bucket_count() >= 100);
+        BOOST_TEST(test::equivalent(x.hash_function(), hf));
+        BOOST_TEST(test::equivalent(x.key_eq(), eq));
+        BOOST_TEST(test::equivalent(x.get_allocator(), al));
         test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 3\n";
     {
+        test::check_instances check_;
+
         T x(2000);
-        BOOST_CHECK(x.empty());
-        BOOST_CHECK(x.bucket_count() >= 2000);
-        BOOST_CHECK(test::equivalent(x.hash_function(), hf));
-        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
-        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
+        BOOST_TEST(x.empty());
+        BOOST_TEST(x.bucket_count() >= 2000);
+        BOOST_TEST(test::equivalent(x.hash_function(), hf));
+        BOOST_TEST(test::equivalent(x.key_eq(), eq));
+        BOOST_TEST(test::equivalent(x.get_allocator(), al));
         test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 4\n";
     {
+        test::check_instances check_;
+
         T x;
-        BOOST_CHECK(x.empty());
-        BOOST_CHECK(test::equivalent(x.hash_function(), hf));
-        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
-        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
+        BOOST_TEST(x.empty());
+        BOOST_TEST(test::equivalent(x.hash_function(), hf));
+        BOOST_TEST(test::equivalent(x.key_eq(), eq));
+        BOOST_TEST(test::equivalent(x.get_allocator(), al));
         test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 5\n";
     {
+        test::check_instances check_;
+
         test::random_values<T> v(1000, generator);
         T x(v.begin(), v.end(), 10000, hf, eq);
-        BOOST_CHECK(x.bucket_count() >= 10000);
-        BOOST_CHECK(test::equivalent(x.hash_function(), hf));
-        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
-        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
+        BOOST_TEST(x.bucket_count() >= 10000);
+        BOOST_TEST(test::equivalent(x.hash_function(), hf));
+        BOOST_TEST(test::equivalent(x.key_eq(), eq));
+        BOOST_TEST(test::equivalent(x.get_allocator(), al));
         test::check_container(x, v);
         test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 6\n";
     {
+        test::check_instances check_;
+
         test::random_values<T> v(10, generator);
         T x(v.begin(), v.end(), 10000, hf);
-        BOOST_CHECK(x.bucket_count() >= 10000);
-        BOOST_CHECK(test::equivalent(x.hash_function(), hf));
-        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
-        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
+        BOOST_TEST(x.bucket_count() >= 10000);
+        BOOST_TEST(test::equivalent(x.hash_function(), hf));
+        BOOST_TEST(test::equivalent(x.key_eq(), eq));
+        BOOST_TEST(test::equivalent(x.get_allocator(), al));
         test::check_container(x, v);
         test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 7\n";
     {
+        test::check_instances check_;
+
         test::random_values<T> v(100, generator);
         T x(v.begin(), v.end(), 100);
-        BOOST_CHECK(x.bucket_count() >= 100);
-        BOOST_CHECK(test::equivalent(x.hash_function(), hf));
-        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
-        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
+        BOOST_TEST(x.bucket_count() >= 100);
+        BOOST_TEST(test::equivalent(x.hash_function(), hf));
+        BOOST_TEST(test::equivalent(x.key_eq(), eq));
+        BOOST_TEST(test::equivalent(x.get_allocator(), al));
         test::check_container(x, v);
         test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 8\n";
     {
+        test::check_instances check_;
+
         test::random_values<T> v(1, generator);
         T x(v.begin(), v.end());
-        BOOST_CHECK(test::equivalent(x.hash_function(), hf));
-        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
-        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
+        BOOST_TEST(test::equivalent(x.hash_function(), hf));
+        BOOST_TEST(test::equivalent(x.key_eq(), eq));
+        BOOST_TEST(test::equivalent(x.get_allocator(), al));
         test::check_container(x, v);
         test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 9\n";
     {
+        test::check_instances check_;
+
         T x(0, hf, eq, al);
-        BOOST_CHECK(x.empty());
-        BOOST_CHECK(test::equivalent(x.hash_function(), hf));
-        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
-        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
+        BOOST_TEST(x.empty());
+        BOOST_TEST(test::equivalent(x.hash_function(), hf));
+        BOOST_TEST(test::equivalent(x.key_eq(), eq));
+        BOOST_TEST(test::equivalent(x.get_allocator(), al));
         test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 10\n";
     {
+        test::check_instances check_;
+
         test::random_values<T> v(1000, generator);
         T x(v.begin(), v.end(), 10000, hf, eq, al);
-        BOOST_CHECK(x.bucket_count() >= 10000);
-        BOOST_CHECK(test::equivalent(x.hash_function(), hf));
-        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
-        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
+        BOOST_TEST(x.bucket_count() >= 10000);
+        BOOST_TEST(test::equivalent(x.hash_function(), hf));
+        BOOST_TEST(test::equivalent(x.key_eq(), eq));
+        BOOST_TEST(test::equivalent(x.get_allocator(), al));
         test::check_container(x, v);
         test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 11\n";
     {
-        test::random_values<T> v(1000, generator);
+        test::check_instances check_;
+
         T x(al);
-        BOOST_CHECK(x.empty());
-        BOOST_CHECK(test::equivalent(x.hash_function(), hf));
-        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
-        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
+        BOOST_TEST(x.empty());
+        BOOST_TEST(test::equivalent(x.hash_function(), hf));
+        BOOST_TEST(test::equivalent(x.key_eq(), eq));
+        BOOST_TEST(test::equivalent(x.get_allocator(), al));
         test::check_equivalent_keys(x);
     }
 }
 
 template <class T>
-void constructor_tests2(T*, test::random_generator const& generator = test::default_generator)
+void constructor_tests2(T*,
+    test::random_generator const& generator = test::default_generator)
 {
     BOOST_DEDUCED_TYPENAME T::hasher hf;
     BOOST_DEDUCED_TYPENAME T::hasher hf1(1);
@@ -164,44 +187,48 @@ void constructor_tests2(T*, test::random_generator const& generator = test::defa
 
     std::cerr<<"Construct 1\n";
     {
+        test::check_instances check_;
         T x(10000, hf1, eq1);
-        BOOST_CHECK(x.bucket_count() >= 10000);
-        BOOST_CHECK(test::equivalent(x.hash_function(), hf1));
-        BOOST_CHECK(test::equivalent(x.key_eq(), eq1));
-        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
+        BOOST_TEST(x.bucket_count() >= 10000);
+        BOOST_TEST(test::equivalent(x.hash_function(), hf1));
+        BOOST_TEST(test::equivalent(x.key_eq(), eq1));
+        BOOST_TEST(test::equivalent(x.get_allocator(), al));
         test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 2\n";
     {
+        test::check_instances check_;
         T x(100, hf1);
-        BOOST_CHECK(x.empty());
-        BOOST_CHECK(x.bucket_count() >= 100);
-        BOOST_CHECK(test::equivalent(x.hash_function(), hf1));
-        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
-        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
+        BOOST_TEST(x.empty());
+        BOOST_TEST(x.bucket_count() >= 100);
+        BOOST_TEST(test::equivalent(x.hash_function(), hf1));
+        BOOST_TEST(test::equivalent(x.key_eq(), eq));
+        BOOST_TEST(test::equivalent(x.get_allocator(), al));
         test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 3\n";
     {
+        test::check_instances check_;
         test::random_values<T> v(100, generator);
         T x(v.begin(), v.end(), 0, hf1, eq1);
-        BOOST_CHECK(test::equivalent(x.hash_function(), hf1));
-        BOOST_CHECK(test::equivalent(x.key_eq(), eq1));
-        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
+        BOOST_TEST(test::equivalent(x.hash_function(), hf1));
+        BOOST_TEST(test::equivalent(x.key_eq(), eq1));
+        BOOST_TEST(test::equivalent(x.get_allocator(), al));
         test::check_container(x, v);
         test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 4\n";
     {
+        test::check_instances check_;
         test::random_values<T> v(5, generator);
         T x(v.begin(), v.end(), 1000, hf1);
-        BOOST_CHECK(x.bucket_count() >= 1000);
-        BOOST_CHECK(test::equivalent(x.hash_function(), hf1));
-        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
-        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
+        BOOST_TEST(x.bucket_count() >= 1000);
+        BOOST_TEST(test::equivalent(x.hash_function(), hf1));
+        BOOST_TEST(test::equivalent(x.key_eq(), eq));
+        BOOST_TEST(test::equivalent(x.get_allocator(), al));
         test::check_container(x, v);
         test::check_equivalent_keys(x);
     }
@@ -209,6 +236,7 @@ void constructor_tests2(T*, test::random_generator const& generator = test::defa
 
     std::cerr<<"Construct 5\n";
     {
+        test::check_instances check_;
         test::random_values<T> v(100, generator);
         T x(v.begin(), v.end(), 0, hf, eq, al1);
         T y(x.begin(), x.end(), 0, hf1, eq1, al2);
@@ -220,6 +248,7 @@ void constructor_tests2(T*, test::random_generator const& generator = test::defa
 
     std::cerr<<"Construct 6\n";
     {
+        test::check_instances check_;
         test::random_values<T> v(100, generator);
         T x(v.begin(), v.end(), 0, hf1, eq1);
         T y(x.begin(), x.end(), 0, hf, eq);
@@ -231,6 +260,7 @@ void constructor_tests2(T*, test::random_generator const& generator = test::defa
 
     std::cerr<<"Construct 7\n";
     {
+        test::check_instances check_;
         test::random_values<T> v(100, generator);
         T x(v.begin(), v.end(), 0, hf1, eq1);
         T y(x.begin(), x.end(), 0, hf2, eq2);
@@ -242,22 +272,127 @@ void constructor_tests2(T*, test::random_generator const& generator = test::defa
 
     std::cerr<<"Construct 8 - from input iterator\n";
     {
+        test::check_instances check_;
         test::random_values<T> v(100, generator);
-        T x(test::input_iterator(v.begin()), test::input_iterator(v.end()), 0, hf1, eq1);
-        T y(test::input_iterator(x.begin()), test::input_iterator(x.end()), 0, hf2, eq2);
+        BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
+            v_begin = v.begin(), v_end = v.end();
+        T x(test::input_iterator(v_begin),
+            test::input_iterator(v_end), 0, hf1, eq1);
+        BOOST_DEDUCED_TYPENAME T::const_iterator
+            x_begin = x.begin(), x_end = x.end();
+        T y(test::input_iterator(x_begin),
+            test::input_iterator(x_end), 0, hf2, eq2);
         test::check_container(x, v);
         test::check_container(y, x);
         test::check_equivalent_keys(x);
         test::check_equivalent_keys(y);
     }
+    
+    std::cerr<<"Construct 8.5 - from copy iterator\n";
+    {
+        test::check_instances check_;
+        test::random_values<T> v(100, generator);
+        T x(test::copy_iterator(v.begin()),
+            test::copy_iterator(v.end()), 0, hf1, eq1);
+        T y(test::copy_iterator(x.begin()),
+            test::copy_iterator(x.end()), 0, hf2, eq2);
+        test::check_container(x, v);
+        test::check_container(y, x);
+        test::check_equivalent_keys(x);
+        test::check_equivalent_keys(y);
+    }
+    
+    std::cerr<<"Construct 9\n";
+    {
+        test::check_instances check_;
+
+        test::random_values<T> v(100, generator);
+        T x(50);
+        BOOST_TEST(x.bucket_count() >= 50);
+        x.max_load_factor(10);
+        BOOST_TEST(x.bucket_count() >= 50);
+        x.insert(v.begin(), v.end());
+        BOOST_TEST(x.bucket_count() >= 50);
+        test::check_container(x, v);
+        test::check_equivalent_keys(x);
+    }
+
+#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+    std::initializer_list<BOOST_DEDUCED_TYPENAME T::value_type> list;
+    
+    std::cerr<<"Initializer list construct 1\n";
+    {
+        test::check_instances check_;
+
+        T x(list);
+        BOOST_TEST(x.empty());
+        BOOST_TEST(test::equivalent(x.hash_function(), hf));
+        BOOST_TEST(test::equivalent(x.key_eq(), eq));
+        BOOST_TEST(test::equivalent(x.get_allocator(), al));
+    }
+
+    std::cerr<<"Initializer list construct 2\n";
+    {
+        test::check_instances check_;
+
+        T x(list, 1000);
+        BOOST_TEST(x.empty());
+        BOOST_TEST(x.bucket_count() >= 1000);
+        BOOST_TEST(test::equivalent(x.hash_function(), hf));
+        BOOST_TEST(test::equivalent(x.key_eq(), eq));
+        BOOST_TEST(test::equivalent(x.get_allocator(), al));
+    }
+
+    std::cerr<<"Initializer list construct 3\n";
+    {
+        test::check_instances check_;
+
+        T x(list, 10, hf1);
+        BOOST_TEST(x.empty());
+        BOOST_TEST(x.bucket_count() >= 10);
+        BOOST_TEST(test::equivalent(x.hash_function(), hf1));
+        BOOST_TEST(test::equivalent(x.key_eq(), eq));
+        BOOST_TEST(test::equivalent(x.get_allocator(), al));
+    }
+
+    std::cerr<<"Initializer list construct 4\n";
+    {
+        test::check_instances check_;
+
+        T x(list, 10, hf1, eq1);
+        BOOST_TEST(x.empty());
+        BOOST_TEST(x.bucket_count() >= 10);
+        BOOST_TEST(test::equivalent(x.hash_function(), hf1));
+        BOOST_TEST(test::equivalent(x.key_eq(), eq1));
+        BOOST_TEST(test::equivalent(x.get_allocator(), al));
+    }
+
+    std::cerr<<"Initializer list construct 5\n";
+    {
+        test::check_instances check_;
+
+        T x(list, 10, hf1, eq1, al1);
+        BOOST_TEST(x.empty());
+        BOOST_TEST(x.bucket_count() >= 10);
+        BOOST_TEST(test::equivalent(x.hash_function(), hf1));
+        BOOST_TEST(test::equivalent(x.key_eq(), eq1));
+        BOOST_TEST(test::equivalent(x.get_allocator(), al1));
+    }
+#endif
 }
 
 template <class T>
-void map_constructor_test(T* = 0, test::random_generator const& generator = test::default_generator)
+void map_constructor_test(T* = 0,
+    test::random_generator const& generator = test::default_generator)
 {
     std::cerr<<"map_constructor_test\n";
 
-    typedef test::list<std::pair<BOOST_DEDUCED_TYPENAME T::key_type, BOOST_DEDUCED_TYPENAME T::mapped_type> > list;
+    typedef test::list<
+        std::pair<
+            BOOST_DEDUCED_TYPENAME T::key_type,
+            BOOST_DEDUCED_TYPENAME T::mapped_type
+        >
+    > list;
     test::random_values<T> v(1000, generator);
     list l(v.begin(), v.end());
     T x(l.begin(), l.end());
@@ -266,10 +401,18 @@ void map_constructor_test(T* = 0, test::random_generator const& generator = test
     test::check_equivalent_keys(x);
 }
 
-boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_set;
-boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multiset;
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_map;
-boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multimap;
+boost::unordered_set<test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_set;
+boost::unordered_multiset<test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_multiset;
+boost::unordered_map<test::object, test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_map;
+boost::unordered_multimap<test::object, test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_multimap;
 
 using test::default_generator;
 using test::generate_collisions;
@@ -288,6 +431,29 @@ UNORDERED_TEST(map_constructor_test,
     ((test_map)(test_multimap))
 )
 
+#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+
+UNORDERED_AUTO_TEST(test_default_initializer_list) {
+    std::cerr<<"Initializer List Tests\n";
+    std::initializer_list<int> init;
+    boost::unordered_set<int> x1 = init;
+    BOOST_TEST(x1.empty());
+}
+
+#endif
+
+#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST) && \
+    !defined(BOOST_NO_INITIALIZER_LISTS)
+
+UNORDERED_AUTO_TEST(test_initializer_list) {
+    std::cerr<<"Initializer List Tests\n";
+    boost::unordered_set<int> x1 = { 2, 10, 45, -5 };
+    BOOST_TEST(x1.find(10) != x1.end());
+    BOOST_TEST(x1.find(46) == x1.end());
+}
+
+#endif
+
 }
 
 RUN_TESTS()

test/unordered/copy_tests.cpp

@@ -1,12 +1,15 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
+#include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
 #include "../helpers/test.hpp"
 #include "../objects/test.hpp"
+#include "../objects/cxx11_allocator.hpp"
 #include "../helpers/random_values.hpp"
 #include "../helpers/tracker.hpp"
 #include "../helpers/equivalent.hpp"
@@ -18,34 +21,47 @@ namespace copy_tests
 {
 
 template <class T>
-void copy_construct_tests1(T*, test::random_generator const& generator = test::default_generator)
+void copy_construct_tests1(T*,
+    test::random_generator const& generator = test::default_generator)
 {
+    typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
+
     BOOST_DEDUCED_TYPENAME T::hasher hf;
     BOOST_DEDUCED_TYPENAME T::key_equal eq;
-    BOOST_DEDUCED_TYPENAME T::allocator_type al;
+    BOOST_DEDUCED_TYPENAME T::allocator_type al;    
 
     {
+        test::check_instances check_;
+
         T x;
         T y(x);
-        BOOST_CHECK(y.empty());
-        BOOST_CHECK(test::equivalent(y.hash_function(), hf));
-        BOOST_CHECK(test::equivalent(y.key_eq(), eq));
-        BOOST_CHECK(test::equivalent(y.get_allocator(), al));
-        BOOST_CHECK(x.max_load_factor() == y.max_load_factor());
+        BOOST_TEST(y.empty());
+        BOOST_TEST(test::equivalent(y.hash_function(), hf));
+        BOOST_TEST(test::equivalent(y.key_eq(), eq));
+        BOOST_TEST(test::equivalent(y.get_allocator(), al));
+        BOOST_TEST(x.max_load_factor() == y.max_load_factor());
+        BOOST_TEST(test::selected_count(y.get_allocator()) ==
+            (allocator_type::is_select_on_copy));
         test::check_equivalent_keys(y);
     }
 
     {
+        test::check_instances check_;
+
         test::random_values<T> v(1000, generator);
 
         T x(v.begin(), v.end());
         T y(x);
         test::unordered_equivalence_tester<T> equivalent(x);
-        equivalent(y);
+        BOOST_TEST(equivalent(y));
+        BOOST_TEST(test::selected_count(y.get_allocator()) ==
+            (allocator_type::is_select_on_copy));
         test::check_equivalent_keys(y);
     }
 
     {
+        test::check_instances check_;
+
         // In this test I drop the original containers max load factor, so it
         // is much lower than the load factor. The hash table is not allowed
         // to rehash, but the destination container should probably allocate
@@ -55,15 +71,18 @@ void copy_construct_tests1(T*, test::random_generator const& generator = test::d
         x.max_load_factor(x.load_factor() / 4);
         T y(x);
         test::unordered_equivalence_tester<T> equivalent(x);
-        equivalent(y);
+        BOOST_TEST(equivalent(y));
         // This isn't guaranteed:
-        BOOST_CHECK(y.load_factor() < y.max_load_factor());
+        BOOST_TEST(y.load_factor() < y.max_load_factor());
+        BOOST_TEST(test::selected_count(y.get_allocator()) ==
+            (allocator_type::is_select_on_copy));
         test::check_equivalent_keys(y);
     }
 }
 
 template <class T>
-void copy_construct_tests2(T* ptr, test::random_generator const& generator = test::default_generator)
+void copy_construct_tests2(T* ptr,
+    test::random_generator const& generator = test::default_generator)
 {
     copy_construct_tests1(ptr);
 
@@ -71,66 +90,130 @@ void copy_construct_tests2(T* ptr, test::random_generator const& generator = tes
     BOOST_DEDUCED_TYPENAME T::key_equal eq(1);
     BOOST_DEDUCED_TYPENAME T::allocator_type al(1);
     BOOST_DEDUCED_TYPENAME T::allocator_type al2(2);
+    
+    typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
 
     {
+        test::check_instances check_;
+
         T x(10000, hf, eq, al);
         T y(x);
-        BOOST_CHECK(y.empty());
-        BOOST_CHECK(test::equivalent(y.hash_function(), hf));
-        BOOST_CHECK(test::equivalent(y.key_eq(), eq));
-        BOOST_CHECK(test::equivalent(y.get_allocator(), al));
-        BOOST_CHECK(x.max_load_factor() == y.max_load_factor());
+        BOOST_TEST(y.empty());
+        BOOST_TEST(test::equivalent(y.hash_function(), hf));
+        BOOST_TEST(test::equivalent(y.key_eq(), eq));
+        BOOST_TEST(test::equivalent(y.get_allocator(), al));
+        BOOST_TEST(x.max_load_factor() == y.max_load_factor());
+        BOOST_TEST(test::selected_count(y.get_allocator()) ==
+            (allocator_type::is_select_on_copy));
         test::check_equivalent_keys(y);
     }
 
     {
+        test::check_instances check_;
+
         T x(1000, hf, eq, al);
         T y(x, al2);
-        BOOST_CHECK(y.empty());
-        BOOST_CHECK(test::equivalent(y.hash_function(), hf));
-        BOOST_CHECK(test::equivalent(y.key_eq(), eq));
-        BOOST_CHECK(test::equivalent(y.get_allocator(), al2));
-        BOOST_CHECK(x.max_load_factor() == y.max_load_factor());
+        BOOST_TEST(y.empty());
+        BOOST_TEST(test::equivalent(y.hash_function(), hf));
+        BOOST_TEST(test::equivalent(y.key_eq(), eq));
+        BOOST_TEST(test::equivalent(y.get_allocator(), al2));
+        BOOST_TEST(x.max_load_factor() == y.max_load_factor());
+        BOOST_TEST(test::selected_count(y.get_allocator()) == 0);
         test::check_equivalent_keys(y);
     }
 
     {
+        test::check_instances check_;
+
         test::random_values<T> v(1000, generator);
 
         T x(v.begin(), v.end(), 0, hf, eq, al);
         T y(x);
         test::unordered_equivalence_tester<T> equivalent(x);
-        equivalent(y);
+        BOOST_TEST(equivalent(y));
         test::check_equivalent_keys(y);
-        BOOST_CHECK(test::equivalent(y.get_allocator(), al));
+        BOOST_TEST(test::selected_count(y.get_allocator()) ==
+            (allocator_type::is_select_on_copy));
+        BOOST_TEST(test::equivalent(y.get_allocator(), al));
     }
 
     {
+        test::check_instances check_;
+
         test::random_values<T> v(500, generator);
 
         T x(v.begin(), v.end(), 0, hf, eq, al);
         T y(x, al2);
         test::unordered_equivalence_tester<T> equivalent(x);
-        equivalent(y);
+        BOOST_TEST(equivalent(y));
         test::check_equivalent_keys(y);
-        BOOST_CHECK(test::equivalent(y.get_allocator(), al2));
+        BOOST_TEST(test::selected_count(y.get_allocator()) == 0);
+        BOOST_TEST(test::equivalent(y.get_allocator(), al2));
     }
 }
 
-boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_set;
-boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multiset;
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_map;
-boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multimap;
+boost::unordered_set<test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_set;
+boost::unordered_multiset<test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_multiset;
+boost::unordered_map<test::object, test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_map;
+boost::unordered_multimap<test::object, test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_multimap;
+
+boost::unordered_set<test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::select_copy> >*
+    test_set_select_copy;
+boost::unordered_multiset<test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::select_copy> >*
+    test_multiset_select_copy;
+boost::unordered_map<test::object, test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::select_copy> >*
+    test_map_select_copy;
+boost::unordered_multimap<test::object, test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::select_copy> >*
+    test_multimap_select_copy;
+
+boost::unordered_set<test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::no_select_copy> >*
+    test_set_no_select_copy;
+boost::unordered_multiset<test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::no_select_copy> >*
+    test_multiset_no_select_copy;
+boost::unordered_map<test::object, test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::no_select_copy> >*
+    test_map_no_select_copy;
+boost::unordered_multimap<test::object, test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::no_select_copy> >*
+    test_multimap_no_select_copy;
 
 using test::default_generator;
 using test::generate_collisions;
 
-UNORDERED_TEST(copy_construct_tests1,
-    ((test_set)(test_multiset)(test_map)(test_multimap))
+UNORDERED_TEST(copy_construct_tests1, (
+        (test_set)(test_multiset)(test_map)(test_multimap)
+        (test_set_select_copy)(test_multiset_select_copy)(test_map_select_copy)(test_multimap_select_copy)
+        (test_set_no_select_copy)(test_multiset_no_select_copy)(test_map_no_select_copy)(test_multimap_no_select_copy)
+    )
 )
 
-UNORDERED_TEST(copy_construct_tests2,
-    ((test_set)(test_multiset)(test_map)(test_multimap))
+UNORDERED_TEST(copy_construct_tests2, (
+        (test_set)(test_multiset)(test_map)(test_multimap)
+        (test_set_select_copy)(test_multiset_select_copy)(test_map_select_copy)(test_multimap_select_copy)
+        (test_set_no_select_copy)(test_multiset_no_select_copy)(test_map_no_select_copy)(test_multimap_no_select_copy)
+    )
     ((default_generator)(generate_collisions))
 )
 

test/unordered/equality_deprecated.cpp

@@ -0,0 +1,173 @@
+
+// Copyright 2008-2009 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)
+
+#define BOOST_UNORDERED_DEPRECATED_EQUALITY
+
+#include "../helpers/prefix.hpp"
+
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
+#include <boost/preprocessor/seq.hpp>
+#include <list>
+#include "../helpers/test.hpp"
+
+namespace equality_tests
+{
+    struct mod_compare
+    {
+        bool alt_hash_;
+
+        explicit mod_compare(bool alt_hash = false) : alt_hash_(alt_hash) {}
+
+        bool operator()(int x, int y) const
+        {
+            return x % 1000 == y % 1000;
+        }
+
+        int operator()(int x) const
+        {
+            return alt_hash_ ? x % 250 : (x + 5) % 250;
+        }
+    };
+
+#define UNORDERED_EQUALITY_SET_TEST(seq1, op, seq2)                         \
+    {                                                                       \
+        boost::unordered_set<int, mod_compare, mod_compare> set1, set2;     \
+        BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set1, seq1)             \
+        BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set2, seq2)             \
+        BOOST_TEST(set1 op set2);                                           \
+    }
+
+#define UNORDERED_EQUALITY_MULTISET_TEST(seq1, op, seq2)                    \
+    {                                                                       \
+        boost::unordered_multiset<int, mod_compare, mod_compare>            \
+            set1, set2;                                                     \
+        BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set1, seq1)             \
+        BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set2, seq2)             \
+        BOOST_TEST(set1 op set2);                                           \
+    }
+
+#define UNORDERED_EQUALITY_MAP_TEST(seq1, op, seq2)                         \
+    {                                                                       \
+        boost::unordered_map<int, int, mod_compare, mod_compare>            \
+            map1, map2;                                                     \
+        BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map1, seq1)             \
+        BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2)             \
+        BOOST_TEST(map1 op map2);                                           \
+    }
+
+#define UNORDERED_EQUALITY_MULTIMAP_TEST(seq1, op, seq2)                    \
+    {                                                                       \
+        boost::unordered_multimap<int, int, mod_compare, mod_compare>       \
+            map1, map2;                                                     \
+        BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map1, seq1)             \
+        BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2)             \
+        BOOST_TEST(map1 op map2);                                           \
+    }
+
+#define UNORDERED_SET_INSERT(r, set, item) set.insert(item);
+#define UNORDERED_MAP_INSERT(r, map, item) \
+    map.insert(std::pair<int const, int> BOOST_PP_SEQ_TO_TUPLE(item));
+
+    UNORDERED_AUTO_TEST(equality_size_tests)
+    {
+        boost::unordered_set<int> x1, x2;
+        BOOST_TEST(x1 == x2);
+        BOOST_TEST(!(x1 != x2));
+
+        x1.insert(1);
+        BOOST_TEST(x1 != x2);
+        BOOST_TEST(!(x1 == x2));
+        BOOST_TEST(x2 != x1);
+        BOOST_TEST(!(x2 == x1));
+
+        x2.insert(1);
+        BOOST_TEST(x1 == x2);
+        BOOST_TEST(!(x1 != x2));
+
+        x2.insert(2);
+        BOOST_TEST(x1 != x2);
+        BOOST_TEST(!(x1 == x2));
+        BOOST_TEST(x2 != x1);
+        BOOST_TEST(!(x2 == x1));
+    }
+
+    UNORDERED_AUTO_TEST(equality_key_value_tests)
+    {
+        UNORDERED_EQUALITY_MULTISET_TEST((1), !=, (2))
+        UNORDERED_EQUALITY_SET_TEST((2), ==, (2))
+        UNORDERED_EQUALITY_MAP_TEST(((1)(1))((2)(1)), !=, ((1)(1))((3)(1)))
+    }
+
+    UNORDERED_AUTO_TEST(equality_collision_test)
+    {
+        UNORDERED_EQUALITY_MULTISET_TEST(
+            (1), !=, (501))
+        UNORDERED_EQUALITY_MULTISET_TEST(
+            (1)(251), !=, (1)(501))
+        UNORDERED_EQUALITY_MULTIMAP_TEST(
+            ((251)(1))((1)(1)), !=, ((501)(1))((1)(1)))
+        UNORDERED_EQUALITY_MULTISET_TEST(
+            (1)(501), ==, (1)(501))
+        UNORDERED_EQUALITY_SET_TEST(
+            (1)(501), ==, (501)(1))
+    }
+
+    UNORDERED_AUTO_TEST(equality_group_size_test)
+    {
+        UNORDERED_EQUALITY_MULTISET_TEST(
+            (10)(20)(20), !=, (10)(10)(20))
+        UNORDERED_EQUALITY_MULTIMAP_TEST(
+            ((10)(1))((20)(1))((20)(1)), !=,
+            ((10)(1))((20)(1))((10)(1)))
+        UNORDERED_EQUALITY_MULTIMAP_TEST(
+            ((20)(1))((10)(1))((10)(1)), ==,
+            ((10)(1))((20)(1))((10)(1)))
+    }
+
+    UNORDERED_AUTO_TEST(equality_map_value_test)
+    {
+        UNORDERED_EQUALITY_MAP_TEST(
+            ((1)(1)), !=, ((1)(2)))
+        UNORDERED_EQUALITY_MAP_TEST(
+            ((1)(1)), ==, ((1)(1)))
+        UNORDERED_EQUALITY_MULTIMAP_TEST(
+            ((1)(1)), !=, ((1)(2)))
+        UNORDERED_EQUALITY_MULTIMAP_TEST(
+            ((1)(1))((1)(1)), !=, ((1)(1))((1)(2)))
+        UNORDERED_EQUALITY_MULTIMAP_TEST(
+            ((1)(2))((1)(1)), !=, ((1)(1))((1)(2)))
+    }
+
+    UNORDERED_AUTO_TEST(equality_predicate_test)
+    {
+        UNORDERED_EQUALITY_SET_TEST(
+            (1), ==, (1001))
+        UNORDERED_EQUALITY_MAP_TEST(
+            ((1)(2))((1001)(1)), ==, ((1001)(2))((1)(1)))
+    }
+
+    // Test that equality still works when the two containers have
+    // different hash functions but the same equality predicate.
+
+    UNORDERED_AUTO_TEST(equality_different_hash_test)
+    {
+        typedef boost::unordered_set<int, mod_compare, mod_compare> set;
+        set set1(0, mod_compare(false), mod_compare(false));
+        set set2(0, mod_compare(true), mod_compare(true));
+        BOOST_TEST(set1 == set2);
+        set1.insert(1); set2.insert(2);
+        BOOST_TEST(set1 != set2);
+        set1.insert(2); set2.insert(1);
+        BOOST_TEST(set1 == set2);
+        set1.insert(10); set2.insert(20);
+        BOOST_TEST(set1 != set2);
+        set1.insert(20); set2.insert(10);
+        BOOST_TEST(set1 == set2);
+    }
+
+}
+
+RUN_TESTS()

test/unordered/equality_tests.cpp

@@ -1,8 +1,10 @@
 
-// Copyright 2008 Daniel James.
+// Copyright 2008-2009 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)
 
+#include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
 #include <boost/preprocessor/seq.hpp>
@@ -13,6 +15,10 @@ namespace equality_tests
 {
     struct mod_compare
     {
+        bool alt_hash_;
+
+        explicit mod_compare(bool alt_hash = false) : alt_hash_(alt_hash) {}
+
         bool operator()(int x, int y) const
         {
             return x % 1000 == y % 1000;
@@ -20,41 +26,44 @@ namespace equality_tests
 
         int operator()(int x) const
         {
-            return x % 250;
+            return alt_hash_ ? x % 250 : (x + 5) % 250;
         }
     };
 
-#define UNORDERED_EQUALITY_SET_TEST(seq1, op, seq2) \
-    do { \
-        boost::unordered_set<int, mod_compare, mod_compare> set1, set2; \
-        BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set1, seq1) \
-        BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set2, seq2) \
-        BOOST_CHECK(set1 op set2); \
-    } while(false)
+#define UNORDERED_EQUALITY_SET_TEST(seq1, op, seq2)                         \
+    {                                                                       \
+        boost::unordered_set<int, mod_compare, mod_compare> set1, set2;     \
+        BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set1, seq1)             \
+        BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set2, seq2)             \
+        BOOST_TEST(set1 op set2);                                           \
+    }
 
-#define UNORDERED_EQUALITY_MULTISET_TEST(seq1, op, seq2) \
-    do { \
-        boost::unordered_multiset<int, mod_compare, mod_compare> set1, set2; \
-        BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set1, seq1) \
-        BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set2, seq2) \
-        BOOST_CHECK(set1 op set2); \
-    } while(false)
+#define UNORDERED_EQUALITY_MULTISET_TEST(seq1, op, seq2)                    \
+    {                                                                       \
+        boost::unordered_multiset<int, mod_compare, mod_compare>            \
+            set1, set2;                                                     \
+        BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set1, seq1)             \
+        BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set2, seq2)             \
+        BOOST_TEST(set1 op set2);                                           \
+    }
 
-#define UNORDERED_EQUALITY_MAP_TEST(seq1, op, seq2) \
-    do { \
-        boost::unordered_map<int, int, mod_compare, mod_compare> map1, map2; \
-        BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map1, seq1) \
-        BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2) \
-        BOOST_CHECK(map1 op map2); \
-    } while(false)
+#define UNORDERED_EQUALITY_MAP_TEST(seq1, op, seq2)                         \
+    {                                                                       \
+        boost::unordered_map<int, int, mod_compare, mod_compare>            \
+            map1, map2;                                                     \
+        BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map1, seq1)             \
+        BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2)             \
+        BOOST_TEST(map1 op map2);                                           \
+    }
 
-#define UNORDERED_EQUALITY_MULTIMAP_TEST(seq1, op, seq2) \
-    do { \
-        boost::unordered_multimap<int, int, mod_compare, mod_compare> map1, map2; \
-        BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map1, seq1) \
-        BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2) \
-        BOOST_CHECK(map1 op map2); \
-    } while(false)
+#define UNORDERED_EQUALITY_MULTIMAP_TEST(seq1, op, seq2)                    \
+    {                                                                       \
+        boost::unordered_multimap<int, int, mod_compare, mod_compare>       \
+            map1, map2;                                                     \
+        BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map1, seq1)             \
+        BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2)             \
+        BOOST_TEST(map1 op map2);                                           \
+    }
 
 #define UNORDERED_SET_INSERT(r, set, item) set.insert(item);
 #define UNORDERED_MAP_INSERT(r, map, item) \
@@ -63,79 +72,100 @@ namespace equality_tests
     UNORDERED_AUTO_TEST(equality_size_tests)
     {
         boost::unordered_set<int> x1, x2;
-        BOOST_CHECK(x1 == x2);
-        BOOST_CHECK(!(x1 != x2));
+        BOOST_TEST(x1 == x2);
+        BOOST_TEST(!(x1 != x2));
 
         x1.insert(1);
-        BOOST_CHECK(x1 != x2);
-        BOOST_CHECK(!(x1 == x2));
-        BOOST_CHECK(x2 != x1);
-        BOOST_CHECK(!(x2 == x1));
+        BOOST_TEST(x1 != x2);
+        BOOST_TEST(!(x1 == x2));
+        BOOST_TEST(x2 != x1);
+        BOOST_TEST(!(x2 == x1));
         
         x2.insert(1);
-        BOOST_CHECK(x1 == x2);
-        BOOST_CHECK(!(x1 != x2));
+        BOOST_TEST(x1 == x2);
+        BOOST_TEST(!(x1 != x2));
         
         x2.insert(2);
-        BOOST_CHECK(x1 != x2);
-        BOOST_CHECK(!(x1 == x2));
-        BOOST_CHECK(x2 != x1);
-        BOOST_CHECK(!(x2 == x1));
+        BOOST_TEST(x1 != x2);
+        BOOST_TEST(!(x1 == x2));
+        BOOST_TEST(x2 != x1);
+        BOOST_TEST(!(x2 == x1));
     }
     
     UNORDERED_AUTO_TEST(equality_key_value_tests)
     {
-        UNORDERED_EQUALITY_MULTISET_TEST((1), !=, (2));
-        UNORDERED_EQUALITY_SET_TEST((2), ==, (2));
-        UNORDERED_EQUALITY_MAP_TEST(((1)(1))((2)(1)), !=, ((1)(1))((3)(1)));
+        UNORDERED_EQUALITY_MULTISET_TEST((1), !=, (2))
+        UNORDERED_EQUALITY_SET_TEST((2), ==, (2))
+        UNORDERED_EQUALITY_MAP_TEST(((1)(1))((2)(1)), !=, ((1)(1))((3)(1)))
     }
     
     UNORDERED_AUTO_TEST(equality_collision_test)
     {
         UNORDERED_EQUALITY_MULTISET_TEST(
-            (1), !=, (501));
+            (1), !=, (501))
         UNORDERED_EQUALITY_MULTISET_TEST(
-            (1)(251), !=, (1)(501));
+            (1)(251), !=, (1)(501))
         UNORDERED_EQUALITY_MULTIMAP_TEST(
-            ((251)(1))((1)(1)), !=, ((501)(1))((1)(1)));
+            ((251)(1))((1)(1)), !=, ((501)(1))((1)(1)))
         UNORDERED_EQUALITY_MULTISET_TEST(
-            (1)(501), ==, (1)(501));
+            (1)(501), ==, (1)(501))
         UNORDERED_EQUALITY_SET_TEST(
-            (1)(501), ==, (501)(1));
+            (1)(501), ==, (501)(1))
     }
 
     UNORDERED_AUTO_TEST(equality_group_size_test)
     {
         UNORDERED_EQUALITY_MULTISET_TEST(
-            (10)(20)(20), !=, (10)(10)(20));
+            (10)(20)(20), !=, (10)(10)(20))
         UNORDERED_EQUALITY_MULTIMAP_TEST(
             ((10)(1))((20)(1))((20)(1)), !=,
-            ((10)(1))((20)(1))((10)(1)));
+            ((10)(1))((20)(1))((10)(1)))
         UNORDERED_EQUALITY_MULTIMAP_TEST(
             ((20)(1))((10)(1))((10)(1)), ==,
-            ((10)(1))((20)(1))((10)(1)));
+            ((10)(1))((20)(1))((10)(1)))
     }
     
     UNORDERED_AUTO_TEST(equality_map_value_test)
     {
         UNORDERED_EQUALITY_MAP_TEST(
-            ((1)(1)), !=, ((1)(2)));
+            ((1)(1)), !=, ((1)(2)))
         UNORDERED_EQUALITY_MAP_TEST(
-            ((1)(1)), ==, ((1)(1)));
+            ((1)(1)), ==, ((1)(1)))
         UNORDERED_EQUALITY_MULTIMAP_TEST(
-            ((1)(1)), !=, ((1)(2)));
+            ((1)(1)), !=, ((1)(2)))
         UNORDERED_EQUALITY_MULTIMAP_TEST(
-            ((1)(1))((1)(1)), !=, ((1)(1))((1)(2)));
+            ((1)(1))((1)(1)), !=, ((1)(1))((1)(2)))
         UNORDERED_EQUALITY_MULTIMAP_TEST(
-            ((1)(2))((1)(1)), !=, ((1)(1))((1)(2)));
+            ((1)(2))((1)(1)), ==, ((1)(1))((1)(2)))
+        UNORDERED_EQUALITY_MULTIMAP_TEST(
+            ((1)(2))((1)(1)), !=, ((1)(1))((1)(3)))
     }
 
     UNORDERED_AUTO_TEST(equality_predicate_test)
     {
         UNORDERED_EQUALITY_SET_TEST(
-            (1), ==, (1001));
+            (1), !=, (1001))
         UNORDERED_EQUALITY_MAP_TEST(
-            ((1)(2))((1001)(1)), ==, ((1001)(2))((1)(1)));
+            ((1)(2))((1001)(1)), !=, ((1001)(2))((1)(1)))
+    }
+
+    // Test that equality still works when the two containers have
+    // different hash functions but the same equality predicate.
+
+    UNORDERED_AUTO_TEST(equality_different_hash_test)
+    {
+        typedef boost::unordered_set<int, mod_compare, mod_compare> set;
+        set set1(0, mod_compare(false), mod_compare(false));
+        set set2(0, mod_compare(true), mod_compare(true));
+        BOOST_TEST(set1 == set2);
+        set1.insert(1); set2.insert(2);
+        BOOST_TEST(set1 != set2);
+        set1.insert(2); set2.insert(1);
+        BOOST_TEST(set1 == set2);
+        set1.insert(10); set2.insert(20);
+        BOOST_TEST(set1 != set2);
+        set1.insert(20); set2.insert(10);
+        BOOST_TEST(set1 == set2);
     }
 
 }

test/unordered/equivalent_keys_tests.cpp

@@ -1,8 +1,10 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
+#include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
 #include "../helpers/test.hpp"
@@ -42,17 +44,20 @@ UNORDERED_AUTO_TEST(set_tests)
         {986, 25, 986}
     };
 
-    test_equal_insertion<boost::unordered_set<int> >(values[0], values[0] + 1);
-    test_equal_insertion<boost::unordered_set<int> >(values[1], values[1] + 2);
-    test_equal_insertion<boost::unordered_set<int> >(values[2], values[2] + 2);
-    test_equal_insertion<boost::unordered_set<int> >(values[3], values[3] + 2);
-    test_equal_insertion<boost::unordered_set<int> >(values[4], values[4] + 3);
+    typedef boost::unordered_set<int> set;
+    typedef boost::unordered_multiset<int> multiset;
 
-    test_equal_insertion<boost::unordered_multiset<int> >(values[0], values[0] + 1);
-    test_equal_insertion<boost::unordered_multiset<int> >(values[1], values[1] + 2);
-    test_equal_insertion<boost::unordered_multiset<int> >(values[2], values[2] + 2);
-    test_equal_insertion<boost::unordered_multiset<int> >(values[3], values[3] + 2);
-    test_equal_insertion<boost::unordered_multiset<int> >(values[4], values[4] + 3);
+    test_equal_insertion<set>(values[0], values[0] + 1);
+    test_equal_insertion<set>(values[1], values[1] + 2);
+    test_equal_insertion<set>(values[2], values[2] + 2);
+    test_equal_insertion<set>(values[3], values[3] + 2);
+    test_equal_insertion<set>(values[4], values[4] + 3);
+
+    test_equal_insertion<multiset>(values[0], values[0] + 1);
+    test_equal_insertion<multiset>(values[1], values[1] + 2);
+    test_equal_insertion<multiset>(values[2], values[2] + 2);
+    test_equal_insertion<multiset>(values[3], values[3] + 2);
+    test_equal_insertion<multiset>(values[4], values[4] + 3);
 }
 
 UNORDERED_AUTO_TEST(map_tests)

test/unordered/erase_equiv_tests.cpp

@@ -1,11 +1,13 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
 // The code for erasing elements from containers with equivalent keys is very
 // hairy with several tricky edge cases - so explicitly test each one.
 
+#include "../helpers/prefix.hpp"
+
 #include <boost/unordered_map.hpp>
 #include "../helpers/test.hpp"
 #include "../helpers/list.hpp"
@@ -15,6 +17,11 @@
 #include <boost/next_prior.hpp>
 #include "../objects/test.hpp"
 
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1400)
+#pragma warning(disable:4267) // conversion from 'size_t' to 'unsigned int',
+                              // possible loss of data.
+#endif
+
 struct write_pair_type
 {
     template <class X1, class X2>
@@ -67,11 +74,11 @@ UNORDERED_AUTO_TEST(single_item_tests)
 
     collide_map x(init.begin(), init.end());
     x.erase(x.begin(), x.begin());
-    BOOST_CHECK(x.count(1) == 1 && x.size() == 1);
+    BOOST_TEST(x.count(1) == 1 && x.size() == 1);
     x.erase(x.end(), x.end());
-    BOOST_CHECK(x.count(1) == 1 && x.size() == 1);
+    BOOST_TEST(x.count(1) == 1 && x.size() == 1);
     x.erase(x.begin(), x.end());
-    BOOST_CHECK(x.count(1) == 0 && x.size() == 0);
+    BOOST_TEST(x.count(1) == 0 && x.size() == 0);
 }
 
 UNORDERED_AUTO_TEST(two_equivalent_item_tests)
@@ -83,14 +90,14 @@ UNORDERED_AUTO_TEST(two_equivalent_item_tests)
     {
         collide_map x(init.begin(), init.end());
         x.erase(x.begin(), x.end());
-        BOOST_CHECK(x.count(1) == 0 && x.size() == 0);
+        BOOST_TEST(x.count(1) == 0 && x.size() == 0);
     }
 
     {
         collide_map x(init.begin(), init.end());
         int value = boost::next(x.begin())->second;
         x.erase(x.begin(), boost::next(x.begin()));
-        BOOST_CHECK(x.count(1) == 1 && x.size() == 1 &&
+        BOOST_TEST(x.count(1) == 1 && x.size() == 1 &&
             x.begin()->first == 1 && x.begin()->second == value);
     }
 
@@ -98,7 +105,7 @@ UNORDERED_AUTO_TEST(two_equivalent_item_tests)
         collide_map x(init.begin(), init.end());
         int value = x.begin()->second;
         x.erase(boost::next(x.begin()), x.end());
-        BOOST_CHECK(x.count(1) == 1 && x.size() == 1 &&
+        BOOST_TEST(x.count(1) == 1 && x.size() == 1 &&
                 x.begin()->first == 1 && x.begin()->second == value);
     }
 }
@@ -116,7 +123,7 @@ bool compare(Range1 const& x, Range2 const& y)
 }
 
 template <class Container>
-bool general_erase_range_test(Container& x, int start, int end)
+bool general_erase_range_test(Container& x, std::size_t start, std::size_t end)
 {
     collide_list l(x.begin(), x.end());
     l.erase(boost::next(l.begin(), start), boost::next(l.begin(), end));
@@ -128,7 +135,8 @@ template <class Container>
 void erase_subrange_tests(Container const& x)
 {
     for(std::size_t length = 0; length < x.size(); ++length) {
-        for(std::size_t position = 0; position < x.size() - length; ++position) {
+        for(std::size_t position = 0; position < x.size() - length; ++position)
+        {
             Container y(x);
             collide_list init(y.begin(), y.end());
             if(!general_erase_range_test(y, position, position + length)) {

test/unordered/erase_tests.cpp

@@ -1,8 +1,10 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
+#include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
 #include "../helpers/test.hpp"
@@ -21,51 +23,60 @@ namespace erase_tests
 test::seed_t seed(85638);
 
 template <class Container>
-void erase_tests1(Container*, test::random_generator generator = test::default_generator)
+void erase_tests1(Container*,
+    test::random_generator generator = test::default_generator)
 {
     std::cerr<<"Erase by key.\n";
     {
+        test::check_instances check_;
+
         test::random_values<Container> v(1000, generator);
         Container x(v.begin(), v.end());
-        for(BOOST_DEDUCED_TYPENAME test::random_values<Container>::iterator it = v.begin();
-            it != v.end(); ++it)
+        for(BOOST_DEDUCED_TYPENAME test::random_values<Container>::iterator
+            it = v.begin(); it != v.end(); ++it)
         {
             std::size_t count = x.count(test::get_key<Container>(*it));
             std::size_t old_size = x.size();
-            BOOST_CHECK(count == x.erase(test::get_key<Container>(*it)));
-            BOOST_CHECK(x.size() == old_size - count);
-            BOOST_CHECK(x.count(test::get_key<Container>(*it)) == 0);
-            BOOST_CHECK(x.find(test::get_key<Container>(*it)) == x.end());
+            BOOST_TEST(count == x.erase(test::get_key<Container>(*it)));
+            BOOST_TEST(x.size() == old_size - count);
+            BOOST_TEST(x.count(test::get_key<Container>(*it)) == 0);
+            BOOST_TEST(x.find(test::get_key<Container>(*it)) == x.end());
         }
     }
 
     std::cerr<<"erase(begin()).\n";
     {
+        test::check_instances check_;
+
         test::random_values<Container> v(1000, generator);
         Container x(v.begin(), v.end());
         std::size_t size = x.size();
         while(size > 0 && !x.empty())
         {
-            BOOST_DEDUCED_TYPENAME Container::key_type key = test::get_key<Container>(*x.begin());
+            BOOST_DEDUCED_TYPENAME Container::key_type
+                key = test::get_key<Container>(*x.begin());
             std::size_t count = x.count(key);
-            BOOST_DEDUCED_TYPENAME Container::iterator pos = x.erase(x.begin());
+            BOOST_DEDUCED_TYPENAME Container::iterator
+                pos = x.erase(x.begin());
             --size;
-            BOOST_CHECK(pos == x.begin());
-            BOOST_CHECK(x.count(key) == count - 1);
-            BOOST_CHECK(x.size() == size);
+            BOOST_TEST(pos == x.begin());
+            BOOST_TEST(x.count(key) == count - 1);
+            BOOST_TEST(x.size() == size);
         }
-        BOOST_CHECK(x.empty());
+        BOOST_TEST(x.empty());
     }
 
     std::cerr<<"erase(random position).\n";
     {
+        test::check_instances check_;
+
         test::random_values<Container> v(1000, generator);
         Container x(v.begin(), v.end());
         std::size_t size = x.size();
         while(size > 0 && !x.empty())
         {
             using namespace std;
-            int index = rand() % x.size();
+            int index = rand() % (int) x.size();
             BOOST_DEDUCED_TYPENAME Container::const_iterator prev, pos, next;
             if(index == 0) {
                 prev = pos = x.begin();
@@ -75,21 +86,24 @@ void erase_tests1(Container*, test::random_generator generator = test::default_g
                 pos = boost::next(prev);
             }
             next = boost::next(pos);
-            BOOST_DEDUCED_TYPENAME Container::key_type key = test::get_key<Container>(*pos);
+            BOOST_DEDUCED_TYPENAME Container::key_type
+                key = test::get_key<Container>(*pos);
             std::size_t count = x.count(key);
-            BOOST_CHECK(next == x.erase(pos));
+            BOOST_TEST(next == x.erase(pos));
             --size;
             if(size > 0)
-                BOOST_CHECK(index == 0 ? next == x.begin() :
+                BOOST_TEST(index == 0 ? next == x.begin() :
                         next == boost::next(prev));
-            BOOST_CHECK(x.count(key) == count - 1);
-            BOOST_CHECK(x.size() == size);
+            BOOST_TEST(x.count(key) == count - 1);
+            BOOST_TEST(x.size() == size);
         }
-        BOOST_CHECK(x.empty());
+        BOOST_TEST(x.empty());
     }
 
     std::cerr<<"erase(ranges).\n";
     {
+        test::check_instances check_;
+
         test::random_values<Container> v(500, generator);
         Container x(v.begin(), v.end());
 
@@ -99,33 +113,98 @@ void erase_tests1(Container*, test::random_generator generator = test::default_g
         // returns 'the iterator immediately following the erase elements'
         // and if nothing is erased, then there's nothing to follow. But I
         // think this is the only sensible option...
-        BOOST_CHECK(x.erase(x.end(), x.end()) == x.end());
-        BOOST_CHECK(x.erase(x.begin(), x.begin()) == x.begin());
-        BOOST_CHECK(x.size() == size);
+        BOOST_TEST(x.erase(x.end(), x.end()) == x.end());
+        BOOST_TEST(x.erase(x.begin(), x.begin()) == x.begin());
+        BOOST_TEST(x.size() == size);
 
-        BOOST_CHECK(x.erase(x.begin(), x.end()) == x.end());
-        BOOST_CHECK(x.empty());
-        BOOST_CHECK(x.begin() == x.end());
+        BOOST_TEST(x.erase(x.begin(), x.end()) == x.end());
+        BOOST_TEST(x.empty());
+        BOOST_TEST(x.begin() == x.end());
 
-        BOOST_CHECK(x.erase(x.begin(), x.end()) == x.begin());
+        BOOST_TEST(x.erase(x.begin(), x.end()) == x.begin());
     }
 
+    std::cerr<<"quick_erase(begin()).\n";
+    {
+        test::check_instances check_;
+
+        test::random_values<Container> v(1000, generator);
+        Container x(v.begin(), v.end());
+        std::size_t size = x.size();
+        while(size > 0 && !x.empty())
+        {
+            BOOST_DEDUCED_TYPENAME Container::key_type
+                key = test::get_key<Container>(*x.begin());
+            std::size_t count = x.count(key);
+            x.quick_erase(x.begin());
+            --size;
+            BOOST_TEST(x.count(key) == count - 1);
+            BOOST_TEST(x.size() == size);
+        }
+        BOOST_TEST(x.empty());
+    }
+
+    std::cerr<<"quick_erase(random position).\n";
+    {
+        test::check_instances check_;
+
+        test::random_values<Container> v(1000, generator);
+        Container x(v.begin(), v.end());
+        std::size_t size = x.size();
+        while(size > 0 && !x.empty())
+        {
+            using namespace std;
+            int index = rand() % (int) x.size();
+            BOOST_DEDUCED_TYPENAME Container::const_iterator prev, pos, next;
+            if(index == 0) {
+                prev = pos = x.begin();
+            }
+            else {
+                prev = boost::next(x.begin(), index - 1);
+                pos = boost::next(prev);
+            }
+            next = boost::next(pos);
+            BOOST_DEDUCED_TYPENAME Container::key_type
+                key = test::get_key<Container>(*pos);
+            std::size_t count = x.count(key);
+            x.quick_erase(pos);
+            --size;
+            if(size > 0)
+                BOOST_TEST(index == 0 ? next == x.begin() :
+                        next == boost::next(prev));
+            BOOST_TEST(x.count(key) == count - 1);
+            BOOST_TEST(x.size() == size);
+        }
+        BOOST_TEST(x.empty());
+    }
+
+
     std::cerr<<"clear().\n";
     {
+        test::check_instances check_;
+
         test::random_values<Container> v(500, generator);
         Container x(v.begin(), v.end());
         x.clear();
-        BOOST_CHECK(x.empty());
-        BOOST_CHECK(x.begin() == x.end());
+        BOOST_TEST(x.empty());
+        BOOST_TEST(x.begin() == x.end());
     }
 
     std::cerr<<"\n";
 }
 
-boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_set;
-boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multiset;
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_map;
-boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multimap;
+boost::unordered_set<test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_set;
+boost::unordered_multiset<test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_multiset;
+boost::unordered_map<test::object, test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_map;
+boost::unordered_multimap<test::object, test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_multimap;
 
 using test::default_generator;
 using test::generate_collisions;

test/unordered/find_tests.cpp

@@ -1,8 +1,10 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
+#include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
 #include "../helpers/test.hpp"
@@ -22,6 +24,8 @@ void find_tests1(X*, test::random_generator generator = test::default_generator)
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
 
     {
+        test::check_instances check_;
+
         test::random_values<X> v(500, generator);
         X x(v.begin(), v.end());
         X const& x_const = x;
@@ -33,13 +37,14 @@ void find_tests1(X*, test::random_generator generator = test::default_generator)
         {
             BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it1);
             iterator pos = x.find(key);
-            BOOST_DEDUCED_TYPENAME X::const_iterator const_pos = x_const.find(key);
-            BOOST_CHECK(pos != x.end() &&
+            BOOST_DEDUCED_TYPENAME X::const_iterator
+                const_pos = x_const.find(key);
+            BOOST_TEST(pos != x.end() &&
                     x.key_eq()(key, test::get_key<X>(*pos)));
-            BOOST_CHECK(const_pos != x_const.end() &&
+            BOOST_TEST(const_pos != x_const.end() &&
                     x_const.key_eq()(key, test::get_key<X>(*const_pos)));
 
-            BOOST_CHECK(x.count(key) == tracker.count(key));
+            BOOST_TEST(x.count(key) == tracker.count(key));
 
             test::compare_pairs(x.equal_range(key),
                     tracker.equal_range(key),
@@ -56,16 +61,18 @@ void find_tests1(X*, test::random_generator generator = test::default_generator)
             BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it2);
             if(tracker.find(test::get_key<X>(key)) == tracker.end())
             {
-                BOOST_CHECK(x.find(key) == x.end());
-                BOOST_CHECK(x_const.find(key) == x_const.end());
-                BOOST_CHECK(x.count(key) == 0);
+                BOOST_TEST(x.find(key) == x.end());
+                BOOST_TEST(x_const.find(key) == x_const.end());
+                BOOST_TEST(x.count(key) == 0);
                 std::pair<iterator, iterator> range = x.equal_range(key);
-                BOOST_CHECK(range.first == range.second);
+                BOOST_TEST(range.first == range.second);
             }
         }
     }
 
     {
+        test::check_instances check_;
+
         X x;
 
         test::random_values<X> v2(5, generator);
@@ -73,18 +80,77 @@ void find_tests1(X*, test::random_generator generator = test::default_generator)
                 v2.begin(); it3 != v2.end(); ++it3)
         {
             BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it3);
-            BOOST_CHECK(x.find(key) == x.end());
-            BOOST_CHECK(x.count(key) == 0);
+            BOOST_TEST(x.find(key) == x.end());
+            BOOST_TEST(x.count(key) == 0);
             std::pair<iterator, iterator> range = x.equal_range(key);
-            BOOST_CHECK(range.first == range.second);
+            BOOST_TEST(range.first == range.second);
         }
     }
 }
 
-boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_set;
-boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multiset;
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_map;
-boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multimap;
+struct compatible_key
+{
+    test::object o_;
+    
+    compatible_key(test::object const& o) : o_(o) {}
+};
+
+struct compatible_hash
+{
+    test::hash hash_;
+
+    std::size_t operator()(compatible_key const& k) const {
+        return hash_(k.o_);
+    }
+};
+
+struct compatible_predicate
+{
+    test::equal_to equal_;
+
+    bool operator()(compatible_key const& k1, compatible_key const& k2) const {
+        return equal_(k1.o_, k2.o_);
+    }
+};
+
+template <class X>
+void find_compatible_keys_test(X*,
+    test::random_generator generator = test::default_generator)
+{
+    typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
+    typedef BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator
+        value_iterator;
+    test::random_values<X> v(500, generator);
+    X x(v.begin(), v.end());
+    
+    compatible_hash h;
+    compatible_predicate eq;
+    
+    for(value_iterator it = v.begin(), end = v.end(); it != end; ++it) {
+        BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it);
+        BOOST_TEST(x.find(key) == x.find(compatible_key(key), h, eq));
+    }
+
+    test::random_values<X> v2(20, generator);
+    
+    for(value_iterator it = v2.begin(), end = v2.end(); it != end; ++it) {
+        BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it);
+        BOOST_TEST(x.find(key) == x.find(compatible_key(key), h, eq));
+    }
+}
+
+boost::unordered_set<test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_set;
+boost::unordered_multiset<test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_multiset;
+boost::unordered_map<test::object, test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_map;
+boost::unordered_multimap<test::object, test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_multimap;
 
 using test::default_generator;
 using test::generate_collisions;
@@ -93,6 +159,10 @@ UNORDERED_TEST(find_tests1,
     ((test_set)(test_multiset)(test_map)(test_multimap))
     ((default_generator)(generate_collisions))
 )
+UNORDERED_TEST(find_compatible_keys_test,
+    ((test_set)(test_multiset)(test_map)(test_multimap))
+    ((default_generator)(generate_collisions))
+)
 
 }
 

test/unordered/fwd_map_test.cpp

@@ -0,0 +1,81 @@
+
+// Copyright 2008-2009 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)
+
+#include "../helpers/prefix.hpp"
+
+#include <boost/unordered/unordered_map_fwd.hpp>
+
+template <typename T>
+void call_swap(boost::unordered_map<T,T>& x,
+    boost::unordered_map<T,T>& y)
+{
+    swap(x,y);
+}
+
+template <typename T>
+bool call_equals(boost::unordered_map<T,T>& x,
+    boost::unordered_map<T,T>& y)
+{
+    return x == y;
+}
+
+template <typename T>
+bool call_not_equals(boost::unordered_map<T,T>& x,
+    boost::unordered_map<T,T>& y)
+{
+    return x != y;
+}
+
+template <typename T>
+void call_swap(boost::unordered_multimap<T,T>& x,
+    boost::unordered_multimap<T,T>& y)
+{
+    swap(x,y);
+}
+
+template <typename T>
+bool call_equals(boost::unordered_multimap<T,T>& x,
+    boost::unordered_multimap<T,T>& y)
+{
+    return x == y;
+}
+
+template <typename T>
+bool call_not_equals(boost::unordered_multimap<T,T>& x,
+    boost::unordered_multimap<T,T>& y)
+{
+    return x != y;
+}
+
+#include <boost/unordered_map.hpp>
+#include "../helpers/test.hpp"
+
+typedef boost::unordered_map<int, int> int_map;
+typedef boost::unordered_multimap<int, int> int_multimap;
+
+UNORDERED_AUTO_TEST(use_map_fwd_declared_function) {
+    int_map x, y;
+    x[1] = 2;
+    y[2] = 1;
+    call_swap(x, y);
+
+    BOOST_TEST(y.find(1) != y.end() && y.find(1)->second == 2);
+    BOOST_TEST(y.find(2) == y.end());
+
+    BOOST_TEST(x.find(1) == x.end());
+    BOOST_TEST(x.find(2) != x.end() && x.find(2)->second == 1);
+
+    BOOST_TEST(!call_equals(x, y));
+    BOOST_TEST(call_not_equals(x, y));
+}
+
+UNORDERED_AUTO_TEST(use_multimap_fwd_declared_function) {
+    int_multimap x, y;
+    call_swap(x, y);
+    BOOST_TEST(call_equals(x, y));
+    BOOST_TEST(!call_not_equals(x, y));
+}
+
+RUN_TESTS()

test/unordered/fwd_set_test.cpp

@@ -0,0 +1,103 @@
+
+// Copyright 2008-2009 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)
+
+#include "../helpers/prefix.hpp"
+
+#include <boost/unordered/unordered_set_fwd.hpp>
+
+struct true_type { char x[100]; };
+struct false_type { char x; };
+
+false_type is_unordered_set_impl(void*);
+
+template <class Value, class Hash, class Pred, class Alloc>
+true_type is_unordered_set_impl(
+        boost::unordered_set<Value, Hash, Pred, Alloc>*);
+
+template<typename T>
+void call_swap(boost::unordered_set<T>& x,
+    boost::unordered_set<T>& y)
+{
+    swap(x,y);
+}
+
+template<typename T>
+bool call_equals(boost::unordered_set<T>& x,
+    boost::unordered_set<T>& y)
+{
+    return x == y;
+}
+
+template<typename T>
+bool call_not_equals(boost::unordered_set<T>& x,
+    boost::unordered_set<T>& y)
+{
+    return x != y;
+}
+
+template<typename T>
+void call_swap(boost::unordered_multiset<T>& x,
+    boost::unordered_multiset<T>& y)
+{
+    swap(x,y);
+}
+
+template<typename T>
+bool call_equals(boost::unordered_multiset<T>& x,
+    boost::unordered_multiset<T>& y)
+{
+    return x == y;
+}
+
+template<typename T>
+bool call_not_equals(boost::unordered_multiset<T>& x,
+    boost::unordered_multiset<T>& y)
+{
+    return x != y;
+}
+
+#include "../helpers/test.hpp"
+
+typedef boost::unordered_set<int> int_set;
+typedef boost::unordered_multiset<int> int_multiset;
+
+UNORDERED_AUTO_TEST(use_fwd_declared_trait_without_definition) {
+    BOOST_TEST(sizeof(is_unordered_set_impl((int_set*) 0))
+        == sizeof(true_type));
+}
+
+#include <boost/unordered_set.hpp>
+
+UNORDERED_AUTO_TEST(use_fwd_declared_trait) {
+    boost::unordered_set<int> x;
+    BOOST_TEST(sizeof(is_unordered_set_impl(&x)) == sizeof(true_type));
+
+    BOOST_TEST(sizeof(is_unordered_set_impl((int*) 0)) == sizeof(false_type));
+}
+
+UNORDERED_AUTO_TEST(use_set_fwd_declared_function) {
+    int_set x, y;
+    x.insert(1);
+    y.insert(2);
+    call_swap(x, y);
+
+    BOOST_TEST(y.find(1) != y.end());
+    BOOST_TEST(y.find(2) == y.end());
+
+    BOOST_TEST(x.find(1) == x.end());
+    BOOST_TEST(x.find(2) != x.end());
+
+    BOOST_TEST(!call_equals(x, y));
+    BOOST_TEST(call_not_equals(x, y));
+}
+
+UNORDERED_AUTO_TEST(use_multiset_fwd_declared_function) {
+    int_multiset x, y;
+    call_swap(x, y);
+    BOOST_TEST(call_equals(x, y));
+    BOOST_TEST(!call_not_equals(x, y));
+}
+
+RUN_TESTS()

test/unordered/incomplete_test.cpp

@@ -0,0 +1,148 @@
+
+// Copyright 2009 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)
+
+#include "../helpers/prefix.hpp"
+
+#include <utility>
+#include <boost/unordered_map.hpp>
+#include <boost/unordered_set.hpp>
+
+namespace x
+{
+    struct D { boost::unordered_map<D, D> x; };
+}
+
+namespace test
+{
+    // Declare, but don't define some types.
+
+    struct value;
+    struct hash;
+    struct equals;
+    template <class T>
+    struct malloc_allocator;
+
+    // Declare some instances
+    
+    typedef boost::unordered_map<value, value, hash, equals,
+        malloc_allocator<std::pair<value const, value> > > map;
+    typedef boost::unordered_multimap<value, value, hash, equals,
+        malloc_allocator<std::pair<value const, value> > > multimap;
+    typedef boost::unordered_set<value, hash, equals,
+        malloc_allocator<value> > set;
+    typedef boost::unordered_multiset<value, hash, equals,
+        malloc_allocator<value> > multiset;
+    
+    // Now define the types which are stored as members, as they are needed for
+    // declaring struct members.
+
+    struct hash { 
+        template <typename T>
+        std::size_t operator()(T const&) const { return 0; }
+    };
+
+    struct equals {
+        template <typename T>
+        bool operator()(T const&, T const&) const { return true; }
+    };
+
+}
+
+#include "../helpers/allocator.hpp"
+
+namespace test
+{
+    // Declare some members of a structs.
+    //
+    // Incomplete hash, equals and allocator aren't here supported at the
+    // moment.
+    
+    struct struct1 {
+        boost::unordered_map<struct1, struct1, hash, equals,
+            malloc_allocator<std::pair<struct1 const, struct1> > > x;
+    };
+    struct struct2 {
+        boost::unordered_multimap<struct2, struct2, hash, equals,
+            malloc_allocator<std::pair<struct2 const, struct2> > > x;
+    };
+    struct struct3 {
+        boost::unordered_set<struct3, hash, equals,
+            malloc_allocator<struct3> > x;
+    };
+    struct struct4 {
+        boost::unordered_multiset<struct4, hash, equals,
+            malloc_allocator<struct4> > x;
+    };
+    
+    // Now define the value type.
+
+    struct value {};
+
+    // Create some instances.
+    
+    test::map m1;
+    test::multimap m2;
+    test::set s1;
+    test::multiset s2;
+
+    test::struct1 c1;
+    test::struct2 c2;
+    test::struct3 c3;
+    test::struct4 c4;
+
+    // Now declare, but don't define, the operators required for comparing
+    // elements.
+
+    std::size_t hash_value(value const&);
+    bool operator==(value const&, value const&);
+
+    std::size_t hash_value(struct1 const&);
+    std::size_t hash_value(struct2 const&);
+    std::size_t hash_value(struct3 const&);
+    std::size_t hash_value(struct4 const&);
+    
+    bool operator==(struct1 const&, struct1 const&);
+    bool operator==(struct2 const&, struct2 const&);
+    bool operator==(struct3 const&, struct3 const&);
+    bool operator==(struct4 const&, struct4 const&);
+    
+    // And finally use these
+    
+    void use_types()
+    {
+        test::value x;
+        m1[x] = x;
+        m2.insert(std::make_pair(x, x));
+        s1.insert(x);
+        s2.insert(x);
+
+        c1.x.insert(std::make_pair(c1, c1));
+        c2.x.insert(std::make_pair(c2, c2));
+        c3.x.insert(c3);
+        c4.x.insert(c4);
+    }
+
+    // And finally define the operators required for comparing elements.
+
+    std::size_t hash_value(value const&) { return 0; }
+    bool operator==(value const&, value const&) { return true; }
+
+    std::size_t hash_value(struct1 const&) { return 0; }
+    std::size_t hash_value(struct2 const&) { return 0; }
+    std::size_t hash_value(struct3 const&) { return 0; }
+    std::size_t hash_value(struct4 const&) { return 0; }
+    
+    bool operator==(struct1 const&, struct1 const&) { return true; }
+    bool operator==(struct2 const&, struct2 const&) { return true; }
+    bool operator==(struct3 const&, struct3 const&) { return true; }
+    bool operator==(struct4 const&, struct4 const&) { return true; }
+}
+
+int main() {
+    // This could just be a compile test, but I like to be able to run these
+    // things. It's probably irrational, but I find it reassuring.
+
+    test::use_types();
+}

test/unordered/insert_stable_tests.cpp

@@ -1,8 +1,10 @@
 
-// Copyright 2007-2008 Daniel James.
+// Copyright 2007-2009 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)
 
+#include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
 #include "../helpers/test.hpp"
@@ -46,33 +48,37 @@ UNORDERED_AUTO_TEST(stable_insert_test1) {
     x.insert(insert_stable::member(1,2));
     x.insert(insert_stable::member(1,3));
 
-    boost::unordered_multiset<insert_stable::member>::const_iterator it = x.begin(), end = x.end();
-    BOOST_CHECK(it != end);
-    if(it != end) { BOOST_CHECK(it->tag2_ == 1); ++it; }
-    BOOST_CHECK(it != end);
-    if(it != end) { BOOST_CHECK(it->tag2_ == 2); ++it; }
-    BOOST_CHECK(it != end);
-    if(it != end) { BOOST_CHECK(it->tag2_ == 3); ++it; }
-    BOOST_CHECK(it == end);
+    boost::unordered_multiset<insert_stable::member>::const_iterator
+        it = x.begin(), end = x.end();
+    BOOST_TEST(it != end);
+    if(it != end) { BOOST_TEST(it->tag2_ == 1); ++it; }
+    BOOST_TEST(it != end);
+    if(it != end) { BOOST_TEST(it->tag2_ == 2); ++it; }
+    BOOST_TEST(it != end);
+    if(it != end) { BOOST_TEST(it->tag2_ == 3); ++it; }
+    BOOST_TEST(it == end);
 }
 
 UNORDERED_AUTO_TEST(stable_insert_test2) {
     boost::unordered_multimap<insert_stable::member, int> x;
-    typedef boost::unordered_multimap<insert_stable::member, int>::const_iterator iterator;
+    typedef
+        boost::unordered_multimap<insert_stable::member, int>::const_iterator
+        iterator;
 
-    iterator it = x.insert(x.end(), std::make_pair(insert_stable::member(1,1), 1));
+    iterator it
+        = x.insert(x.end(), std::make_pair(insert_stable::member(1,1), 1));
     it = x.insert(it, std::make_pair(insert_stable::member(1,2), 2));
     it = x.insert(it, std::make_pair(insert_stable::member(1,3), 3));
 
     it = x.begin();
     iterator end = x.end();
-    BOOST_CHECK(it != end);
-    if(it != end) { BOOST_CHECK(it->first.tag2_ == 1 && it->second == 1); ++it; }
-    BOOST_CHECK(it != end);
-    if(it != end) { BOOST_CHECK(it->first.tag2_ == 2 && it->second == 2); ++it; }
-    BOOST_CHECK(it != end);
-    if(it != end) { BOOST_CHECK(it->first.tag2_ == 3 && it->second == 3); ++it; }
-    BOOST_CHECK(it == end);
+    BOOST_TEST(it != end);
+    if(it != end) { BOOST_TEST(it->first.tag2_ == 1 && it->second == 1); ++it; }
+    BOOST_TEST(it != end);
+    if(it != end) { BOOST_TEST(it->first.tag2_ == 2 && it->second == 2); ++it; }
+    BOOST_TEST(it != end);
+    if(it != end) { BOOST_TEST(it->first.tag2_ == 3 && it->second == 3); ++it; }
+    BOOST_TEST(it == end);
 }
 
 RUN_TESTS()

test/unordered/insert_tests.cpp

@@ -1,8 +1,10 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2010 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)
 
+#include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
 #include "../helpers/test.hpp"
@@ -21,8 +23,11 @@ namespace insert_tests {
 test::seed_t seed(243432);
 
 template <class X>
-void unique_insert_tests1(X*, test::random_generator generator = test::default_generator)
+void unique_insert_tests1(X*,
+    test::random_generator generator = test::default_generator)
 {
+    test::check_instances check_;
+
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
     typedef test::ordered<X> ordered;
 
@@ -41,25 +46,30 @@ void unique_insert_tests1(X*, test::random_generator generator = test::default_g
         float b = x.max_load_factor();
 
         std::pair<iterator, bool> r1 = x.insert(*it);
-        std::pair<BOOST_DEDUCED_TYPENAME ordered::iterator, bool> r2 = tracker.insert(*it);
+        std::pair<BOOST_DEDUCED_TYPENAME ordered::iterator, bool>
+            r2 = tracker.insert(*it);
 
-        BOOST_CHECK(r1.second == r2.second);
-        BOOST_CHECK(*r1.first == *r2.first);
+        BOOST_TEST(r1.second == r2.second);
+        BOOST_TEST(*r1.first == *r2.first);
 
         tracker.compare_key(x, *it);
 
-        if(x.size() < b * old_bucket_count)
-            BOOST_CHECK(x.bucket_count() == old_bucket_count);
+        if(static_cast<double>(x.size()) < b * static_cast<double>(old_bucket_count))
+            BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 
     test::check_equivalent_keys(x);
 }
 
 template <class X>
-void equivalent_insert_tests1(X*, test::random_generator generator = test::default_generator)
+void equivalent_insert_tests1(X*,
+    test::random_generator generator = test::default_generator)
 {
     std::cerr<<"insert(value) tests for containers with equivalent keys.\n";
 
+    test::check_instances check_;
+
+
     X x;
     test::ordered<X> tracker = test::create_ordered(x);
 
@@ -71,21 +81,23 @@ void equivalent_insert_tests1(X*, test::random_generator generator = test::defau
         float b = x.max_load_factor();
 
         BOOST_DEDUCED_TYPENAME X::iterator r1 = x.insert(*it);
-        BOOST_DEDUCED_TYPENAME test::ordered<X>::iterator r2 = tracker.insert(*it);
+        BOOST_DEDUCED_TYPENAME test::ordered<X>::iterator r2
+            = tracker.insert(*it);
 
-        BOOST_CHECK(*r1 == *r2);
+        BOOST_TEST(*r1 == *r2);
 
         tracker.compare_key(x, *it);
 
-        if(x.size() < b * old_bucket_count)
-            BOOST_CHECK(x.bucket_count() == old_bucket_count);
+        if(static_cast<double>(x.size()) < b * static_cast<double>(old_bucket_count))
+            BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 
     test::check_equivalent_keys(x);
 }
 
 template <class X>
-void insert_tests2(X*, test::random_generator generator = test::default_generator)
+void insert_tests2(X*,
+    test::random_generator generator = test::default_generator)
 {
     typedef BOOST_DEDUCED_TYPENAME test::ordered<X> tracker_type;
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
@@ -95,23 +107,26 @@ void insert_tests2(X*, test::random_generator generator = test::default_generato
     std::cerr<<"insert(begin(), value) tests.\n";
 
     {
+        test::check_instances check_;
+
         X x;
         tracker_type tracker = test::create_ordered(x);
 
         test::random_values<X> v(1000, generator);
-        for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it = v.begin();
-                it != v.end(); ++it)
+        for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator
+            it = v.begin(); it != v.end(); ++it)
         {
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
+            BOOST_DEDUCED_TYPENAME X::size_type
+                old_bucket_count = x.bucket_count();
             float b = x.max_load_factor();
 
             iterator r1 = x.insert(x.begin(), *it);
             tracker_iterator r2 = tracker.insert(tracker.begin(), *it);
-            BOOST_CHECK(*r1 == *r2);
+            BOOST_TEST(*r1 == *r2);
             tracker.compare_key(x, *it);
 
-            if(x.size() < b * old_bucket_count)
-                BOOST_CHECK(x.bucket_count() == old_bucket_count);
+            if(static_cast<double>(x.size()) < b * static_cast<double>(old_bucket_count))
+                BOOST_TEST(x.bucket_count() == old_bucket_count);
         }
 
         test::check_equivalent_keys(x);
@@ -120,24 +135,27 @@ void insert_tests2(X*, test::random_generator generator = test::default_generato
     std::cerr<<"insert(end(), value) tests.\n";
 
     {
+        test::check_instances check_;
+
         X x;
         X const& x_const = x;
         tracker_type tracker = test::create_ordered(x);
 
         test::random_values<X> v(100, generator);
-        for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it = v.begin();
-                it != v.end(); ++it)
+        for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator
+            it = v.begin(); it != v.end(); ++it)
         {
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
+            BOOST_DEDUCED_TYPENAME X::size_type
+                old_bucket_count = x.bucket_count();
             float b = x.max_load_factor();
 
             const_iterator r1 = x.insert(x_const.end(), *it);
             tracker_iterator r2 = tracker.insert(tracker.end(), *it);
-            BOOST_CHECK(*r1 == *r2);
+            BOOST_TEST(*r1 == *r2);
             tracker.compare_key(x, *it);
 
-            if(x.size() < b * old_bucket_count)
-                BOOST_CHECK(x.bucket_count() == old_bucket_count);
+            if(static_cast<double>(x.size()) < b * static_cast<double>(old_bucket_count))
+                BOOST_TEST(x.bucket_count() == old_bucket_count);
         }
 
         test::check_equivalent_keys(x);
@@ -146,24 +164,27 @@ void insert_tests2(X*, test::random_generator generator = test::default_generato
     std::cerr<<"insert(pos, value) tests.\n";
 
     {
+        test::check_instances check_;
+
         X x;
         const_iterator pos = x.begin();
         tracker_type tracker = test::create_ordered(x);
 
         test::random_values<X> v(1000, generator);
-        for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it = v.begin();
-                it != v.end(); ++it)
+        for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator
+            it = v.begin(); it != v.end(); ++it)
         {
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
+            BOOST_DEDUCED_TYPENAME X::size_type
+                old_bucket_count = x.bucket_count();
             float b = x.max_load_factor();
 
             pos = x.insert(pos, *it);
             tracker_iterator r2 = tracker.insert(tracker.begin(), *it);
-            BOOST_CHECK(*pos == *r2);
+            BOOST_TEST(*pos == *r2);
             tracker.compare_key(x, *it);
 
-            if(x.size() < b * old_bucket_count)
-                BOOST_CHECK(x.bucket_count() == old_bucket_count);
+            if(static_cast<double>(x.size()) < b * static_cast<double>(old_bucket_count))
+                BOOST_TEST(x.bucket_count() == old_bucket_count);
         }
 
         test::check_equivalent_keys(x);
@@ -172,22 +193,25 @@ void insert_tests2(X*, test::random_generator generator = test::default_generato
     std::cerr<<"insert single item range tests.\n";
 
     {
+        test::check_instances check_;
+
         X x;
         tracker_type tracker = test::create_ordered(x);
 
         test::random_values<X> v(1000, generator);
-        for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it = v.begin();
-                it != v.end(); ++it)
+        for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator
+            it = v.begin(); it != v.end(); ++it)
         {
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
+            BOOST_DEDUCED_TYPENAME X::size_type
+                old_bucket_count = x.bucket_count();
             float b = x.max_load_factor();
 
             x.insert(it, boost::next(it));
             tracker.insert(*it);
             tracker.compare_key(x, *it);
 
-            if(x.size() < b * old_bucket_count)
-                BOOST_CHECK(x.bucket_count() == old_bucket_count);
+            if(static_cast<double>(x.size()) < b * static_cast<double>(old_bucket_count))
+                BOOST_TEST(x.bucket_count() == old_bucket_count);
         }
 
         test::check_equivalent_keys(x);
@@ -196,6 +220,8 @@ void insert_tests2(X*, test::random_generator generator = test::default_generato
     std::cerr<<"insert range tests.\n";
 
     {
+        test::check_instances check_;
+
         X x;
 
         test::random_values<X> v(1000, generator);
@@ -208,20 +234,39 @@ void insert_tests2(X*, test::random_generator generator = test::default_generato
     std::cerr<<"insert input iterator range tests.\n";
 
     {
+        test::check_instances check_;
+
         X x;
 
         test::random_values<X> v(1000, generator);
-        x.insert(test::input_iterator(v.begin()), test::input_iterator(v.end()));
+        BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator
+            begin = v.begin(), end = v.end();
+        x.insert(test::input_iterator(begin), test::input_iterator(end));
+        test::check_container(x, v);
+
+        test::check_equivalent_keys(x);
+    }
+
+    std::cerr<<"insert copy iterator range tests.\n";
+
+    {
+        test::check_instances check_;
+
+        X x;
+
+        test::random_values<X> v(1000, generator);
+        x.insert(test::copy_iterator(v.begin()), test::copy_iterator(v.end()));
         test::check_container(x, v);
 
         test::check_equivalent_keys(x);
     }
 }
 
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
+#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
 
 template <class X>
-void unique_emplace_tests1(X*, test::random_generator generator = test::default_generator)
+void unique_emplace_tests1(X*,
+    test::random_generator generator = test::default_generator)
 {
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
     typedef test::ordered<X> ordered;
@@ -241,22 +286,24 @@ void unique_emplace_tests1(X*, test::random_generator generator = test::default_
         float b = x.max_load_factor();
 
         std::pair<iterator, bool> r1 = x.emplace(*it);
-        std::pair<BOOST_DEDUCED_TYPENAME ordered::iterator, bool> r2 = tracker.insert(*it);
+        std::pair<BOOST_DEDUCED_TYPENAME ordered::iterator, bool>
+            r2 = tracker.insert(*it);
 
-        BOOST_CHECK(r1.second == r2.second);
-        BOOST_CHECK(*r1.first == *r2.first);
+        BOOST_TEST(r1.second == r2.second);
+        BOOST_TEST(*r1.first == *r2.first);
 
         tracker.compare_key(x, *it);
 
-        if(x.size() < b * old_bucket_count)
-            BOOST_CHECK(x.bucket_count() == old_bucket_count);
+        if(static_cast<double>(x.size()) < b * static_cast<double>(old_bucket_count))
+            BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 
     test::check_equivalent_keys(x);
 }
 
 template <class X>
-void equivalent_emplace_tests1(X*, test::random_generator generator = test::default_generator)
+void equivalent_emplace_tests1(X*,
+    test::random_generator generator = test::default_generator)
 {
     std::cerr<<"emplace(value) tests for containers with equivalent keys.\n";
 
@@ -271,14 +318,15 @@ void equivalent_emplace_tests1(X*, test::random_generator generator = test::defa
         float b = x.max_load_factor();
 
         BOOST_DEDUCED_TYPENAME X::iterator r1 = x.emplace(*it);
-        BOOST_DEDUCED_TYPENAME test::ordered<X>::iterator r2 = tracker.insert(*it);
+        BOOST_DEDUCED_TYPENAME test::ordered<X>::iterator
+            r2 = tracker.insert(*it);
 
-        BOOST_CHECK(*r1 == *r2);
+        BOOST_TEST(*r1 == *r2);
 
         tracker.compare_key(x, *it);
 
-        if(x.size() < b * old_bucket_count)
-            BOOST_CHECK(x.bucket_count() == old_bucket_count);
+        if(static_cast<double>(x.size()) < b * static_cast<double>(old_bucket_count))
+            BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 
     test::check_equivalent_keys(x);
@@ -306,19 +354,30 @@ void map_tests(X*, test::random_generator generator = test::default_generator)
 
         tracker.compare_key(x, *it);
 
-        if(x.size() < b * old_bucket_count)
-            BOOST_CHECK(x.bucket_count() == old_bucket_count);
+        if(static_cast<double>(x.size()) < b * static_cast<double>(old_bucket_count))
+            BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 
     test::check_equivalent_keys(x);   
 }
 
-template <class X>
-void associative_insert_range_test(X*, test::random_generator generator = test::default_generator)
-{
-    std::cerr<<"associative_insert_range_test\n";
+// Some tests for when the range's value type doesn't match the container's
+// value type.
 
-    typedef test::list<std::pair<BOOST_DEDUCED_TYPENAME X::key_type, BOOST_DEDUCED_TYPENAME X::mapped_type> > list;
+template <class X>
+void map_insert_range_test1(X*,
+    test::random_generator generator = test::default_generator)
+{
+    std::cerr<<"map_insert_range_test1\n";
+
+    test::check_instances check_;
+
+    typedef test::list<
+        std::pair<
+            BOOST_DEDUCED_TYPENAME X::key_type,
+            BOOST_DEDUCED_TYPENAME X::mapped_type
+        >
+    > list;
     test::random_values<X> v(1000, generator);
     list l(v.begin(), v.end());
 
@@ -327,10 +386,39 @@ void associative_insert_range_test(X*, test::random_generator generator = test::
     test::check_equivalent_keys(x);
 }
 
-boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_set;
-boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multiset;
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_map;
-boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multimap;
+template <class X>
+void map_insert_range_test2(X*,
+    test::random_generator generator = test::default_generator)
+{
+    std::cerr<<"map_insert_range_test2\n";
+
+    test::check_instances check_;
+
+    typedef test::list<
+        std::pair<BOOST_DEDUCED_TYPENAME X::key_type const, test::implicitly_convertible>
+    > list;
+    test::random_values<
+        boost::unordered_map<BOOST_DEDUCED_TYPENAME X::key_type, test::implicitly_convertible>
+    > v(1000, generator);
+    list l(v.begin(), v.end());
+
+    X x; x.insert(l.begin(), l.end());
+
+    test::check_equivalent_keys(x);
+}
+
+boost::unordered_set<test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_set;
+boost::unordered_multiset<test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_multiset;
+boost::unordered_map<test::object, test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_map;
+boost::unordered_multimap<test::object, test::object,
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_multimap;
 
 using test::default_generator;
 using test::generate_collisions;
@@ -350,7 +438,7 @@ UNORDERED_TEST(insert_tests2,
     ((default_generator)(generate_collisions))
 )
 
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
+#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
 UNORDERED_TEST(unique_emplace_tests1,
     ((test_set)(test_map))
     ((default_generator)(generate_collisions))
@@ -367,11 +455,179 @@ UNORDERED_TEST(map_tests,
     ((default_generator)(generate_collisions))
 )
 
-UNORDERED_TEST(associative_insert_range_test,
+UNORDERED_TEST(map_insert_range_test1,
     ((test_map)(test_multimap))
     ((default_generator)(generate_collisions))
 )
 
+UNORDERED_TEST(map_insert_range_test2,
+    ((test_map)(test_multimap))
+    ((default_generator)(generate_collisions))
+)
+
+#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST) && \
+    !defined(BOOST_NO_INITIALIZER_LISTS)
+
+UNORDERED_AUTO_TEST(insert_initializer_list_set)
+{
+    boost::unordered_set<int> set;
+    set.insert({1,2,3,1});
+    BOOST_TEST_EQ(set.size(), 3u);
+    BOOST_TEST(set.find(1) != set.end());
+    BOOST_TEST(set.find(4) == set.end());
+}
+
+UNORDERED_AUTO_TEST(insert_initializer_list_multiset)
+{
+    boost::unordered_multiset<std::string> multiset;
+    //multiset.insert({});
+    BOOST_TEST(multiset.empty());
+    multiset.insert({"a"});
+    BOOST_TEST_EQ(multiset.size(), 1u);
+    BOOST_TEST(multiset.find("a") != multiset.end());
+    BOOST_TEST(multiset.find("b") == multiset.end());
+    multiset.insert({"a","b"});
+    BOOST_TEST(multiset.size() == 3);
+    BOOST_TEST_EQ(multiset.count("a"), 2u);
+    BOOST_TEST_EQ(multiset.count("b"), 1u);
+    BOOST_TEST_EQ(multiset.count("c"), 0u);
+}
+
+UNORDERED_AUTO_TEST(insert_initializer_list_map)
+{
+    boost::unordered_map<std::string, std::string> map;
+    //map.insert({});
+    BOOST_TEST(map.empty());
+    map.insert({{"a", "b"},{"a", "b"},{"d", ""}});
+    BOOST_TEST_EQ(map.size(), 2u);
+}
+
+UNORDERED_AUTO_TEST(insert_initializer_list_multimap)
+{
+    boost::unordered_multimap<std::string, std::string> multimap;
+    //multimap.insert({});
+    BOOST_TEST(multimap.empty());
+    multimap.insert({{"a", "b"},{"a", "b"},{"d", ""}});
+    BOOST_TEST_EQ(multimap.size(), 3u);
+    BOOST_TEST_EQ(multimap.count("a"), 2u);
+}
+
+#endif
+
+struct overloaded_constructor
+{
+    overloaded_constructor(int x1 = 1, int x2 = 2, int x3 = 3, int x4 = 4)
+      : x1(x1), x2(x2), x3(x3), x4(x4) {}
+
+    int x1, x2, x3, x4;
+    
+    bool operator==(overloaded_constructor const& rhs) const
+    {
+        return x1 == rhs.x1 && x2 == rhs.x2 && x3 == rhs.x3 && x4 == rhs.x4;
+    }
+    
+    friend std::size_t hash_value(overloaded_constructor const& x)
+    {
+        std::size_t hash = 0;
+        boost::hash_combine(hash, x.x1);
+        boost::hash_combine(hash, x.x2);
+        boost::hash_combine(hash, x.x3);
+        boost::hash_combine(hash, x.x4);
+        return hash;
+    }
+};
+
+UNORDERED_AUTO_TEST(map_emplace_test)
+{
+    boost::unordered_map<int, overloaded_constructor> x;
+
+#if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x5100))
+    x.emplace();
+    BOOST_TEST(x.find(0) != x.end() &&
+        x.find(0)->second == overloaded_constructor());
+#endif
+
+    x.emplace(2, 3);
+    BOOST_TEST(x.find(2) != x.end() &&
+        x.find(2)->second == overloaded_constructor(3));
+
+#if defined (BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT)
+    x.emplace(1);
+    BOOST_TEST(x.find(1) != x.end() &&
+        x.find(1)->second == overloaded_constructor());
+
+    x.emplace(4, 5, 6);
+    BOOST_TEST(x.find(4) != x.end() &&
+        x.find(4)->second == overloaded_constructor(5, 6));
+
+    x.emplace(7, 8, 9, 10);
+    BOOST_TEST(x.find(7) != x.end() &&
+        x.find(7)->second == overloaded_constructor(8, 9, 10));
+#endif
+}
+
+UNORDERED_AUTO_TEST(set_emplace_test)
+{
+    boost::unordered_set<overloaded_constructor> x;
+    overloaded_constructor check;
+
+#if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x5100))
+    x.emplace();
+    BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
+#endif
+
+    x.clear();
+    x.emplace(1);
+    check = overloaded_constructor(1);
+    BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
+
+    x.clear();
+    x.emplace(2, 3);
+    check = overloaded_constructor(2, 3);
+    BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
+
+    x.clear();
+    x.emplace(4, 5, 6);
+    check = overloaded_constructor(4, 5, 6);
+    BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
+
+    x.clear();
+    x.emplace(7, 8, 9, 10);
+    check = overloaded_constructor(7, 8, 9, 10);
+    BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
+}
+
+UNORDERED_AUTO_TEST(map_emplace_test2)
+{
+    boost::unordered_map<overloaded_constructor, overloaded_constructor> x;
+
+    x.emplace(boost::unordered::piecewise_construct, boost::make_tuple(), boost::make_tuple());
+    BOOST_TEST(x.find(overloaded_constructor()) != x.end() &&
+        x.find(overloaded_constructor())->second == overloaded_constructor());
+
+    x.emplace(boost::unordered::piecewise_construct, boost::make_tuple(1), boost::make_tuple());
+    BOOST_TEST(x.find(overloaded_constructor(1)) != x.end() &&
+        x.find(overloaded_constructor(1))->second == overloaded_constructor());
+
+    x.emplace(boost::unordered::piecewise_construct, boost::make_tuple(2,3), boost::make_tuple(4,5,6));
+    BOOST_TEST(x.find(overloaded_constructor(2,3)) != x.end() &&
+        x.find(overloaded_constructor(2,3))->second == overloaded_constructor(4,5,6));
+}
+
+UNORDERED_AUTO_TEST(set_emplace_test2)
+{
+    boost::unordered_set<std::pair<overloaded_constructor, overloaded_constructor> > x;
+    std::pair<overloaded_constructor, overloaded_constructor> check;
+
+    x.emplace(boost::unordered::piecewise_construct, boost::make_tuple(), boost::make_tuple());
+    BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
+
+    x.clear();
+    x.emplace(boost::unordered::piecewise_construct, boost::make_tuple(1), boost::make_tuple(2,3));
+    check = std::make_pair(overloaded_constructor(1), overloaded_constructor(2, 3));;
+    BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
+}
+
 }
 
 RUN_TESTS()

test/unordered/link_test_1.cpp

@@ -1,8 +1,10 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
+#include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
 

test/unordered/link_test_2.cpp

@@ -1,8 +1,10 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
+#include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
 
@@ -11,6 +13,15 @@ void foo(boost::unordered_set<int>& x1,
         boost::unordered_multiset<int>& x3,
         boost::unordered_multimap<int, int>& x4)
 {
+#if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
+        struct dummy {
+            boost::unordered_set<int> x1;
+            boost::unordered_map<int, int> x2;
+            boost::unordered_multiset<int> x3;
+            boost::unordered_multimap<int, int> x4;
+        };
+#endif
+
     x1.insert(1);
     x2[2] = 2;
     x3.insert(3);

test/unordered/load_factor_tests.cpp

@@ -1,8 +1,10 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
+#include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
 #include "../helpers/test.hpp"
@@ -24,17 +26,18 @@ void set_load_factor_tests(X* = 0)
 {
     X x;
 
-    BOOST_CHECK(x.max_load_factor() == 1.0);
-    BOOST_CHECK(x.load_factor() == 0);
+    BOOST_TEST(x.max_load_factor() == 1.0);
+    BOOST_TEST(x.load_factor() == 0);
 
     // A valid implementation could fail these tests, but I think they're
     // reasonable.
-    x.max_load_factor(2.0); BOOST_CHECK(x.max_load_factor() == 2.0);
-    x.max_load_factor(0.5); BOOST_CHECK(x.max_load_factor() == 0.5);
+    x.max_load_factor(2.0); BOOST_TEST(x.max_load_factor() == 2.0);
+    x.max_load_factor(0.5); BOOST_TEST(x.max_load_factor() == 0.5);
 }
 
 template <class X>
-void insert_test(X*, float mlf, test::random_generator generator = test::default_generator)
+void insert_test(X*, float mlf,
+    test::random_generator generator = test::default_generator)
 {
     X x;
     x.max_load_factor(mlf);
@@ -48,8 +51,8 @@ void insert_test(X*, float mlf, test::random_generator generator = test::default
         BOOST_DEDUCED_TYPENAME X::size_type old_size = x.size(),
                  old_bucket_count = x.bucket_count();
         x.insert(*it);
-        if(old_size + 1 < b * old_bucket_count)
-            BOOST_CHECK(x.bucket_count() == old_bucket_count);
+        if(static_cast<double>(old_size + 1) < b * static_cast<double>(old_bucket_count))
+            BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 }
 

test/unordered/minimal_allocator.cpp

@@ -0,0 +1,95 @@
+
+// Copyright 2011 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)
+
+#include <boost/unordered/detail/allocator_helpers.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/mpl/assert.hpp>
+#include "../objects/test.hpp"
+
+template <class Tp> 
+struct SimpleAllocator
+{ 
+    typedef Tp value_type;
+
+    SimpleAllocator()
+    {
+    }
+
+    template <class T> SimpleAllocator(const SimpleAllocator<T>& other)
+    {
+    }
+
+    Tp *allocate(std::size_t n)
+    {
+        return static_cast<Tp*>(::operator new(n * sizeof(Tp)));
+    }
+
+    void deallocate(Tp* p, std::size_t)
+    {
+        ::operator delete((void*) p);
+    }
+};
+
+template <typename T>
+void test_simple_allocator()
+{
+    test::check_instances check_;
+
+    typedef boost::unordered::detail::allocator_traits<
+        SimpleAllocator<T> > traits;
+
+    BOOST_MPL_ASSERT((boost::is_same<typename traits::allocator_type, SimpleAllocator<T> >));
+
+    BOOST_MPL_ASSERT((boost::is_same<typename traits::value_type, T>));
+
+    BOOST_MPL_ASSERT((boost::is_same<typename traits::pointer, T* >));
+    BOOST_MPL_ASSERT((boost::is_same<typename traits::const_pointer, T const*>));
+    //BOOST_MPL_ASSERT((boost::is_same<typename traits::void_pointer, void* >));
+    //BOOST_MPL_ASSERT((boost::is_same<typename traits::const_void_pointer, void const*>));
+
+    BOOST_MPL_ASSERT((boost::is_same<typename traits::difference_type, std::ptrdiff_t>));
+
+#if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS
+    BOOST_MPL_ASSERT((boost::is_same<typename traits::size_type,
+        std::make_unsigned<std::ptrdiff_t>::type>));
+#else
+    BOOST_MPL_ASSERT((boost::is_same<typename traits::size_type, std::size_t>));
+#endif
+
+    BOOST_TEST(!traits::propagate_on_container_copy_assignment::value);
+    BOOST_TEST(!traits::propagate_on_container_move_assignment::value);
+    BOOST_TEST(!traits::propagate_on_container_swap::value);
+
+    // rebind_alloc
+    // rebind_traits
+
+    SimpleAllocator<T> a;
+
+    T* ptr1 = traits::allocate(a, 1);
+    //T* ptr2 = traits::allocate(a, 1, static_cast<void const*>(ptr1));
+    
+    traits::construct(a, ptr1, T(10));
+    //traits::construct(a, ptr2, T(30), ptr1);
+
+    BOOST_TEST(*ptr1 == T(10));
+    //BOOST_TEST(*ptr2 == T(30));
+
+    traits::destroy(a, ptr1);
+    //traits::destroy(a, ptr2);
+
+    //traits::deallocate(a, ptr2, 1);
+    traits::deallocate(a, ptr1, 1);
+
+    traits::max_size(a);
+}
+
+int main()
+{
+    test_simple_allocator<int>();
+    test_simple_allocator<test::object>();
+
+    return boost::report_errors();
+}

test/unordered/move_tests.cpp

@@ -1,20 +1,32 @@
 
-// Copyright 2008 Daniel James.
+// Copyright 2008-2009 Daniel James.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or move at http://www.boost.org/LICENSE_1_0.txt)
 
+#include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
 #include "../helpers/test.hpp"
 #include "../objects/test.hpp"
+#include "../objects/cxx11_allocator.hpp"
 #include "../helpers/random_values.hpp"
 #include "../helpers/tracker.hpp"
 #include "../helpers/equivalent.hpp"
 #include "../helpers/invariants.hpp"
 
+#if defined(BOOST_MSVC)
+#pragma warning(disable:4127) // conditional expression is constant
+#endif
+
 namespace move_tests
 {
     test::seed_t seed(98624);
+#if defined(BOOST_UNORDERED_USE_MOVE) || !defined(BOOST_NO_RVALUE_REFERENCES)
+#define BOOST_UNORDERED_TEST_MOVING 1
+#else
+#define BOOST_UNORDERED_TEST_MOVING 0
+#endif
 
     template<class T>
     T empty(T*) {
@@ -44,41 +56,53 @@ namespace move_tests
     }
 
     template <class T>
-    void move_construct_tests1(T* ptr, test::random_generator const& generator = test::default_generator)
+    void move_construct_tests1(T* ptr,
+        test::random_generator const& generator = test::default_generator)
     {
         BOOST_DEDUCED_TYPENAME T::hasher hf;
         BOOST_DEDUCED_TYPENAME T::key_equal eq;
         BOOST_DEDUCED_TYPENAME T::allocator_type al;
 
         {
+            test::check_instances check_;
+
             T y(empty(ptr));
-            BOOST_CHECK(y.empty());
-            BOOST_CHECK(test::equivalent(y.hash_function(), hf));
-            BOOST_CHECK(test::equivalent(y.key_eq(), eq));
-            BOOST_CHECK(test::equivalent(y.get_allocator(), al));
-            BOOST_CHECK(y.max_load_factor() == 1.0);
+            BOOST_TEST(y.empty());
+            BOOST_TEST(test::equivalent(y.hash_function(), hf));
+            BOOST_TEST(test::equivalent(y.key_eq(), eq));
+            BOOST_TEST(test::equivalent(y.get_allocator(), al));
+            BOOST_TEST(y.max_load_factor() == 1.0);
             test::check_equivalent_keys(y);
         }
 
         {
+            test::check_instances check_;
+
             test::random_values<T> v(1000, generator);
             test::object_count count;
             T y(create(v, count));
-            BOOST_CHECK(count == test::global_object_count);
+#if defined(BOOST_HAS_NRVO)
+            BOOST_TEST(count == test::global_object_count);
+#endif
             test::check_container(y, v);
             test::check_equivalent_keys(y);
         }
     }
 
     template <class T>
-    void move_assign_tests1(T*, test::random_generator const& generator = test::default_generator)
+    void move_assign_tests1(T*,
+        test::random_generator const& generator = test::default_generator)
     {
         {
+            test::check_instances check_;
+
             test::random_values<T> v(500, generator);
             test::object_count count;
             T y;
             y = create(v, count);
-            BOOST_CHECK(count == test::global_object_count);
+#if BOOST_UNORDERED_TEST_MOVING && defined(BOOST_HAS_NRVO)
+            BOOST_TEST(count == test::global_object_count);
+#endif
             test::check_container(y, v);
             test::check_equivalent_keys(y);
         }
@@ -96,67 +120,276 @@ namespace move_tests
         test::object_count count;
 
         {
+            test::check_instances check_;
+
             test::random_values<T> v(500, generator);
             T y(create(v, count, hf, eq, al, 0.5));
-            BOOST_CHECK(count == test::global_object_count);
-            test::check_container(y, v);
-            BOOST_CHECK(test::equivalent(y.hash_function(), hf));
-            BOOST_CHECK(test::equivalent(y.key_eq(), eq));
-            BOOST_CHECK(test::equivalent(y.get_allocator(), al));
-            BOOST_CHECK(y.max_load_factor() == 0.5); // Not necessarily required.
-            test::check_equivalent_keys(y);
-        }
-
-        {
-            // TODO: To do this correctly requires the fancy new allocator stuff.
-            test::random_values<T> v(500, generator);
-            T y(create(v, count, hf, eq, al, 2.0), al2);
-            BOOST_CHECK(count != test::global_object_count);
-            test::check_container(y, v);
-            BOOST_CHECK(test::equivalent(y.hash_function(), hf));
-            BOOST_CHECK(test::equivalent(y.key_eq(), eq));
-            BOOST_CHECK(test::equivalent(y.get_allocator(), al2));
-            BOOST_CHECK(y.max_load_factor() == 2.0); // Not necessarily required.
-            test::check_equivalent_keys(y);
-        }
-
-        {
-            test::random_values<T> v(25, generator);
-            T y(create(v, count, hf, eq, al, 1.0), al);
-#if defined(BOOST_HAS_RVALUE_REFS)
-            BOOST_CHECK(count == test::global_object_count);
-#else
-            BOOST_CHECK(test::global_object_count.constructions - count.constructions <=
-                (test::is_map<T>::value ? 50 : 25));
-            BOOST_CHECK(count.instances == test::global_object_count.instances);
+#if defined(BOOST_HAS_NRVO)
+            BOOST_TEST(count == test::global_object_count);
 #endif
             test::check_container(y, v);
-            BOOST_CHECK(test::equivalent(y.hash_function(), hf));
-            BOOST_CHECK(test::equivalent(y.key_eq(), eq));
-            BOOST_CHECK(test::equivalent(y.get_allocator(), al));
-            BOOST_CHECK(y.max_load_factor() == 1.0); // Not necessarily required.
+            BOOST_TEST(test::equivalent(y.hash_function(), hf));
+            BOOST_TEST(test::equivalent(y.key_eq(), eq));
+            BOOST_TEST(test::equivalent(y.get_allocator(), al));
+            BOOST_TEST(y.max_load_factor() == 0.5); // Not necessarily required.
+            test::check_equivalent_keys(y);
+        }
+
+        {
+            test::check_instances check_;
+
+            // TODO: To do this correctly requires the fancy new allocator
+            // stuff.
+            test::random_values<T> v(500, generator);
+            T y(create(v, count, hf, eq, al, 2.0), al2);
+            BOOST_TEST(count != test::global_object_count);
+            test::check_container(y, v);
+            BOOST_TEST(test::equivalent(y.hash_function(), hf));
+            BOOST_TEST(test::equivalent(y.key_eq(), eq));
+            BOOST_TEST(test::equivalent(y.get_allocator(), al2));
+            BOOST_TEST(y.max_load_factor() == 2.0); // Not necessarily required.
+            test::check_equivalent_keys(y);
+        }
+
+        {
+            test::check_instances check_;
+
+            test::random_values<T> v(25, generator);
+            T y(create(v, count, hf, eq, al, 1.0), al);
+#if !defined(BOOST_NO_RVALUE_REFERENCES)
+            BOOST_TEST(count == test::global_object_count);
+#elif defined(BOOST_HAS_NRVO)
+            BOOST_TEST(
+                test::global_object_count.constructions - count.constructions <=
+                (test::is_map<T>::value ? 50 : 25));
+            BOOST_TEST(count.instances == test::global_object_count.instances);
+#else
+            BOOST_TEST(
+                test::global_object_count.constructions - count.constructions <=
+                (test::is_map<T>::value ? 100 : 50));
+            BOOST_TEST(count.instances == test::global_object_count.instances);
+#endif
+            test::check_container(y, v);
+            BOOST_TEST(test::equivalent(y.hash_function(), hf));
+            BOOST_TEST(test::equivalent(y.key_eq(), eq));
+            BOOST_TEST(test::equivalent(y.get_allocator(), al));
+            BOOST_TEST(y.max_load_factor() == 1.0); // Not necessarily required.
             test::check_equivalent_keys(y);
         }
     }
 
-    boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_set;
-    boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multiset;
-    boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_map;
-    boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multimap;
+    template <class T>
+    void move_assign_tests2(T*,
+        test::random_generator const& generator = test::default_generator)
+    {
+        BOOST_DEDUCED_TYPENAME T::hasher hf(1);
+        BOOST_DEDUCED_TYPENAME T::key_equal eq(1);
+        BOOST_DEDUCED_TYPENAME T::allocator_type al1(1);
+        BOOST_DEDUCED_TYPENAME T::allocator_type al2(2);
+        typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
+
+        {
+            test::random_values<T> v(500, generator);
+            test::random_values<T> v2(0, generator);
+            T y(v.begin(), v.end(), 0, hf, eq, al1);
+            test::object_count count;
+            y = create(v2, count, hf, eq, al2, 2.0);
+            BOOST_TEST(y.empty());
+            test::check_container(y, v2);
+            test::check_equivalent_keys(y);
+            BOOST_TEST(y.max_load_factor() == 2.0);
+
+#if defined(BOOST_HAS_NRVO)
+            if (BOOST_UNORDERED_TEST_MOVING ?
+                    (bool) allocator_type::is_propagate_on_move :
+                    (bool) allocator_type::is_propagate_on_assign)
+            {
+                BOOST_TEST(test::equivalent(y.get_allocator(), al2));
+            }
+            else {
+                BOOST_TEST(test::equivalent(y.get_allocator(), al1));
+            }
+#endif
+        }
+
+        {
+            test::random_values<T> v(500, generator);
+            test::object_count count;
+            T y(0, hf, eq, al1);
+            y = create(v, count, hf, eq, al2, 0.5);
+#if defined(BOOST_HAS_NRVO)
+            if (BOOST_UNORDERED_TEST_MOVING &&
+                    allocator_type::is_propagate_on_move)
+            {
+                BOOST_TEST(count == test::global_object_count);
+            }
+#endif
+            test::check_container(y, v);
+            test::check_equivalent_keys(y);
+            BOOST_TEST(y.max_load_factor() == 0.5);
+
+#if defined(BOOST_HAS_NRVO)
+            if (BOOST_UNORDERED_TEST_MOVING ?
+                    (bool) allocator_type::is_propagate_on_move :
+                    (bool) allocator_type::is_propagate_on_assign)
+            {
+                BOOST_TEST(test::equivalent(y.get_allocator(), al2));
+            }
+            else {
+                BOOST_TEST(test::equivalent(y.get_allocator(), al1));
+            }
+#endif
+        }
+
+        {
+            test::check_instances check_;
+
+            test::random_values<T> v(500, generator);
+            T y(0, hf, eq, al1);
+
+            T x(0, hf, eq, al2);
+            x.max_load_factor(0.25);
+            x.insert(v.begin(), v.end());
+
+            test::object_count count = test::global_object_count;
+            y = boost::move(x);
+            if (BOOST_UNORDERED_TEST_MOVING &&
+                    allocator_type::is_propagate_on_move)
+            {
+                BOOST_TEST(count == test::global_object_count);
+            }
+            test::check_container(y, v);
+            test::check_equivalent_keys(y);
+            BOOST_TEST(y.max_load_factor() == 0.25);
+
+            if (BOOST_UNORDERED_TEST_MOVING ?
+                    (bool) allocator_type::is_propagate_on_move :
+                    (bool) allocator_type::is_propagate_on_assign)
+            {
+                BOOST_TEST(test::equivalent(y.get_allocator(), al2));
+            }
+            else {
+                BOOST_TEST(test::equivalent(y.get_allocator(), al1));
+            }
+        }
+
+        {
+            test::check_instances check_;
+
+            test::random_values<T> v1(1000, generator);
+            test::random_values<T> v2(200, generator);
+
+            T x(0, hf, eq, al2);
+            x.max_load_factor(0.5);
+            x.insert(v2.begin(), v2.end());
+
+            test::object_count count1 = test::global_object_count;
+
+            T y(v1.begin(), v1.end(), 0, hf, eq, al1);
+            y = boost::move(x);
+
+            test::object_count count2 = test::global_object_count;
+
+            if (BOOST_UNORDERED_TEST_MOVING &&
+                    allocator_type::is_propagate_on_move)
+            {
+                BOOST_TEST(count1.instances ==
+                    test::global_object_count.instances);
+                BOOST_TEST(count2.constructions ==
+                    test::global_object_count.constructions);
+            }
+
+            test::check_container(y, v2);
+            test::check_equivalent_keys(y);
+            BOOST_TEST(y.max_load_factor() == 0.5);
+
+            if (BOOST_UNORDERED_TEST_MOVING ?
+                    (bool) allocator_type::is_propagate_on_move :
+                    (bool) allocator_type::is_propagate_on_assign)
+            {
+                BOOST_TEST(test::equivalent(y.get_allocator(), al2));
+            }
+            else {
+                BOOST_TEST(test::equivalent(y.get_allocator(), al1));
+            }
+        }
+    }
+
+    boost::unordered_set<test::object,
+        test::hash, test::equal_to,
+        test::allocator<test::object> >* test_set;
+    boost::unordered_multiset<test::object,
+        test::hash, test::equal_to,
+        test::allocator<test::object> >* test_multiset;
+    boost::unordered_map<test::object, test::object,
+        test::hash, test::equal_to,
+        test::allocator<test::object> >* test_map;
+    boost::unordered_multimap<test::object, test::object,
+        test::hash, test::equal_to,
+        test::allocator<test::object> >* test_multimap;
+
+boost::unordered_set<test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::propagate_move> >*
+    test_set_prop_move;
+boost::unordered_multiset<test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::propagate_move> >*
+    test_multiset_prop_move;
+boost::unordered_map<test::object, test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::propagate_move> >*
+    test_map_prop_move;
+boost::unordered_multimap<test::object, test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::propagate_move> >*
+    test_multimap_prop_move;
+
+boost::unordered_set<test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::no_propagate_move> >*
+    test_set_no_prop_move;
+boost::unordered_multiset<test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::no_propagate_move> >*
+    test_multiset_no_prop_move;
+boost::unordered_map<test::object, test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::no_propagate_move> >*
+    test_map_no_prop_move;
+boost::unordered_multimap<test::object, test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::no_propagate_move> >*
+    test_multimap_no_prop_move;
 
     using test::default_generator;
     using test::generate_collisions;
 
-    UNORDERED_TEST(move_construct_tests1,
-        ((test_set)(test_multiset)(test_map)(test_multimap))
+    UNORDERED_TEST(move_construct_tests1, (
+            (test_set)(test_multiset)(test_map)(test_multimap)
+            (test_set_prop_move)(test_multiset_prop_move)(test_map_prop_move)(test_multimap_prop_move)
+            (test_set_no_prop_move)(test_multiset_no_prop_move)(test_map_no_prop_move)(test_multimap_no_prop_move)
+        )
     )
-    UNORDERED_TEST(move_assign_tests1,
-        ((test_set)(test_multiset)(test_map)(test_multimap))
+    UNORDERED_TEST(move_assign_tests1, (
+            (test_set)(test_multiset)(test_map)(test_multimap)
+            (test_set_prop_move)(test_multiset_prop_move)(test_map_prop_move)(test_multimap_prop_move)
+            (test_set_no_prop_move)(test_multiset_no_prop_move)(test_map_no_prop_move)(test_multimap_no_prop_move)
+        )
     )
-    UNORDERED_TEST(move_construct_tests2,
-        ((test_set)(test_multiset)(test_map)(test_multimap))
+    UNORDERED_TEST(move_construct_tests2, (
+            (test_set)(test_multiset)(test_map)(test_multimap)
+            (test_set_prop_move)(test_multiset_prop_move)(test_map_prop_move)(test_multimap_prop_move)
+            (test_set_no_prop_move)(test_multiset_no_prop_move)(test_map_no_prop_move)(test_multimap_no_prop_move)
+        )
         ((default_generator)(generate_collisions))
     )
+    UNORDERED_TEST(move_assign_tests2, (
+            (test_set)(test_multiset)(test_map)(test_multimap)
+            (test_set_prop_move)(test_multiset_prop_move)(test_map_prop_move)(test_multimap_prop_move)
+            (test_set_no_prop_move)(test_multiset_no_prop_move)(test_map_no_prop_move)(test_multimap_no_prop_move)
+        )
+    )
 }
 
 RUN_TESTS()

test/unordered/rehash_tests.cpp

@@ -1,8 +1,10 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
+#include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
 #include "../helpers/test.hpp"
@@ -17,7 +19,9 @@ test::seed_t seed(2974);
 template <class X>
 bool postcondition(X const& x, BOOST_DEDUCED_TYPENAME X::size_type n)
 {
-    return x.bucket_count() > x.size() / x.max_load_factor() && x.bucket_count() >= n;
+    return static_cast<double>(x.bucket_count()) >
+        static_cast<double>(x.size()) / x.max_load_factor() &&
+        x.bucket_count() >= n;
 }
 
 template <class X>
@@ -26,32 +30,72 @@ void rehash_empty_test1(X* = 0)
     X x;
 
     x.rehash(10000);
-    BOOST_CHECK(postcondition(x, 10000));
+    BOOST_TEST(postcondition(x, 10000));
 
     x.rehash(0);
-    BOOST_CHECK(postcondition(x, 0));
+    BOOST_TEST(postcondition(x, 0));
 }
 
 template <class X>
-void rehash_test1(X* = 0, test::random_generator generator = test::default_generator)
+void rehash_empty_test2(X* = 0,
+    test::random_generator generator = test::default_generator)
+{
+    test::random_values<X> v(1000, generator);
+    test::ordered<X> tracker;
+
+    X x;
+
+    x.rehash(10000);
+    BOOST_TEST(postcondition(x, 10000));
+
+    tracker.insert_range(v.begin(), v.end());
+    x.insert(v.begin(), v.end());
+    tracker.compare(x);
+
+    BOOST_TEST(postcondition(x, 10000));
+}
+
+template <class X>
+void rehash_empty_test3(X* = 0,
+    test::random_generator generator = test::default_generator)
+{
+    test::random_values<X> v(1000, generator);
+    test::ordered<X> tracker;
+
+    X x;
+
+    x.rehash(0);
+    BOOST_TEST(postcondition(x, 0));
+
+    tracker.insert_range(v.begin(), v.end());
+    x.insert(v.begin(), v.end());
+    tracker.compare(x);
+
+    BOOST_TEST(postcondition(x, 0));
+}
+
+
+template <class X>
+void rehash_test1(X* = 0,
+    test::random_generator generator = test::default_generator)
 {
     test::random_values<X> v(1000, generator);
     test::ordered<X> tracker;
     tracker.insert_range(v.begin(), v.end());
     X x(v.begin(), v.end());
 
-    x.rehash(0); BOOST_CHECK(postcondition(x, 0));
+    x.rehash(0); BOOST_TEST(postcondition(x, 0));
     tracker.compare(x);
 
     x.max_load_factor(0.25);
-    x.rehash(0); BOOST_CHECK(postcondition(x, 0));
+    x.rehash(0); BOOST_TEST(postcondition(x, 0));
     tracker.compare(x);
 
     x.max_load_factor(50.0);
-    x.rehash(0); BOOST_CHECK(postcondition(x, 0));
+    x.rehash(0); BOOST_TEST(postcondition(x, 0));
     tracker.compare(x);
 
-    x.rehash(1000); BOOST_CHECK(postcondition(x, 1000));
+    x.rehash(1000); BOOST_TEST(postcondition(x, 1000));
     tracker.compare(x);
 }
 
@@ -63,6 +107,12 @@ boost::unordered_multimap<int, int>* int_multimap_ptr;
 UNORDERED_TEST(rehash_empty_test1,
     ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr))
 )
+UNORDERED_TEST(rehash_empty_test2,
+    ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr))
+)
+UNORDERED_TEST(rehash_empty_test3,
+    ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr))
+)
 UNORDERED_TEST(rehash_test1,
     ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr))
 )

test/unordered/simple_tests.cpp

@@ -1,10 +1,12 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
 // This test checks the runtime requirements of containers.
 
+#include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
 #include "../helpers/test.hpp"
@@ -19,67 +21,69 @@ void simple_test(X const& a)
 
     {
         X u;
-        BOOST_CHECK(u.size() == 0);
-        BOOST_CHECK(X().size() == 0);
+        BOOST_TEST(u.size() == 0);
+        BOOST_TEST(X().size() == 0);
     }
 
     {
-        BOOST_CHECK(equivalent(X(a)));
+        BOOST_TEST(equivalent(X(a)));
     }
 
     {
         X u(a);
-        BOOST_CHECK(equivalent(u));
+        BOOST_TEST(equivalent(u));
     }
 
     {
         X u = a;
-        BOOST_CHECK(equivalent(u));
+        BOOST_TEST(equivalent(u));
     }
 
     {
         X b(a);
-        BOOST_CHECK(b.begin() == const_cast<X const&>(b).cbegin());
-        BOOST_CHECK(b.end() == const_cast<X const&>(b).cend());
+        BOOST_TEST(b.begin() == const_cast<X const&>(b).cbegin());
+        BOOST_TEST(b.end() == const_cast<X const&>(b).cend());
     }
 
     {
         X b(a);
         X c;
-        BOOST_CHECK(equivalent(b));
-        BOOST_CHECK(c.empty());
+        BOOST_TEST(equivalent(b));
+        BOOST_TEST(c.empty());
         b.swap(c);
-        BOOST_CHECK(b.empty());
-        BOOST_CHECK(equivalent(c));
+        BOOST_TEST(b.empty());
+        BOOST_TEST(equivalent(c));
         b.swap(c);
-        BOOST_CHECK(c.empty());
-        BOOST_CHECK(equivalent(b));
+        BOOST_TEST(c.empty());
+        BOOST_TEST(equivalent(b));
     }
 
     {
         X u;
         X& r = u;
-        BOOST_CHECK(&(r = r) == &r);
-        BOOST_CHECK(r.empty());
-        BOOST_CHECK(&(r = a) == &r);
-        BOOST_CHECK(equivalent(r));
-        BOOST_CHECK(&(r = r) == &r);
-        BOOST_CHECK(equivalent(r));
+        BOOST_TEST(&(r = r) == &r);
+
+        BOOST_TEST(r.empty());
+        BOOST_TEST(&(r = a) == &r);
+        BOOST_TEST(equivalent(r));
+        BOOST_TEST(&(r = r) == &r);
+        BOOST_TEST(equivalent(r));
     }
 
     {
-        BOOST_CHECK(a.size() ==
-                (BOOST_DEDUCED_TYPENAME X::size_type) std::distance(a.begin(), a.end()));
+        BOOST_TEST(a.size() ==
+            static_cast<BOOST_DEDUCED_TYPENAME X::size_type>(
+                std::distance(a.begin(), a.end())));
     }
 
     {
-        BOOST_CHECK(a.empty() == (a.size() == 0));
+        BOOST_TEST(a.empty() == (a.size() == 0));
     }
 
     {
-        BOOST_CHECK(a.empty() == (a.begin() == a.end()));
+        BOOST_TEST(a.empty() == (a.begin() == a.end()));
         X u;
-        BOOST_CHECK(u.begin() == u.end());
+        BOOST_TEST(u.begin() == u.end());
     }
 }
 
@@ -91,7 +95,7 @@ UNORDERED_AUTO_TEST(simple_tests)
     std::cout<<"Test unordered_set.\n";
     boost::unordered_set<int> set;
     simple_test(set);
-    
+
     set.insert(1); set.insert(2); set.insert(1456);
     simple_test(set);
 

test/unordered/swap_tests.cpp

@@ -1,8 +1,10 @@
 
-// Copyright 2006-2008 Daniel James.
+// Copyright 2006-2009 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)
 
+#include "../helpers/prefix.hpp"
+
 #include <boost/config.hpp>
 #include <algorithm>
 #include <iterator>
@@ -10,10 +12,15 @@
 #include <boost/unordered_map.hpp>
 #include "../helpers/test.hpp"
 #include "../objects/test.hpp"
+#include "../objects/cxx11_allocator.hpp"
 #include "../helpers/random_values.hpp"
 #include "../helpers/tracker.hpp"
 #include "../helpers/invariants.hpp"
 
+#if defined(BOOST_MSVC)
+#pragma warning(disable:4127) // conditional expression is constant
+#endif
+
 namespace swap_tests
 {
 
@@ -35,16 +42,22 @@ template <class X>
 void swap_tests1(X*, test::random_generator generator = test::default_generator)
 {
     {
+        test::check_instances check_;
+
         X x;
         swap_test_impl(x, x);
     }
 
     {
+        test::check_instances check_;
+
         X x,y;
         swap_test_impl(x, y);
     }
 
     {
+        test::check_instances check_;
+
         test::random_values<X> v(1000, generator);
         X x, y(v.begin(), v.end());
         swap_test_impl(x, y);
@@ -52,6 +65,8 @@ void swap_tests1(X*, test::random_generator generator = test::default_generator)
     }
 
     {
+        test::check_instances check_;
+
         test::random_values<X> vx(1000, generator), vy(1000, generator);
         X x(vx.begin(), vx.end()), y(vy.begin(), vy.end());
         swap_test_impl(x, y);
@@ -60,7 +75,8 @@ void swap_tests1(X*, test::random_generator generator = test::default_generator)
 }
 
 template <class X>
-void swap_tests2(X* ptr = 0, test::random_generator generator = test::default_generator)
+void swap_tests2(X* ptr = 0,
+    test::random_generator generator = test::default_generator)
 {
     swap_tests1(ptr);
 
@@ -69,12 +85,16 @@ void swap_tests2(X* ptr = 0, test::random_generator generator = test::default_ge
     typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
 
     {
+        test::check_instances check_;
+
         X x(0, hasher(1), key_equal(1));
         X y(0, hasher(2), key_equal(2));
         swap_test_impl(x, y);
     }
 
     {
+        test::check_instances check_;
+
         test::random_values<X> v(1000, generator);
         X x(v.begin(), v.end(), 0, hasher(1), key_equal(1));
         X y(0, hasher(2), key_equal(2));
@@ -82,6 +102,8 @@ void swap_tests2(X* ptr = 0, test::random_generator generator = test::default_ge
     }
 
     {
+        test::check_instances check_;
+
         test::random_values<X> vx(100, generator), vy(50, generator);
         X x(vx.begin(), vx.end(), 0, hasher(1), key_equal(1));
         X y(vy.begin(), vy.end(), 0, hasher(2), key_equal(2));
@@ -89,46 +111,113 @@ void swap_tests2(X* ptr = 0, test::random_generator generator = test::default_ge
         swap_test_impl(x, y);
     }
 
-#if BOOST_UNORDERED_SWAP_METHOD == 1
-    {
-        test::random_values<X> vx(100, generator), vy(50, generator);
-        X x(vx.begin(), vx.end(), 0, hasher(), key_equal(), allocator_type(1));
-        X y(vy.begin(), vy.end(), 0, hasher(), key_equal(), allocator_type(2));
-        try {
-            swap_test_impl(x, y);
-            BOOST_ERROR("Using swap method 1, swapping with unequal allocators didn't throw.");
-        } catch (std::runtime_error) {}
-    }
-#else
     {
+        test::force_equal_allocator force_(
+            !allocator_type::is_propagate_on_swap);
+        test::check_instances check_;
+
         test::random_values<X> vx(50, generator), vy(100, generator);
         X x(vx.begin(), vx.end(), 0, hasher(), key_equal(), allocator_type(1));
         X y(vy.begin(), vy.end(), 0, hasher(), key_equal(), allocator_type(2));
-        swap_test_impl(x, y);
+
+        if (allocator_type::is_propagate_on_swap ||
+            x.get_allocator() == y.get_allocator())
+        {
+            swap_test_impl(x, y);
+        }
     }
 
     {
+        test::force_equal_allocator force_(
+            !allocator_type::is_propagate_on_swap);
+        test::check_instances check_;
+
         test::random_values<X> vx(100, generator), vy(100, generator);
-        X x(vx.begin(), vx.end(), 0, hasher(1), key_equal(1), allocator_type(1));
-        X y(vy.begin(), vy.end(), 0, hasher(2), key_equal(2), allocator_type(2));
-        swap_test_impl(x, y);
-        swap_test_impl(x, y);
+        X x(vx.begin(), vx.end(), 0, hasher(1), key_equal(1),
+            allocator_type(1));
+        X y(vy.begin(), vy.end(), 0, hasher(2), key_equal(2),
+            allocator_type(2));
+
+        if (allocator_type::is_propagate_on_swap ||
+            x.get_allocator() == y.get_allocator())
+        {
+            swap_test_impl(x, y);
+            swap_test_impl(x, y);
+        }
     }
-#endif
 }
 
-boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_set;
-boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multiset;
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_map;
-boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multimap;
+boost::unordered_set<test::object,
+        test::hash, test::equal_to,
+        test::allocator<test::object> >* test_set;
+boost::unordered_multiset<test::object,
+        test::hash, test::equal_to,
+        test::allocator<test::object> >* test_multiset;
+boost::unordered_map<test::object, test::object,
+        test::hash, test::equal_to,
+        test::allocator<test::object> >* test_map;
+boost::unordered_multimap<test::object, test::object,
+        test::hash, test::equal_to,
+        test::allocator<test::object> >* test_multimap;
 
-UNORDERED_TEST(swap_tests1,
-    ((test_set)(test_multiset)(test_map)(test_multimap))
-)
+boost::unordered_set<test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::propagate_swap> >*
+    test_set_prop_swap;
+boost::unordered_multiset<test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::propagate_swap> >*
+    test_multiset_prop_swap;
+boost::unordered_map<test::object, test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::propagate_swap> >*
+    test_map_prop_swap;
+boost::unordered_multimap<test::object, test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::propagate_swap> >*
+    test_multimap_prop_swap;
 
-UNORDERED_TEST(swap_tests2,
-    ((test_set)(test_multiset)(test_map)(test_multimap))
-)
+boost::unordered_set<test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::no_propagate_swap> >*
+    test_set_no_prop_swap;
+boost::unordered_multiset<test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::no_propagate_swap> >*
+    test_multiset_no_prop_swap;
+boost::unordered_map<test::object, test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::no_propagate_swap> >*
+    test_map_no_prop_swap;
+boost::unordered_multimap<test::object, test::object,
+        test::hash, test::equal_to,
+        test::cxx11_allocator<test::object, test::no_propagate_swap> >*
+    test_multimap_no_prop_swap;
+
+template <typename T>
+bool is_propagate(T*)
+{
+    return T::allocator_type::is_propagate_on_swap;
+}
+
+UNORDERED_AUTO_TEST(check_traits)
+{
+    BOOST_TEST(!is_propagate(test_set));
+    BOOST_TEST(is_propagate(test_set_prop_swap));
+    BOOST_TEST(!is_propagate(test_set_no_prop_swap));
+}
+
+UNORDERED_TEST(swap_tests1, (
+    (test_set)(test_multiset)(test_map)(test_multimap)
+    (test_set_prop_swap)(test_multiset_prop_swap)(test_map_prop_swap)(test_multimap_prop_swap)
+    (test_set_no_prop_swap)(test_multiset_no_prop_swap)(test_map_no_prop_swap)(test_multimap_no_prop_swap)
+))
+
+UNORDERED_TEST(swap_tests2, (
+    (test_set)(test_multiset)(test_map)(test_multimap)
+    (test_set_prop_swap)(test_multiset_prop_swap)(test_map_prop_swap)(test_multimap_prop_swap)
+    (test_set_no_prop_swap)(test_multiset_no_prop_swap)(test_map_no_prop_swap)(test_multimap_no_prop_swap)
+))
 
 }
 RUN_TESTS()

test/unordered/unnecessary_copy_tests.cpp

@@ -1,16 +1,38 @@
-
-// Copyright 2006-2008 Daniel James.
+#include <iostream>
+// Copyright 2006-2009 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)
 
+#include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
 #include "../helpers/test.hpp"
 
+#if defined(BOOST_UNORDERED_VARIADIC_MOVE)
+#   if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
+#   elif defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)
+#   elif defined(_LIBCPP_VERSION)
+#       define BOOST_UNORDERED_VARIADIC_MOVE
+#   elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
+#       if defined(__GLIBCXX__) && __GLIBCXX__ >= 20090804
+#           define BOOST_UNORDERED_VARIADIC_MOVE
+#       endif
+#    elif defined(__STL_CONFIG_H)
+#    elif defined(__MSL_CPP__)
+#    elif defined(__IBMCPP__)
+#    elif defined(MSIPL_COMPILE_H)
+#    elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER)
+#   endif
+#endif
+
 namespace unnecessary_copy_tests
 {
     struct count_copies
     {
+    private:
+        BOOST_COPYABLE_AND_MOVABLE(count_copies)
+    public:
         static int copies;
         static int moves;
         count_copies() : tag_(0) { ++copies; }
@@ -29,14 +51,25 @@ namespace unnecessary_copy_tests
             : tag_(x.tag_) { ++copies; }
 
         count_copies(count_copies const& x) : tag_(x.tag_) { ++copies; }
-#if defined(BOOST_HAS_RVALUE_REFS)
-        count_copies(count_copies&& x) : tag_(x.tag_) {
+        count_copies(BOOST_RV_REF(count_copies) x) : tag_(x.tag_) {
             x.tag_ = -1; ++moves;
         }
-#endif
-       int tag_;
-    private:
-       count_copies& operator=(count_copies const&);
+
+        count_copies& operator=(BOOST_COPY_ASSIGN_REF(count_copies) p) // Copy assignment
+        {
+            tag_ = p.tag_;
+            ++copies;
+            return *this;
+        }
+
+        count_copies& operator=(BOOST_RV_REF(count_copies) p) //Move assignment
+        {
+            tag_ = p.tag_;
+            ++moves;
+            return *this;
+        }
+
+        int tag_;
     };
 
     bool operator==(count_copies const& x, count_copies const& y) {
@@ -65,15 +98,39 @@ namespace unnecessary_copy_tests
     }
 }
 
-#define COPY_COUNT(n) \
-    if(count_copies::copies != n) { \
-        BOOST_ERROR("Wrong number of copies."); \
-        std::cerr<<"Number of copies: "<<count_copies::copies<<std::endl; \
+#define COPY_COUNT(n)                                                       \
+    if(::unnecessary_copy_tests::count_copies::copies != n) {               \
+        BOOST_ERROR("Wrong number of copies.");                             \
+        std::cerr                                                           \
+            << "Number of copies: "                                         \
+            << ::unnecessary_copy_tests::count_copies::copies               \
+            << " expecting: " << n << std::endl;                            \
     }
-#define MOVE_COUNT(n) \
-    if(count_copies::moves != n) { \
-        BOOST_ERROR("Wrong number of moves."); \
-        std::cerr<<"Number of moves: "<<count_copies::moves<<std::endl; \
+#define MOVE_COUNT(n)                                                       \
+    if(::unnecessary_copy_tests::count_copies::moves != n) {                \
+        BOOST_ERROR("Wrong number of moves.");                              \
+        std::cerr                                                           \
+            << "Number of moves: "                                          \
+            << ::unnecessary_copy_tests::count_copies::moves                \
+            << " expecting: " <<n << std::endl;                             \
+    }
+#define COPY_COUNT_RANGE(a, b)                                              \
+    if(::unnecessary_copy_tests::count_copies::copies < a ||                \
+            ::unnecessary_copy_tests::count_copies::copies > b) {           \
+        BOOST_ERROR("Wrong number of copies.");                             \
+        std::cerr                                                           \
+            << "Number of copies: "                                         \
+            << ::unnecessary_copy_tests::count_copies::copies               \
+            << " expecting: [" << a << ", " << b << "]" << std::endl;       \
+    }
+#define MOVE_COUNT_RANGE(a, b)                                              \
+    if(::unnecessary_copy_tests::count_copies::moves < a ||                 \
+            ::unnecessary_copy_tests::count_copies::moves > b) {            \
+        BOOST_ERROR("Wrong number of moves.");                              \
+        std::cerr                                                           \
+            << "Number of moves: "                                          \
+            << ::unnecessary_copy_tests::count_copies::copies               \
+            << " expecting: [" << a << ", " << b << "]" << std::endl;       \
     }
 
 namespace unnecessary_copy_tests
@@ -99,7 +156,6 @@ namespace unnecessary_copy_tests
     UNORDERED_TEST(unnecessary_copy_insert_test,
             ((set)(multiset)(map)(multimap)))
 
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
     template <class T>
     void unnecessary_copy_emplace_test(T*)
     {
@@ -117,9 +173,19 @@ namespace unnecessary_copy_tests
         reset();
         T x;
         x.emplace(source<BOOST_DEDUCED_TYPENAME T::value_type>());
+#if !defined(BOOST_NO_RVALUE_REFERENCES)
         COPY_COUNT(1);
+#else
+        COPY_COUNT(2);
+#endif
     }
 
+    UNORDERED_TEST(unnecessary_copy_emplace_test,
+            ((set)(multiset)(map)(multimap)))
+    UNORDERED_TEST(unnecessary_copy_emplace_rvalue_test,
+            ((set)(multiset)(map)(multimap)))
+
+#if defined(BOOST_UNORDERED_STD_FORWARD_MOVE)
     template <class T>
     void unnecessary_copy_emplace_move_test(T*)
     {
@@ -131,15 +197,54 @@ namespace unnecessary_copy_tests
         COPY_COUNT(1); MOVE_COUNT(1);
     }
 
-    UNORDERED_TEST(unnecessary_copy_emplace_test,
-            ((set)(multiset)(map)(multimap)))
-    UNORDERED_TEST(unnecessary_copy_emplace_rvalue_test,
-            ((set)(multiset)(map)(multimap)))
     UNORDERED_TEST(unnecessary_copy_emplace_move_test,
             ((set)(multiset)(map)(multimap)))
+#endif
+
+    template <class T>
+    void unnecessary_copy_emplace_boost_move_set_test(T*)
+    {
+        reset();
+        T x;
+        BOOST_DEDUCED_TYPENAME T::value_type a;
+        COPY_COUNT(1); MOVE_COUNT(0);
+        x.emplace(boost::move(a));
+        COPY_COUNT(1); MOVE_COUNT(1);
+    }
+
+    UNORDERED_TEST(unnecessary_copy_emplace_boost_move_set_test,
+            ((set)(multiset)))
+
+    template <class T>
+    void unnecessary_copy_emplace_boost_move_map_test(T*)
+    {
+        reset();
+        T x;
+        COPY_COUNT(0); MOVE_COUNT(0);
+        BOOST_DEDUCED_TYPENAME T::value_type a;
+        COPY_COUNT(1); MOVE_COUNT(0);
+        x.emplace(boost::move(a));
+#if defined(BOOST_NO_RVALUE_REFERENCES)
+        COPY_COUNT(2); MOVE_COUNT(0);
+#else
+        COPY_COUNT(1); MOVE_COUNT(1);
+#endif
+    }
+
+    UNORDERED_TEST(unnecessary_copy_emplace_boost_move_map_test,
+            ((map)(multimap)))
 
     UNORDERED_AUTO_TEST(unnecessary_copy_emplace_set_test)
     {
+        // When calling 'source' the object is moved on some compilers, but not
+        // others. So count that here to adjust later.
+
+        reset();
+        source<count_copies>();
+        int source_cost = ::unnecessary_copy_tests::count_copies::moves;
+
+        //
+
         reset();
         boost::unordered_set<count_copies> x;
         count_copies a;
@@ -150,11 +255,18 @@ namespace unnecessary_copy_tests
         // 0 arguments
         // 
 
+#if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x5100))
         // The container will have to create a copy in order to compare with
         // the existing element.
         reset();
         x.emplace();
-        COPY_COUNT(1); MOVE_COUNT(0);
+#if !defined(BOOST_NO_RVALUE_REFERENCES)
+        // source_cost doesn't make much sense here, but it seems to fit.
+        COPY_COUNT(1); MOVE_COUNT(source_cost);
+#else
+        COPY_COUNT(1); MOVE_COUNT(1 + source_cost);
+#endif
+#endif
 
         //
         // 1 argument
@@ -170,12 +282,14 @@ namespace unnecessary_copy_tests
         // copied.
         reset();
         x.emplace(source<count_copies>());
-        COPY_COUNT(1); MOVE_COUNT(0);
+        COPY_COUNT(1); MOVE_COUNT(source_cost);
 
+#if defined(BOOST_UNORDERED_STD_FORWARD_MOVE)
         // No move should take place.
         reset();
         x.emplace(std::move(a));
         COPY_COUNT(0); MOVE_COUNT(0);
+#endif
 
         // Just in case a did get moved...
         count_copies b;
@@ -192,14 +306,31 @@ namespace unnecessary_copy_tests
 
         // The container will have to create b copy in order to compare with
         // the existing element.
+        //
+        // Note to self: If copy_count == 0 it's an error not an optimization.
+        // TODO: Devise a better test.
 
         reset();
+
         x.emplace(b, b);
         COPY_COUNT(1); MOVE_COUNT(0);
     }
 
     UNORDERED_AUTO_TEST(unnecessary_copy_emplace_map_test)
     {
+        // When calling 'source' the object is moved on some compilers, but not
+        // others. So count that here to adjust later.
+
+        reset();
+        source<count_copies>();
+        int source_cost = ::unnecessary_copy_tests::count_copies::moves;
+
+        reset();
+        source<std::pair<count_copies, count_copies> >();
+        int source_pair_cost = ::unnecessary_copy_tests::count_copies::moves;
+
+        //
+
         reset();
         boost::unordered_map<count_copies, count_copies> x;
         // TODO: Run tests for pairs without const etc.
@@ -211,10 +342,19 @@ namespace unnecessary_copy_tests
         // 0 arguments
         //
 
+#if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x5100))
         // COPY_COUNT(1) would be okay here.
         reset();
         x.emplace();
         COPY_COUNT(2); MOVE_COUNT(0);
+#endif
+
+        reset();
+        x.emplace(boost::unordered::piecewise_construct,
+                boost::make_tuple(),
+                boost::make_tuple());
+        COPY_COUNT(2); MOVE_COUNT(0);
+
 
         //
         // 1 argument
@@ -228,49 +368,93 @@ namespace unnecessary_copy_tests
         // copied.
         reset();
         x.emplace(source<std::pair<count_copies, count_copies> >());
-        COPY_COUNT(2); MOVE_COUNT(0);
+        COPY_COUNT(2); MOVE_COUNT(source_pair_cost);
 
+#if (defined(__GNUC__) && __GNUC__ > 4) || \
+    (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ > 2) || \
+    (defined(BOOST_MSVC) && BOOST_MSVC >= 1600 )
         count_copies part;
         reset();
         std::pair<count_copies const&, count_copies const&> a_ref(part, part);
         x.emplace(a_ref);
-        COPY_COUNT(0); MOVE_COUNT(0);
+        COPY_COUNT(2); MOVE_COUNT(0);
+
+#endif
+
+#if defined(BOOST_UNORDERED_STD_FORWARD_MOVE)
 
         // No move should take place.
+        // (since a is already in the container)
         reset();
         x.emplace(std::move(a));
         COPY_COUNT(0); MOVE_COUNT(0);
 
-        // Just in case a did get moved
-        std::pair<count_copies const, count_copies> b;
-
-        // This test requires a C++0x std::pair. Which gcc hasn't got yet.
-        //reset();
-        //x.emplace(b.first.tag_);
-        //COPY_COUNT(2); MOVE_COUNT(0);
+#endif
 
         //
         // 2 arguments
         //
 
+        std::pair<count_copies const, count_copies> b;
+
         reset();
         x.emplace(b.first, b.second);
         COPY_COUNT(0); MOVE_COUNT(0);
 
         reset();
         x.emplace(source<count_copies>(), source<count_copies>());
-        COPY_COUNT(2); MOVE_COUNT(0);
+        COPY_COUNT(2); MOVE_COUNT(source_cost * 2);
 
         // source<count_copies> creates a single copy.
         reset();
         x.emplace(b.first, source<count_copies>());
-        COPY_COUNT(1); MOVE_COUNT(0);
+        COPY_COUNT(1); MOVE_COUNT(source_cost);
 
         reset();
-        x.emplace(b.first.tag_, b.second.tag_);
-        COPY_COUNT(2); MOVE_COUNT(0);
-    }
+        x.emplace(count_copies(b.first.tag_), count_copies(b.second.tag_));
+        COPY_COUNT(2); MOVE_COUNT(0);        
+
+        reset();
+        x.emplace(boost::unordered::piecewise_construct,
+                boost::make_tuple(boost::ref(b.first)),
+                boost::make_tuple(boost::ref(b.second)));
+        COPY_COUNT(0); MOVE_COUNT(0);
+        
+#if !defined(BOOST_NO_0X_HDR_TUPLE) || defined(BOOST_HAS_TR1_TUPLE)
+
+        reset();
+        x.emplace(boost::unordered::piecewise_construct,
+                std::make_tuple(std::ref(b.first)),
+                std::make_tuple(std::ref(b.second)));
+        COPY_COUNT(0); MOVE_COUNT(0);
+
+        std::pair<count_copies const, count_copies> move_source_trial;
+        reset();
+        std::make_tuple(std::move(move_source_trial.first));
+        std::make_tuple(std::move(move_source_trial.second));
+        int tuple_move_cost = ::unnecessary_copy_tests::count_copies::moves;
+        int tuple_copy_cost = ::unnecessary_copy_tests::count_copies::copies;
+
+        std::pair<count_copies const, count_copies> move_source;
+        reset();
+        x.emplace(boost::unordered::piecewise_construct,
+                std::make_tuple(std::move(move_source.first)),
+                std::make_tuple(std::move(move_source.second)));
+        COPY_COUNT(tuple_copy_cost);
+        MOVE_COUNT(tuple_move_cost);
+
+#if defined(__GNUC__) && __GNUC__ > 4 || \
+    defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ >= 6
+        reset();
+        x.emplace(boost::unordered::piecewise_construct,
+                std::forward_as_tuple(b.first),
+                std::forward_as_tuple(b.second));
+        COPY_COUNT(0); MOVE_COUNT(0);
 #endif
+
+#endif
+
+    }
 }
 
 RUN_TESTS()