Release 1.49.0

[SVN r77094]

doc/Jamfile.v2

@@ -3,6 +3,9 @@
 # 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 ;
 

doc/buckets.qbk

@@ -112,7 +112,7 @@ 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]]
 
     [

doc/changes.qbk

@@ -134,4 +134,45 @@ First official release.
 * 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

@@ -67,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/2009/n2960.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

@@ -44,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)
@@ -63,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]
 
@@ -90,52 +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 implemented
-fairly efficiently. They are specified differently to the other standard
-containers, comparing keys using the equality predicate rather than
-`operator==`.
-
-It's also different to the proposal
-[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2944.pdf n2944].
-which uses the equality operators for the whole of `value_type`. This
-implementation just uses the key equality function for the key,
-and `mapped_type`'s equality operator in `unordered_map` and
-`unordered_multimap` for the mapped part of the element.
-
-Also, in `unordered_multimap`, the mapped values for a group of elements with
-equivalent keys are only considered equal if they are in the same order,
-in n2944 they just need to be a permutation of each other. Since the
-order of elements with equal keys is now defined to be stable, it seems to me
-that their order can be considered part of the container's value.
-
-[h2 Active Issues and Proposals]
-
-[h3 C++0x allocators]
-
-Recent drafts have included an overhaul of the allocators, but this was
-dependent on concepts which are no longer in the standard.
-[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2946.pdf n2946]
-attempts to respecify them without concepts. I'll try to implement this (or
-an appropriate later version) in a future version of boost, possibly changed
-a little to accomodate non-C++0x compilers.
-
-[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]. This has been resolved
-with the new allocator specification, so this should be fixed when
-support is added.
-
-[h3 Are insert and erase stable for unordered_multiset and unordered_multimap?]
-
-It wan't 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`).
-Since [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2691.pdf
-n2691] it's been specified that they do and this implementation follows that.
-
 [endsect]

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]
@@ -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]

include/boost/unordered/detail/allocator_helpers.hpp

@@ -1,9 +1,12 @@
 
-// Copyright 2005-2009 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)
-
-// A couple of templates to make using allocators easier.
+//
+// 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
@@ -13,77 +16,491 @@
 #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
 
-namespace boost { namespace unordered_detail {
+#if !defined(BOOST_NO_0X_HDR_TYPE_TRAITS)
+#  include <type_traits>
+#endif
 
-    // rebind_wrap
+namespace boost { namespace unordered { namespace detail {
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Integral_constrant, true_type, false_type
     //
-    // Rebind allocators. For some problematic libraries, use rebind_to
-    // from <boost/detail/allocator_utilities.hpp>.
+    // 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>
+
+    template <typename T, T Value>
+    struct integral_constant { enum { value = Value }; };
+
+    typedef boost::unordered::detail::integral_constant<bool, true> true_type;
+    typedef boost::unordered::detail::integral_constant<bool, false> false_type;
+
+#endif
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Explicitly call a destructor
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+#pragma warning(disable:4100) // unreferenced formal parameter
+#endif
+
+    template <class T>
+    inline void destroy(T* x) {
+        x->~T();
+    }
+
+#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 BOOST_DEDUCED_TYPENAME
-            Alloc::BOOST_NESTED_TEMPLATE rebind<T>::other
+        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
 
-    // allocator_array_constructor
+    #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 <class Allocator>
-    struct allocator_array_constructor
+    template <typename Allocator>
+    struct array_constructor
     {
-        typedef BOOST_DEDUCED_TYPENAME Allocator::pointer pointer;
+        typedef boost::unordered::detail::allocator_traits<Allocator> traits;
+        typedef typename traits::pointer pointer;
 
         Allocator& alloc_;
         pointer ptr_;
         pointer constructed_;
         std::size_t length_;
 
-        allocator_array_constructor(Allocator& a)
+        array_constructor(Allocator& a)
             : alloc_(a), ptr_(), constructed_(), length_(0)
         {
             constructed_ = pointer();
             ptr_ = pointer();
         }
 
-        ~allocator_array_constructor() {
+        ~array_constructor() {
             if (ptr_) {
                 for(pointer p = ptr_; p != constructed_; ++p)
-                    alloc_.destroy(p);
+                    traits::destroy(alloc_, boost::addressof(*p));
 
-                alloc_.deallocate(ptr_, length_);
+                traits::deallocate(alloc_, ptr_, length_);
             }
         }
 
-        template <class V>
+        template <typename V>
         void construct(V const& v, std::size_t l)
         {
             BOOST_ASSERT(!ptr_);
             length_ = l;
-            ptr_ = alloc_.allocate(length_);
+            ptr_ = traits::allocate(alloc_, length_);
             pointer end = ptr_ + static_cast<std::ptrdiff_t>(length_);
             for(constructed_ = ptr_; constructed_ != end; ++constructed_)
-                alloc_.construct(constructed_, v);
+                traits::construct(alloc_, boost::addressof(*constructed_), v);
         }
 
         pointer get() const
@@ -98,14 +515,9 @@ namespace boost { namespace unordered_detail {
             return p;
         }
     private:
-        allocator_array_constructor(allocator_array_constructor const&);
-        allocator_array_constructor& operator=(
-            allocator_array_constructor const&);
+        array_constructor(array_constructor const&);
+        array_constructor& operator=(array_constructor const&);
     };
-}}
-
-#if defined(BOOST_UNORDERED_USE_ALLOCATOR_UTILITIES)
-#  undef BOOST_UNORDERED_USE_ALLOCATOR_UTILITIES
-#endif
+}}}
 
 #endif

include/boost/unordered/detail/buckets.hpp

@@ -1,183 +1,667 @@
 
 // Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
-// Copyright (C) 2005-2009 Daniel James
+// 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
 
-#include <boost/config.hpp>
-#include <boost/assert.hpp>
-#include <boost/unordered/detail/node.hpp>
+#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>
 
-namespace boost { namespace unordered_detail {
+#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 <class A, class G>
-    inline std::size_t hash_buckets<A, G>::max_bucket_count() const {
-        // -1 to account for the sentinel.
-        return prev_prime(this->bucket_alloc().max_size() - 1);
-    }
 
-    template <class A, class G>
-    inline BOOST_DEDUCED_TYPENAME hash_buckets<A, G>::bucket_ptr
-        hash_buckets<A, G>::get_bucket(std::size_t num) const
+    template <typename A, typename Bucket, typename Node>
+    struct buckets
     {
-        return buckets_ + static_cast<std::ptrdiff_t>(num);
-    }
+    private:
+        buckets(buckets const&);
+        buckets& operator=(buckets const&);
+    public:
+        typedef boost::unordered::detail::allocator_traits<A> traits;
+        typedef typename traits::value_type value_type;
 
-    template <class A, class G>
-    inline BOOST_DEDUCED_TYPENAME hash_buckets<A, G>::bucket_ptr
-        hash_buckets<A, G>::bucket_ptr_from_hash(std::size_t hashed) const
-    {
-        return get_bucket(hashed % bucket_count_);
-    }
-    
-    template <class A, class G>
-    std::size_t hash_buckets<A, G>::bucket_size(std::size_t index) const
-    {
-        if(!buckets_) return 0;
-        bucket_ptr ptr = get_bucket(index)->next_;
-        std::size_t count = 0;
-        while(ptr) {
-            ++count;
-            ptr = ptr->next_;
+        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();
         }
-        return count;
-    }
 
-    template <class A, class G>
-    inline BOOST_DEDUCED_TYPENAME hash_buckets<A, G>::node_ptr
-        hash_buckets<A, G>::bucket_begin(std::size_t num) const
-    {
-        return buckets_ ? get_bucket(num)->next_ : node_ptr();
-    }
+        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;
+            }
+        }
+    };
 
     ////////////////////////////////////////////////////////////////////////////
-    // Delete
+    // Functions
 
-    template <class A, class G>
-    inline void hash_buckets<A, G>::delete_node(node_ptr b)
+    // 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
     {
-        node* raw_ptr = static_cast<node*>(&*b);
-        boost::unordered_detail::destroy(&raw_ptr->value());
-        real_node_ptr n(node_alloc().address(*raw_ptr));
-        node_alloc().destroy(n);
-        node_alloc().deallocate(n, 1);
-    }
+        friend class boost::unordered::detail::set_hash_functions<H, P>;
+        functions& operator=(functions const&);
 
-    template <class A, class G>
-    inline void hash_buckets<A, G>::clear_bucket(bucket_ptr b)
-    {
-        node_ptr node_it = b->next_;
-        b->next_ = node_ptr();
+        typedef compressed<H, P> function_pair;
 
-        while(node_it) {
-            node_ptr node_to_delete = node_it;
-            node_it = node_it->next_;
-            delete_node(node_to_delete);
-        }
-    }
+        typedef typename boost::aligned_storage<
+            sizeof(function_pair),
+            boost::alignment_of<function_pair>::value>::type aligned_function;
 
-    template <class A, class G>
-    inline void hash_buckets<A, G>::delete_buckets()
-    {      
-        bucket_ptr end = this->get_bucket(this->bucket_count_);
+        bool current_; // The currently active functions.
+        aligned_function funcs_[2];
 
-        for(bucket_ptr begin = this->buckets_; begin != end; ++begin) {
-            clear_bucket(begin);
+        function_pair const& current() const {
+            return *static_cast<function_pair const*>(
+                static_cast<void const*>(&funcs_[current_]));
         }
 
-        // Destroy the buckets (including the sentinel bucket).
-        ++end;
-        for(bucket_ptr begin = this->buckets_; begin != end; ++begin) {
-            bucket_alloc().destroy(begin);
+        void construct(bool which, H const& hf, P const& eq)
+        {
+            new((void*) &funcs_[which]) function_pair(hf, eq);
         }
 
-        bucket_alloc().deallocate(this->buckets_, this->bucket_count_ + 1);
-
-        this->buckets_ = bucket_ptr();
-    }
-
-    template <class A, class G>
-    inline std::size_t hash_buckets<A, G>::delete_nodes(
-        node_ptr begin, node_ptr end)
-    {
-        std::size_t count = 0;
-        while(begin != end) {
-            node_ptr n = begin;
-            begin = begin->next_;
-            delete_node(n);
-            ++count;
+        void construct(bool which, function_pair const& f)
+        {
+            new((void*) &funcs_[which]) function_pair(f);
         }
-        return count;
-    }
+        
+        void destroy(bool which)
+        {
+            boost::unordered::detail::destroy((function_pair*)(&funcs_[which]));
+        }
+        
+    public:
 
-    ////////////////////////////////////////////////////////////////////////////
-    // Constructors and Destructors
+        functions(H const& hf, P const& eq)
+            : current_(false)
+        {
+            construct(current_, hf, eq);
+        }
 
-    template <class A, class G>
-    inline hash_buckets<A, G>::hash_buckets(
-        node_allocator const& a, std::size_t bucket_count)
-      : buckets_(),
-        bucket_count_(bucket_count),
-        allocators_(a,a)
-    {
-    }
+        functions(functions const& bf)
+            : current_(false)
+        {
+            construct(current_, bf.current());
+        }
 
-    template <class A, class G>
-    inline hash_buckets<A, G>::~hash_buckets()
-    {
-        if(this->buckets_) { this->delete_buckets(); }
-    }
+        ~functions() {
+            this->destroy(current_);
+        }
+
+        H const& hash_function() const {
+            return current().first();
+        }
+
+        P const& key_eq() const {
+            return current().second();
+        }
+    };
     
-    template <class A, class G>
-    inline void hash_buckets<A, G>::create_buckets()
+    template <class H, class P>
+    class set_hash_functions
     {
-        // The array constructor will clean up in the event of an
-        // exception.
-        allocator_array_constructor<bucket_allocator>
-            constructor(bucket_alloc());
+        set_hash_functions(set_hash_functions const&);
+        set_hash_functions& operator=(set_hash_functions const&);
+    
+        functions<H,P>& functions_;
+        bool tmp_functions_;
 
-        // Creates an extra bucket to act as a sentinel.
-        constructor.construct(bucket(), this->bucket_count_ + 1);
+    public:
 
-        // Set up the sentinel (node_ptr cast)
-        bucket_ptr sentinel = constructor.get() +
-            static_cast<std::ptrdiff_t>(this->bucket_count_);
-        sentinel->next_ = sentinel;
+        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);
+        }
 
-        // Only release the buckets once everything is successfully
-        // done.
-        this->buckets_ = constructor.release();
-    }
+        set_hash_functions(functions<H,P>& f, functions<H,P> const& other)
+          : functions_(f),
+            tmp_functions_(!f.current_)
+        {
+            f.construct(tmp_functions_, other.current());
+        }
 
-    ////////////////////////////////////////////////////////////////////////////
-    // Constructors and Destructors
+        ~set_hash_functions()
+        {
+            functions_.destroy(tmp_functions_);
+        }
 
-    // no throw
-    template <class A, class G>
-    inline void hash_buckets<A, G>::move(hash_buckets& other)
-    {
-        BOOST_ASSERT(node_alloc() == other.node_alloc());
-        if(this->buckets_) { this->delete_buckets(); }
-        this->buckets_ = other.buckets_;
-        this->bucket_count_ = other.bucket_count_;
-        other.buckets_ = bucket_ptr();
-        other.bucket_count_ = 0;
-    }
+        void commit()
+        {
+            functions_.current_ = tmp_functions_;
+            tmp_functions_ = !tmp_functions_;
+        }
+    };
+}}}
 
-    template <class A, class G>
-    inline void hash_buckets<A, G>::swap(hash_buckets<A, G>& other)
-    {
-        BOOST_ASSERT(node_alloc() == other.node_alloc());
-        std::swap(buckets_, other.buckets_);
-        std::swap(bucket_count_, other.bucket_count_);
-    }
-}}
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#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/extract_key.hpp

@@ -1,17 +1,16 @@
 
-// Copyright (C) 2005-2009 Daniel James
+// 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/config.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/unordered/detail/fwd.hpp>
+#include <boost/unordered/detail/table.hpp>
 
 namespace boost {
-namespace unordered_detail {
+namespace unordered {
+namespace detail {
 
     // key extractors
     //
@@ -28,6 +27,19 @@ namespace unordered_detail {
         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
     {
@@ -44,13 +56,12 @@ namespace unordered_detail {
             return no_key();
         }
         
-#if defined(BOOST_UNORDERED_STD_FORWARD)
+#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&)
@@ -58,8 +69,8 @@ namespace unordered_detail {
             return no_key();
         }
 
-        template <class Arg>
-        static no_key extract(Arg const&, Arg const&)
+        template <class Arg1, class Arg2>
+        static no_key extract(Arg1 const&, Arg2 const&)
         {
             return no_key();
         }
@@ -75,7 +86,7 @@ namespace unordered_detail {
     struct map_extractor
     {
         typedef ValueType value_type;
-        typedef BOOST_DEDUCED_TYPENAME boost::remove_const<Key>::type key_type;
+        typedef typename boost::remove_const<Key>::type key_type;
 
         static key_type const& extract(value_type const& v)
         {
@@ -100,7 +111,7 @@ namespace unordered_detail {
             return v.first;
         }
 
-#if defined(BOOST_UNORDERED_STD_FORWARD)
+#if defined(BOOST_UNORDERED_VARIADIC_MOVE)
         template <class Arg1, class... Args>
         static key_type const& extract(key_type const& k,
             Arg1 const&, Args const&...)
@@ -114,6 +125,7 @@ namespace unordered_detail {
             return no_key();
         }
 #else
+
         template <class Arg1>
         static key_type const& extract(key_type const& k, Arg1 const&)
         {
@@ -138,11 +150,57 @@ namespace unordered_detail {
         }
 #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

@@ -1,856 +1,53 @@
 
-// Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
-// Copyright (C) 2005-2009 Daniel James
+// 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)
 
-// This contains the basic data structure, apart from the actual values. There's
-// no construction or deconstruction here. So this only depends on the pointer
-// type.
+#ifndef BOOST_UNORDERED_FWD_HPP_INCLUDED
+#define BOOST_UNORDERED_FWD_HPP_INCLUDED
 
-#ifndef BOOST_UNORDERED_DETAIL_FWD_HPP_INCLUDED
-#define BOOST_UNORDERED_DETAIL_FWD_HPP_INCLUDED
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
 
 #include <boost/config.hpp>
-#include <boost/iterator.hpp>
-#include <boost/compressed_pair.hpp>
-#include <boost/type_traits/aligned_storage.hpp>
-#include <boost/type_traits/alignment_of.hpp>
-#include <boost/unordered/detail/allocator_helpers.hpp>
-#include <algorithm>
+#include <memory>
+#include <functional>
+#include <boost/functional/hash_fwd.hpp>
 
-// This header defines most of the classes used to implement the unordered
-// containers. It doesn't include the insert methods as they require a lot
-// of preprocessor metaprogramming - they are in insert.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 parameters:
-//
-// H = Hash Function
-// P = Predicate
-// A = Value Allocator
-// G = Grouped/Ungrouped
-// E = Key Extractor
+    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;
 
-#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
-#   if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
-        // STLport doesn't have std::forward.
-#   else
-#       define BOOST_UNORDERED_STD_FORWARD
-#   endif
-#endif
+    template <class T,
+        class H = boost::hash<T>,
+        class P = std::equal_to<T>,
+        class A = std::allocator<T> >
+    class unordered_set;
 
-#if !defined(BOOST_UNORDERED_EMPLACE_LIMIT)
-#define BOOST_UNORDERED_EMPLACE_LIMIT 10
-#endif
+    template <class T,
+        class H = boost::hash<T>,
+        class P = std::equal_to<T>,
+        class A = std::allocator<T> >
+    class unordered_multiset;
 
-#if !defined(BOOST_UNORDERED_STD_FORWARD)
-
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/repetition/repeat_from_to.hpp>
-
-#define BOOST_UNORDERED_TEMPLATE_ARGS(z, num_params) \
-    BOOST_PP_ENUM_PARAMS_Z(z, num_params, class Arg)
-#define BOOST_UNORDERED_FUNCTION_PARAMS(z, num_params) \
-    BOOST_PP_ENUM_BINARY_PARAMS_Z(z, num_params, Arg, const& arg)
-#define BOOST_UNORDERED_CALL_PARAMS(z, num_params) \
-    BOOST_PP_ENUM_PARAMS_Z(z, num_params, arg)
-
-#endif
-
-namespace boost { namespace unordered_detail {
-
-    static const float minimum_max_load_factor = 1e-3f;
-    static const std::size_t default_bucket_count = 11;
-    struct move_tag {};
-
-    template <class T> class hash_unique_table;
-    template <class T> class hash_equivalent_table;
-    template <class Alloc, class Grouped>
-    class hash_node_constructor;
-    template <class ValueType>
-    struct set_extractor;
-    template <class Key, class ValueType>
-    struct map_extractor;
-    struct no_key;
-
-    // Explicitly call a destructor
-
-#if defined(BOOST_MSVC)
-#pragma warning(push)
-#pragma warning(disable:4100) // unreferenced formal parameter
-#endif
-
-    template <class T>
-    inline void destroy(T* x) {
-        x->~T();
-    }
-
-#if defined(BOOST_MSVC)
-#pragma warning(pop)
-#endif
-
-    // hash_bucket
-    
-    template <class A>
-    class hash_bucket
-    {
-        hash_bucket& operator=(hash_bucket const&);
-    public:
-        typedef hash_bucket<A> bucket;
-        typedef BOOST_DEDUCED_TYPENAME
-            boost::unordered_detail::rebind_wrap<A, bucket>::type
-            bucket_allocator;
-        typedef BOOST_DEDUCED_TYPENAME bucket_allocator::pointer bucket_ptr;
-        typedef bucket_ptr node_ptr;
-    
-        node_ptr next_;
-
-        hash_bucket() : next_() {}
-    };
-
-    template <class A>
-    struct ungrouped_node_base : hash_bucket<A> {
-        typedef hash_bucket<A> bucket;
-        typedef BOOST_DEDUCED_TYPENAME bucket::bucket_ptr bucket_ptr;
-        typedef BOOST_DEDUCED_TYPENAME bucket::node_ptr node_ptr;
-
-        ungrouped_node_base() : bucket() {}
-        static inline node_ptr& next_group(node_ptr ptr);
-        static inline std::size_t group_count(node_ptr ptr);
-        static inline void add_to_bucket(node_ptr n, bucket& b);
-        static inline void add_after_node(node_ptr n, node_ptr position);
-        static void unlink_node(bucket& b, node_ptr n);
-        static void unlink_nodes(bucket& b, node_ptr begin, node_ptr end);
-        static void unlink_nodes(bucket& b, node_ptr end);
-    };
-
-    template <class A>
-    struct grouped_node_base : hash_bucket<A>
-    {
-        typedef hash_bucket<A> bucket;
-        typedef BOOST_DEDUCED_TYPENAME bucket::bucket_ptr bucket_ptr;
-        typedef BOOST_DEDUCED_TYPENAME bucket::node_ptr node_ptr;
-
-        node_ptr group_prev_;
-
-        grouped_node_base() : bucket(), group_prev_() {}
-        static inline node_ptr& next_group(node_ptr ptr);
-        static inline node_ptr first_in_group(node_ptr n);
-        static inline std::size_t group_count(node_ptr ptr);
-        static inline void add_to_bucket(node_ptr n, bucket& b);
-        static inline void add_after_node(node_ptr n, node_ptr position);
-        static void unlink_node(bucket& b, node_ptr n);
-        static void unlink_nodes(bucket& b, node_ptr begin, node_ptr end);
-        static void unlink_nodes(bucket& b, node_ptr end);
-
-    private:
-        static inline node_ptr split_group(node_ptr split);
-        static inline grouped_node_base& get(node_ptr ptr) {
-            return static_cast<grouped_node_base&>(*ptr);
-        }
-    };
-
-    struct ungrouped
-    {
-        template <class A>
-        struct base {
-            typedef ungrouped_node_base<A> type;
-        };
-    };
-
-    struct grouped
-    {
-        template <class A>
-        struct base {
-            typedef grouped_node_base<A> type;
-        };
-    };
-
-    template <class ValueType>
-    struct value_base
-    {
-        typedef ValueType value_type;
-        BOOST_DEDUCED_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;
-        }
-    private:
-        value_base& operator=(value_base const&);
-    };
-
-    // Node
-    
-    template <class A, class G>
-    class hash_node :
-        public G::BOOST_NESTED_TEMPLATE base<A>::type,
-        public value_base<BOOST_DEDUCED_TYPENAME A::value_type>
-    {
-    public:
-        typedef BOOST_DEDUCED_TYPENAME A::value_type value_type;
-        typedef BOOST_DEDUCED_TYPENAME hash_bucket<A>::node_ptr node_ptr;
-
-        static value_type& get_value(node_ptr p) {
-            return static_cast<hash_node&>(*p).value();
-        }
-    private:
-        hash_node& operator=(hash_node const&);
-    };
-
-    // Iterator Base
-
-    template <class A, class G>
-    class hash_iterator_base
-    {
-    public:
-        typedef A value_allocator;
-        typedef hash_bucket<A> bucket;
-        typedef hash_node<A, G> node;
-        typedef BOOST_DEDUCED_TYPENAME A::value_type value_type;
-        typedef BOOST_DEDUCED_TYPENAME bucket::bucket_ptr bucket_ptr;
-        typedef BOOST_DEDUCED_TYPENAME bucket::node_ptr node_ptr;
-
-        bucket_ptr bucket_;
-        node_ptr node_;
-
-        hash_iterator_base() : bucket_(), node_() {}
-        explicit hash_iterator_base(bucket_ptr b)
-          : bucket_(b),
-            node_(b ? b->next_ : node_ptr()) {}
-        hash_iterator_base(bucket_ptr b, node_ptr n)
-          : bucket_(b),
-            node_(n) {}
-        
-        bool operator==(hash_iterator_base const& x) const {
-            return node_ == x.node_; }
-        bool operator!=(hash_iterator_base const& x) const {
-            return node_ != x.node_; }
-        value_type& operator*() const {
-            return node::get_value(node_);
-        }
-    
-        void increment_bucket(node_ptr n) {
-            while(!n) {
-                ++bucket_;
-                n = bucket_->next_;
-            }
-            node_ = bucket_ == n ? node_ptr() : n;
-        }
-
-        void increment() {
-            increment_bucket(node_->next_);
-        }
-    };
-
-    // hash_buckets
-    //
-    // This is responsible for allocating and deallocating buckets and nodes.
-    //
-    // Notes:
-    // 1. For the sake exception safety the allocators themselves don't allocate
-    //    anything.
-    // 2. It's the callers responsibility to allocate the buckets before calling
-    //    any of the methods (other than getters and setters).
-
-    template <class A, class G>
-    class hash_buckets
-    {
-        hash_buckets(hash_buckets const&);
-        hash_buckets& operator=(hash_buckets const&);
-    public:
-        // Types
-
-        typedef A value_allocator;
-        typedef hash_bucket<A> bucket;
-        typedef hash_iterator_base<A, G> iterator_base;
-        typedef BOOST_DEDUCED_TYPENAME A::value_type value_type;
-        typedef BOOST_DEDUCED_TYPENAME iterator_base::node node;
-
-        typedef BOOST_DEDUCED_TYPENAME bucket::bucket_allocator
-            bucket_allocator;
-        typedef BOOST_DEDUCED_TYPENAME bucket::bucket_ptr bucket_ptr;
-        typedef BOOST_DEDUCED_TYPENAME bucket::node_ptr node_ptr;
-
-        typedef BOOST_DEDUCED_TYPENAME rebind_wrap<value_allocator, node>::type
-            node_allocator;
-        typedef BOOST_DEDUCED_TYPENAME node_allocator::pointer real_node_ptr;
-
-        // Members
-
-        bucket_ptr buckets_;
-        std::size_t bucket_count_;
-        boost::compressed_pair<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;
-
-        // Constructors
-
-        hash_buckets(node_allocator const& a, std::size_t n);
-        void create_buckets();
-        ~hash_buckets();
-        
-        // no throw
-        void swap(hash_buckets& other);
-        void move(hash_buckets& other);
-
-        // For the remaining functions, buckets_ must not be null.
-        
-        bucket_ptr get_bucket(std::size_t n) const;
-        bucket_ptr bucket_ptr_from_hash(std::size_t hashed) const;
-        std::size_t bucket_size(std::size_t index) const;
-        node_ptr bucket_begin(std::size_t n) const;
-
-        // Alloc/Dealloc
-        
-        void delete_node(node_ptr);
-
-        // 
-        void delete_buckets();
-        void clear_bucket(bucket_ptr);
-        std::size_t delete_nodes(node_ptr begin, node_ptr end);
-        std::size_t delete_to_bucket_end(node_ptr begin);
-    };
-
-    template <class H, class P> class set_hash_functions;
-
-    template <class H, class P>
-    class hash_buffered_functions
-    {
-        friend class set_hash_functions<H, P>;
-        hash_buffered_functions& operator=(hash_buffered_functions const&);
-
-        typedef boost::compressed_pair<H, P> function_pair;
-        typedef BOOST_DEDUCED_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:
-
-        hash_buffered_functions(H const& hf, P const& eq)
-            : current_(false)
-        {
-            construct(current_, hf, eq);
-        }
-
-        hash_buffered_functions(hash_buffered_functions const& bf)
-            : current_(false)
-        {
-            construct(current_, bf.current());
-        }
-
-        ~hash_buffered_functions() {
-            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&);
-    
-        typedef hash_buffered_functions<H, P> buffered_functions;
-        buffered_functions& buffered_functions_;
-        bool tmp_functions_;
-
-    public:
-
-        set_hash_functions(buffered_functions& f, H const& h, P const& p)
-          : buffered_functions_(f),
-            tmp_functions_(!f.current_)
-        {
-            f.construct(tmp_functions_, h, p);
-        }
-
-        set_hash_functions(buffered_functions& f,
-            buffered_functions const& other)
-          : buffered_functions_(f),
-            tmp_functions_(!f.current_)
-        {
-            f.construct(tmp_functions_, other.current());
-        }
-
-        ~set_hash_functions()
-        {
-            buffered_functions_.destroy(tmp_functions_);
-        }
-
-        void commit()
-        {
-            buffered_functions_.current_ = tmp_functions_;
-            tmp_functions_ = !tmp_functions_;
-        }
-    };
-
-    template <class T>
-    class hash_table : public T::buckets, public T::buffered_functions
-    {
-        hash_table(hash_table const&);
-    public:
-        typedef BOOST_DEDUCED_TYPENAME T::hasher hasher;
-        typedef BOOST_DEDUCED_TYPENAME T::key_equal key_equal;
-        typedef BOOST_DEDUCED_TYPENAME T::value_allocator value_allocator;
-        typedef BOOST_DEDUCED_TYPENAME T::key_type key_type;
-        typedef BOOST_DEDUCED_TYPENAME T::value_type value_type;
-        typedef BOOST_DEDUCED_TYPENAME T::buffered_functions base;
-        typedef BOOST_DEDUCED_TYPENAME T::buckets buckets;
-        typedef BOOST_DEDUCED_TYPENAME T::extractor extractor;
-        typedef BOOST_DEDUCED_TYPENAME T::node_constructor node_constructor;
-
-        typedef BOOST_DEDUCED_TYPENAME T::node node;
-        typedef BOOST_DEDUCED_TYPENAME T::bucket bucket;
-        typedef BOOST_DEDUCED_TYPENAME T::node_ptr node_ptr;
-        typedef BOOST_DEDUCED_TYPENAME T::bucket_ptr bucket_ptr;
-        typedef BOOST_DEDUCED_TYPENAME T::iterator_base iterator_base;
-        typedef BOOST_DEDUCED_TYPENAME T::node_allocator node_allocator;
-        typedef BOOST_DEDUCED_TYPENAME T::iterator_pair iterator_pair;
-
-        // Members
-        
-        std::size_t size_;
-        float mlf_;
-        // Cached data - invalid if !this->buckets_
-        bucket_ptr cached_begin_bucket_;
-        std::size_t max_load_;
-
-        // Helper methods
-
-        key_type const& get_key(value_type const& v) const {
-            return extractor::extract(v);
-        }
-        key_type const& get_key_from_ptr(node_ptr n) const {
-            return extractor::extract(node::get_value(n));
-        }
-        bool equal(key_type const& k, value_type const& v) const;
-        template <class Key, class Pred>
-        node_ptr find_iterator(bucket_ptr bucket, Key const& k,
-            Pred const&) const;
-        node_ptr find_iterator(bucket_ptr bucket, key_type const& k) const;
-        node_ptr find_iterator(key_type const& k) const;
-        node_ptr* find_for_erase(bucket_ptr bucket, key_type const& k) const;
-        
-        // Load methods
-
-        std::size_t max_size() const;
-        std::size_t bucket_index(key_type const& k) const;
-        void max_load_factor(float z);
-        std::size_t min_buckets_for_size(std::size_t n) const;
-        std::size_t calculate_max_load();
-
-        // Constructors
-
-        hash_table(std::size_t n, hasher const& hf, key_equal const& eq,
-            node_allocator const& a);
-        hash_table(hash_table const& x, node_allocator const& a);
-        hash_table(hash_table& x, move_tag m);
-        hash_table(hash_table& x, node_allocator const& a, move_tag m);
-        ~hash_table() {}
-        hash_table& operator=(hash_table const&);
-
-        // Iterators
-
-        iterator_base begin() const {
-            return this->size_ ?
-                iterator_base(this->cached_begin_bucket_) :
-                iterator_base();
-        }
-        iterator_base end() const {
-            return iterator_base();
-        }
-
-        // Swap & Move
-
-        void swap(hash_table& x);
-        void fast_swap(hash_table& other);
-        void slow_swap(hash_table& other);
-        void partial_swap(hash_table& other);
-        void move(hash_table& x);
-
-        // Reserve and rehash
-
-        void create_for_insert(std::size_t n);
-        bool reserve_for_insert(std::size_t n);
-        void rehash(std::size_t n);
-        void rehash_impl(std::size_t n);
-
-        // Move/copy buckets
-
-        void move_buckets_to(buckets& dst);
-        void copy_buckets_to(buckets& dst) const;
-
-        // Misc. key methods
-
-        std::size_t count(key_type const& k) const;
-        iterator_base find(key_type const& k) const;
-        template <class Key, class Hash, class Pred>
-        iterator_base find(Key const& k, Hash const& h, Pred const& eq) const;
-        value_type& at(key_type const& k) const;
-        iterator_pair equal_range(key_type const& k) const;
-
-        // Erase
-        //
-        // no throw
-
-        void clear();
-        std::size_t erase_key(key_type const& k);
-        iterator_base erase_return_iterator(iterator_base r);
-        void erase(iterator_base r);
-        std::size_t erase_group(node_ptr* it, bucket_ptr bucket);
-        iterator_base erase_range(iterator_base r1, iterator_base r2);
-
-        // recompute_begin_bucket
-
-        void init_buckets();
-
-        // After an erase cached_begin_bucket_ might be left pointing to
-        // an empty bucket, so this is called to update it
-        //
-        // no throw
-
-        void recompute_begin_bucket(bucket_ptr b);
-
-        // This is called when a range has been erased
-        //
-        // no throw
-
-        void recompute_begin_bucket(bucket_ptr b1, bucket_ptr b2);
-        
-        // no throw
-        float load_factor() const;
-        
-        iterator_base emplace_empty_impl_with_node(
-            node_constructor&, std::size_t);
-    };
-
-    // Iterator Access
-
-#if !defined(__clang__)
-    class iterator_access
-    {
-    public:
-        template <class Iterator>
-        static BOOST_DEDUCED_TYPENAME Iterator::base const&
-            get(Iterator const& it)
-        {
-            return it.base_;
-        }
-    };
-#else
-    class iterator_access
-    {
-    public:
-        // Note: we access Iterator::base here, rather than in the function
-        // signature to work around a bug in the friend support of an
-        // early version of clang.
-
-        template <class Iterator>
-        struct base
-        {
-            typedef BOOST_DEDUCED_TYPENAME Iterator::base type;
-        };
-    
-        template <class Iterator>
-        static BOOST_DEDUCED_TYPENAME base<Iterator>::type const&
-            get(Iterator const& it)
-        {
-            return it.base_;
-        }
-    };
-#endif
-
-    // Iterators
-
-    template <class A, class G> class hash_iterator;
-    template <class A, class G> class hash_const_iterator;
-    template <class A, class G> class hash_local_iterator;
-    template <class A, class G> class hash_const_local_iterator;
-
-    // Local Iterators
-    //
-    // all no throw
-
-    template <class A, class G>
-    class hash_local_iterator
-        : public boost::iterator <
-            std::forward_iterator_tag,
-            BOOST_DEDUCED_TYPENAME A::value_type,
-            std::ptrdiff_t,
-            BOOST_DEDUCED_TYPENAME A::pointer,
-            BOOST_DEDUCED_TYPENAME A::reference>
-    {
-    public:
-        typedef BOOST_DEDUCED_TYPENAME A::value_type value_type;
-
-    private:
-        typedef hash_buckets<A, G> buckets;
-        typedef BOOST_DEDUCED_TYPENAME buckets::node_ptr node_ptr;
-        typedef BOOST_DEDUCED_TYPENAME buckets::node node;
-        typedef hash_const_local_iterator<A, G> const_local_iterator;
-
-        friend class hash_const_local_iterator<A, G>;
-        node_ptr ptr_;
-
-    public:
-        hash_local_iterator() : ptr_() {}
-        explicit hash_local_iterator(node_ptr x) : ptr_(x) {}
-        BOOST_DEDUCED_TYPENAME A::reference operator*() const {
-            return node::get_value(ptr_);
-        }
-        value_type* operator->() const {
-            return &node::get_value(ptr_);
-        }
-        hash_local_iterator& operator++() {
-            ptr_ = ptr_->next_; return *this;
-        }
-        hash_local_iterator operator++(int) {
-            hash_local_iterator tmp(ptr_); ptr_ = ptr_->next_; return tmp; }
-        bool operator==(hash_local_iterator x) const {
-            return ptr_ == x.ptr_;
-        }
-        bool operator==(const_local_iterator x) const {
-            return ptr_ == x.ptr_;
-        }
-        bool operator!=(hash_local_iterator x) const {
-            return ptr_ != x.ptr_;
-        }
-        bool operator!=(const_local_iterator x) const {
-            return ptr_ != x.ptr_;
-        }
-    };
-
-    template <class A, class G>
-    class hash_const_local_iterator
-        : public boost::iterator <
-            std::forward_iterator_tag,
-            BOOST_DEDUCED_TYPENAME A::value_type,
-            std::ptrdiff_t,
-            BOOST_DEDUCED_TYPENAME A::const_pointer,
-            BOOST_DEDUCED_TYPENAME A::const_reference >
-    {
-    public:
-        typedef BOOST_DEDUCED_TYPENAME A::value_type value_type;
-
-    private:
-        typedef hash_buckets<A, G> buckets;
-        typedef BOOST_DEDUCED_TYPENAME buckets::node_ptr ptr;
-        typedef BOOST_DEDUCED_TYPENAME buckets::node node;
-        typedef hash_local_iterator<A, G> local_iterator;
-        friend class hash_local_iterator<A, G>;
-        ptr ptr_;
-
-    public:
-        hash_const_local_iterator() : ptr_() {}
-        explicit hash_const_local_iterator(ptr x) : ptr_(x) {}
-        hash_const_local_iterator(local_iterator x) : ptr_(x.ptr_) {}
-        BOOST_DEDUCED_TYPENAME A::const_reference
-            operator*() const {
-            return node::get_value(ptr_);
-        }
-        value_type const* operator->() const {
-            return &node::get_value(ptr_);
-        }
-        hash_const_local_iterator& operator++() {
-            ptr_ = ptr_->next_; return *this;
-        }
-        hash_const_local_iterator operator++(int) {
-            hash_const_local_iterator tmp(ptr_); ptr_ = ptr_->next_; return tmp;
-        }
-        bool operator==(local_iterator x) const {
-            return ptr_ == x.ptr_;
-        }
-        bool operator==(hash_const_local_iterator x) const {
-            return ptr_ == x.ptr_;
-        }
-        bool operator!=(local_iterator x) const {
-            return ptr_ != x.ptr_;
-        }
-        bool operator!=(hash_const_local_iterator x) const {
-            return ptr_ != x.ptr_;
-        }
-    };
-
-    // iterators
-    //
-    // all no throw
-
-
-    template <class A, class G>
-    class hash_iterator
-        : public boost::iterator <
-            std::forward_iterator_tag,
-            BOOST_DEDUCED_TYPENAME A::value_type,
-            std::ptrdiff_t,
-            BOOST_DEDUCED_TYPENAME A::pointer,
-            BOOST_DEDUCED_TYPENAME A::reference >
-    {
-    public:
-        typedef BOOST_DEDUCED_TYPENAME A::value_type value_type;
-
-    private:
-        typedef hash_buckets<A, G> buckets;
-        typedef BOOST_DEDUCED_TYPENAME buckets::node node;
-        typedef BOOST_DEDUCED_TYPENAME buckets::iterator_base base;
-        typedef hash_const_iterator<A, G> const_iterator;
-        friend class hash_const_iterator<A, G>;
-        base base_;
-
-    public:
-
-        hash_iterator() : base_() {}
-        explicit hash_iterator(base const& x) : base_(x) {}
-        BOOST_DEDUCED_TYPENAME A::reference operator*() const {
-            return *base_;
-        }
-        value_type* operator->() const {
-            return &*base_;
-        }
-        hash_iterator& operator++() {
-            base_.increment(); return *this;
-        }
-        hash_iterator operator++(int) {
-            hash_iterator tmp(base_); base_.increment(); return tmp;
-        }
-        bool operator==(hash_iterator const& x) const {
-            return base_ == x.base_;
-        }
-        bool operator==(const_iterator const& x) const {
-            return base_ == x.base_;
-        }
-        bool operator!=(hash_iterator const& x) const {
-            return base_ != x.base_;
-        }
-        bool operator!=(const_iterator const& x) const {
-            return base_ != x.base_;
-        }
-    };
-
-    template <class A, class G>
-    class hash_const_iterator
-        : public boost::iterator <
-            std::forward_iterator_tag,
-            BOOST_DEDUCED_TYPENAME A::value_type,
-            std::ptrdiff_t,
-            BOOST_DEDUCED_TYPENAME A::const_pointer,
-            BOOST_DEDUCED_TYPENAME A::const_reference >
-    {
-    public:
-        typedef BOOST_DEDUCED_TYPENAME A::value_type value_type;
-
-    private:
-        typedef hash_buckets<A, G> buckets;
-        typedef BOOST_DEDUCED_TYPENAME buckets::node node;
-        typedef BOOST_DEDUCED_TYPENAME buckets::iterator_base base;
-        typedef hash_iterator<A, G> iterator;
-        friend class hash_iterator<A, G>;
-        friend class iterator_access;
-        base base_;
-
-    public:
-
-        hash_const_iterator() : base_() {}
-        explicit hash_const_iterator(base const& x) : base_(x) {}
-        hash_const_iterator(iterator const& x) : base_(x.base_) {}
-        BOOST_DEDUCED_TYPENAME A::const_reference operator*() const {
-            return *base_;
-        }
-        value_type const* operator->() const {
-            return &*base_;
-        }
-        hash_const_iterator& operator++() {
-            base_.increment(); return *this;
-        }
-        hash_const_iterator operator++(int) {
-            hash_const_iterator tmp(base_); base_.increment(); return tmp;
-        }
-        bool operator==(iterator const& x) const {
-            return base_ == x.base_;
-        }
-        bool operator==(hash_const_iterator const& x) const {
-            return base_ == x.base_;
-        }
-        bool operator!=(iterator const& x) const {
-            return base_ != x.base_;
-        }
-        bool operator!=(hash_const_iterator const& x) const {
-            return base_ != x.base_;
-        }
-    };
-
-    // types
-
-    template <class K, class V, class H, class P, class A, class E, class G>
-    struct types
-    {
-    public:
-        typedef K key_type;
-        typedef V value_type;
-        typedef H hasher;
-        typedef P key_equal;
-        typedef A value_allocator;
-        typedef E extractor;
-        typedef G group_type;
-        
-        typedef hash_node_constructor<value_allocator, group_type>
-            node_constructor;
-        typedef hash_buckets<value_allocator, group_type> buckets;
-        typedef hash_buffered_functions<hasher, key_equal> buffered_functions;
-
-        typedef BOOST_DEDUCED_TYPENAME buckets::node node;
-        typedef BOOST_DEDUCED_TYPENAME buckets::bucket bucket;
-        typedef BOOST_DEDUCED_TYPENAME buckets::node_ptr node_ptr;
-        typedef BOOST_DEDUCED_TYPENAME buckets::bucket_ptr bucket_ptr;
-        typedef BOOST_DEDUCED_TYPENAME buckets::iterator_base iterator_base;
-        typedef BOOST_DEDUCED_TYPENAME buckets::node_allocator node_allocator;
-
-        typedef std::pair<iterator_base, iterator_base> iterator_pair;
-    };
-}}
+    struct piecewise_construct_t {};
+    const piecewise_construct_t piecewise_construct = piecewise_construct_t();
+}
+}
 
 #endif

include/boost/unordered/detail/move.hpp

@@ -1,243 +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/config.hpp>
-#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/detail/workaround.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
-
-/*************************************************************************************************/
-
-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;
-private:
-    move_from& operator=(move_from const&);
-};
-
-/*************************************************************************************************/
-
-#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/node.hpp

@@ -1,226 +0,0 @@
-
-// Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
-// Copyright (C) 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)
-
-// This contains the basic data structure, apart from the actual values. There's
-// no construction or deconstruction here. So this only depends on the pointer
-// type.
-
-#ifndef BOOST_UNORDERED_DETAIL_NODE_HPP_INCLUDED
-#define BOOST_UNORDERED_DETAIL_NODE_HPP_INCLUDED
-
-#include <boost/config.hpp>
-#include <boost/assert.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/unordered/detail/fwd.hpp>
-
-#if BOOST_WORKAROUND(__BORLANDC__, <= 0X0582)
-#define BOOST_UNORDERED_BORLAND_BOOL(x) (bool)(x)
-#else
-#define BOOST_UNORDERED_BORLAND_BOOL(x) x
-#endif
-
-namespace boost { namespace unordered_detail {
-
-    ////////////////////////////////////////////////////////////////////////////
-    // ungrouped node implementation
-    
-    template <class A>
-    inline BOOST_DEDUCED_TYPENAME ungrouped_node_base<A>::node_ptr&
-        ungrouped_node_base<A>::next_group(node_ptr ptr)
-    {
-        return ptr->next_;
-    }
-
-    template <class A>
-    inline std::size_t ungrouped_node_base<A>::group_count(node_ptr)
-    {
-        return 1;
-    }
-
-    template <class A>
-    inline void ungrouped_node_base<A>::add_to_bucket(node_ptr n, bucket& b)
-    {
-        n->next_ = b.next_;
-        b.next_ = n;
-    }
-
-    template <class A>
-    inline void ungrouped_node_base<A>::add_after_node(node_ptr n,
-        node_ptr position)
-    {
-        n->next_ = position->next_;
-        position->next_ = position;
-    }
-    
-    template <class A>
-    inline void ungrouped_node_base<A>::unlink_nodes(bucket& b,
-        node_ptr begin, node_ptr end)
-    {
-        node_ptr* pos = &b.next_;
-        while(*pos != begin) pos = &(*pos)->next_;
-        *pos = end;
-    }
-
-    template <class A>
-    inline void ungrouped_node_base<A>::unlink_nodes(bucket& b, node_ptr end)
-    {
-        b.next_ = end;
-    }
-
-    template <class A>
-    inline void ungrouped_node_base<A>::unlink_node(bucket& b, node_ptr n)
-    {
-        unlink_nodes(b, n, n->next_);
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-    // grouped node implementation
-    
-    // If ptr is the first element in a group, return pointer to next group.
-    // Otherwise returns a pointer to ptr.
-    template <class A>
-    inline BOOST_DEDUCED_TYPENAME grouped_node_base<A>::node_ptr&
-        grouped_node_base<A>::next_group(node_ptr ptr)
-    {
-        return get(ptr).group_prev_->next_;
-    }
-
-    template <class A>
-    inline BOOST_DEDUCED_TYPENAME grouped_node_base<A>::node_ptr
-        grouped_node_base<A>::first_in_group(node_ptr ptr)
-    {
-        while(next_group(ptr) == ptr)
-            ptr = get(ptr).group_prev_;
-        return ptr;
-    }
-
-    template <class A>
-    inline std::size_t grouped_node_base<A>::group_count(node_ptr ptr)
-    {
-        node_ptr start = ptr;
-        std::size_t size = 0;
-        do {
-            ++size;
-            ptr = get(ptr).group_prev_;
-        } while(ptr != start);
-        return size;
-    }
-
-    template <class A>
-    inline void grouped_node_base<A>::add_to_bucket(node_ptr n, bucket& b)
-    {
-        n->next_ = b.next_;
-        get(n).group_prev_ = n;
-        b.next_ = n;
-    }
-
-    template <class A>
-    inline void grouped_node_base<A>::add_after_node(node_ptr n, node_ptr pos)
-    {
-        n->next_ = next_group(pos);
-        get(n).group_prev_ = get(pos).group_prev_;
-        next_group(pos) = n;
-        get(pos).group_prev_ = n;
-    }
-
-    // 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).
-    template <class A>
-    inline BOOST_DEDUCED_TYPENAME grouped_node_base<A>::node_ptr
-        grouped_node_base<A>::split_group(node_ptr split)
-    {
-        node_ptr first = first_in_group(split);
-        if(first == split) return split;
-
-        node_ptr last = get(first).group_prev_;
-        get(first).group_prev_ = get(split).group_prev_;
-        get(split).group_prev_ = last;
-
-        return first;
-    }
-
-    template <class A>
-    void grouped_node_base<A>::unlink_node(bucket& b, node_ptr n)
-    {
-        node_ptr next = n->next_;
-        node_ptr* pos = &next_group(n);
-
-        if(*pos != n) {
-            // The node is at the beginning of a group.
-
-            // Find the previous node pointer:
-            pos = &b.next_;
-            while(*pos != n) pos = &next_group(*pos);
-
-            // Remove from group
-            if(BOOST_UNORDERED_BORLAND_BOOL(next) &&
-                get(next).group_prev_ == n)
-            {
-                get(next).group_prev_ = get(n).group_prev_;
-            }
-        }
-        else if(BOOST_UNORDERED_BORLAND_BOOL(next) &&
-            get(next).group_prev_ == n)
-        {
-            // The deleted node is not at the end of the group, so
-            // change the link from the next node.
-            get(next).group_prev_ = get(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_ptr x = get(n).group_prev_;
-            while(get(x).group_prev_ != n) {
-                x = get(x).group_prev_;
-            }
-            get(x).group_prev_ = get(n).group_prev_;
-        }
-        *pos = next;
-    }
-
-    template <class A>
-    void grouped_node_base<A>::unlink_nodes(bucket& b,
-        node_ptr begin, node_ptr end)
-    {
-        node_ptr* pos = &next_group(begin);
-
-        if(*pos != begin) {
-            // The node is at the beginning of a group.
-
-            // Find the previous node pointer:
-            pos = &b.next_;
-            while(*pos != begin) pos = &next_group(*pos);
-
-            // Remove from group
-            if(BOOST_UNORDERED_BORLAND_BOOL(end)) split_group(end);
-        }
-        else {
-            node_ptr group1 = split_group(begin);
-            if(BOOST_UNORDERED_BORLAND_BOOL(end)) {
-                node_ptr group2 = split_group(end);
-
-                if(begin == group2) {
-                    node_ptr end1 = get(group1).group_prev_;
-                    node_ptr end2 = get(group2).group_prev_;
-                    get(group1).group_prev_ = end2;
-                    get(group2).group_prev_ = end1;
-                }
-            }
-        }
-        *pos = end;
-    }
-
-    template <class A>
-    void grouped_node_base<A>::unlink_nodes(bucket& b, node_ptr end)
-    {
-        split_group(end);
-        b.next_ = end;
-    }
-}}
-
-#endif

include/boost/unordered/detail/util.hpp

@@ -1,33 +1,56 @@
 
 // Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
-// Copyright (C) 2005-2009 Daniel James
+// 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
 
-#include <cstddef>
-#include <utility>
-#include <algorithm>
-#include <boost/limits.hpp>
+#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/unordered/detail/fwd.hpp>
+#include <boost/swap.hpp>
 
-namespace boost { namespace unordered_detail {
+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 {};
 
     ////////////////////////////////////////////////////////////////////////////
-    // convert double to std::size_t
+    // iterator SFINAE
 
-    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);
-    }
+    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
@@ -92,240 +115,146 @@ namespace boost { namespace unordered_detail {
         return *bound;
     }
 
-    ////////////////////////////////////////////////////////////////////////////
-    // pair_cast - because some libraries don't have the full pair constructors.
-
-    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));
-    }
-
     ////////////////////////////////////////////////////////////////////////////
     // 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 std::size_t insert_size(I i, I j, boost::forward_traversal_tag)
+    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 std::size_t insert_size(I, I, boost::incrementable_traversal_tag)
+    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 insert_size(I i, I j)
-    {
-        BOOST_DEDUCED_TYPENAME boost::iterator_traversal<I>::type
-            iterator_traversal_tag;
-        return insert_size(i, j, iterator_traversal_tag);
-    }
-    
     template <class I>
     inline std::size_t initial_size(I i, I j,
-        std::size_t num_buckets = boost::unordered_detail::default_bucket_count)
+        std::size_t num_buckets =
+            boost::unordered::detail::default_bucket_count)
     {
-        return (std::max)(static_cast<std::size_t>(insert_size(i, j)) + 1,
+        // TODO: Why +1?
+        return (std::max)(
+            boost::unordered::detail::insert_size(i, j) + 1,
             num_buckets);
     }
 
     ////////////////////////////////////////////////////////////////////////////
-    // Node Constructors
+    // compressed
 
-#if defined(BOOST_UNORDERED_STD_FORWARD)
-
-    template <class T, class... Args>
-    inline void construct_impl(T*, void* address, Args&&... args)
+    template <typename T, int Index>
+    struct compressed_base : private T
     {
-        new(address) T(std::forward<Args>(args)...);
-    }
+        compressed_base(T const& x) : T(x) {}
+        compressed_base(T& x, move_tag) : T(boost::move(x)) {}
 
-#if defined(BOOST_UNORDERED_CPP0X_PAIR)
-    template <class First, class Second, class Key, class Arg0, class... Args>
-    inline void construct_impl(std::pair<First, Second>*, void* address,
-        Key&& k, Arg0&& arg0, Args&&... args)
-    )
+        T& get() { return *this; }
+        T const& get() const { return *this; }
+    };
+    
+    template <typename T, int Index>
+    struct uncompressed_base
     {
-        new(address) std::pair<First, Second>(k,
-            Second(arg0, std::forward<Args>(args)...);
-    }
-#endif
+        uncompressed_base(T const& x) : value_(x) {}
+        uncompressed_base(T& x, move_tag) : value_(boost::move(x)) {}
 
-#else
-
-#define BOOST_UNORDERED_CONSTRUCT_IMPL(z, num_params, _)                       \
-    template <                                                                 \
-        class T,                                                               \
-        BOOST_UNORDERED_TEMPLATE_ARGS(z, num_params)                           \
-    >                                                                          \
-    inline void construct_impl(                                                \
-        T*, void* address,                                                     \
-        BOOST_UNORDERED_FUNCTION_PARAMS(z, num_params)                         \
-    )                                                                          \
-    {                                                                          \
-        new(address) T(                                                        \
-            BOOST_UNORDERED_CALL_PARAMS(z, num_params));                       \
-    }                                                                          \
-                                                                               \
-    template <class First, class Second, class Key,                            \
-        BOOST_UNORDERED_TEMPLATE_ARGS(z, num_params)                           \
-    >                                                                          \
-    inline void construct_impl(                                                \
-        std::pair<First, Second>*, void* address,                              \
-        Key const& k, BOOST_UNORDERED_FUNCTION_PARAMS(z, num_params))          \
-    {                                                                          \
-        new(address) std::pair<First, Second>(k,                               \
-            Second(BOOST_UNORDERED_CALL_PARAMS(z, num_params)));               \
-    }
-
-    BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT,
-        BOOST_UNORDERED_CONSTRUCT_IMPL, _)
-
-#undef BOOST_UNORDERED_CONSTRUCT_IMPL
-#endif
-
-    // hash_node_constructor
-    //
-    // Used to construct nodes in an exception safe manner.
-
-    template <class Alloc, class Grouped>
-    class hash_node_constructor
+        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 hash_buckets<Alloc, Grouped> buckets;
-        typedef BOOST_DEDUCED_TYPENAME buckets::node node;
-        typedef BOOST_DEDUCED_TYPENAME buckets::real_node_ptr real_node_ptr;
-        typedef BOOST_DEDUCED_TYPENAME buckets::value_type value_type;
+        typedef typename generate_base<T1, 1>::type base1;
+        typedef typename generate_base<T2, 2>::type base2;
 
-        buckets& buckets_;
-        real_node_ptr node_;
-        bool node_constructed_;
-        bool value_constructed_;
-
-    public:
-
-        hash_node_constructor(buckets& m) :
-            buckets_(m),
-            node_(),
-            node_constructed_(false),
-            value_constructed_(false)
-        {
+        typedef T1 first_type;
+        typedef T2 second_type;
+        
+        first_type& first() {
+            return static_cast<base1*>(this)->get();
         }
 
-        ~hash_node_constructor();
-        void construct_preamble();
-
-#if defined(BOOST_UNORDERED_STD_FORWARD)
-        template <class... Args>
-        void construct(Args&&... args)
-        {
-            construct_preamble();
-            construct_impl((value_type*) 0, node_->address(),
-                std::forward<Args>(args)...);
-            value_constructed_ = true;
-        }
-#else
-
-#define BOOST_UNORDERED_CONSTRUCT(z, num_params, _)                            \
-        template <                                                             \
-            BOOST_UNORDERED_TEMPLATE_ARGS(z, num_params)                       \
-        >                                                                      \
-        void construct(                                                        \
-            BOOST_UNORDERED_FUNCTION_PARAMS(z, num_params)                     \
-        )                                                                      \
-        {                                                                      \
-            construct_preamble();                                              \
-            construct_impl(                                                    \
-                (value_type*) 0, node_->address(),                             \
-                BOOST_UNORDERED_CALL_PARAMS(z, num_params)                     \
-            );                                                                 \
-            value_constructed_ = true;                                         \
+        first_type const& first() const {
+            return static_cast<base1 const*>(this)->get();
         }
 
-        BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT,
-            BOOST_UNORDERED_CONSTRUCT, _)
-
-#undef BOOST_UNORDERED_CONSTRUCT
-
-#endif
-        template <class K, class M>
-        void construct_pair(K const& k, M*)
-        {
-            construct_preamble();
-            new(node_->address()) value_type(k, M());                    
-            value_constructed_ = true;
+        second_type& second() {
+            return static_cast<base2*>(this)->get();
         }
 
-        value_type& value() const
-        {
-            BOOST_ASSERT(node_);
-            return node_->value();
+        second_type const& second() const {
+            return static_cast<base2 const*>(this)->get();
         }
 
-        // no throw
-        BOOST_DEDUCED_TYPENAME buckets::node_ptr release()
+        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)
         {
-            real_node_ptr p = node_;
-            node_ = real_node_ptr();
-            // node_ptr cast
-            return buckets_.bucket_alloc().address(*p);
+            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:
-        hash_node_constructor(hash_node_constructor const&);
-        hash_node_constructor& operator=(hash_node_constructor const&);
+        // Prevent assignment just to make use of assign or
+        // move_assign explicit.
+        compressed& operator=(compressed const&);
     };
-    
-    // hash_node_constructor
-
-    template <class Alloc, class Grouped>
-    inline hash_node_constructor<Alloc, Grouped>::~hash_node_constructor()
-    {
-        if (node_) {
-            if (value_constructed_) {
-#if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
-                struct dummy { hash_node<Alloc, Grouped> x; };
-#endif
-                boost::unordered_detail::destroy(&node_->value());
-            }
-
-            if (node_constructed_)
-                buckets_.node_alloc().destroy(node_);
-
-            buckets_.node_alloc().deallocate(node_, 1);
-        }
-    }
-
-    template <class Alloc, class Grouped>
-    inline void hash_node_constructor<Alloc, Grouped>::construct_preamble()
-    {
-        if(!node_) {
-            node_constructed_ = false;
-            value_constructed_ = false;
-
-            node_ = buckets_.node_alloc().allocate(1);
-            buckets_.node_alloc().construct(node_, node());
-            node_constructed_ = true;
-        }
-        else {
-            BOOST_ASSERT(node_constructed_ && value_constructed_);
-            boost::unordered_detail::destroy(&node_->value());
-            value_constructed_ = false;
-        }
-    }
-}}
+}}}
 
 #endif

include/boost/unordered/unordered_map_fwd.hpp

@@ -1,5 +1,5 @@
 
-// Copyright (C) 2008-2009 Daniel James.
+// 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)
 
@@ -10,44 +10,38 @@
 # pragma once
 #endif
 
-#include <boost/config.hpp>
-#include <memory>
-#include <functional>
-#include <boost/functional/hash_fwd.hpp>
+#include <boost/unordered/detail/fwd.hpp>
 
 namespace boost
 {
-    template <class K,
-        class T,
-        class H = 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, 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>&);
+    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 = hash<K>,
-        class P = std::equal_to<K>,
-        class A = std::allocator<std::pair<const K, 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 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

@@ -1,5 +1,5 @@
 
-// Copyright (C) 2008-2009 Daniel James.
+// 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)
 
@@ -10,42 +10,38 @@
 # pragma once
 #endif
 
-#include <boost/config.hpp>
-#include <memory>
-#include <functional>
-#include <boost/functional/hash_fwd.hpp>
+#include <boost/unordered/detail/fwd.hpp>
 
 namespace boost
 {
-    template <class T,
-        class H = hash<T>,
-        class P = std::equal_to<T>,
-        class A = std::allocator<T> >
-    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);
+    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 = hash<T>,
-        class P = std::equal_to<T>,
-        class A = std::allocator<T> >
-    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 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

test/exception/Jamfile.v2

@@ -14,9 +14,9 @@ project unordered-test/exception-tests
         <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>gcc:<define>_GLIBCXX_DEBUG
         #<toolset>darwin:<define>_GLIBCXX_DEBUG
-        <toolset>msvc:<warnings-as-errors>on
+        #<toolset>msvc:<warnings-as-errors>on
         #<toolset>gcc:<warnings-as-errors>on
         #<toolset>darwin:<warnings-as-errors>on
     ;

test/exception/swap_exception_tests.cpp

@@ -27,13 +27,12 @@ struct self_swap_base : public test::exception_base
     void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const {
         std::string scope(test::scope);
 
-#if BOOST_UNORDERED_SWAP_METHOD != 2
+        // TODO: In C++11 exceptions are only allowed in the swap function.
         BOOST_TEST(
-                scope == "hash::operator(hash)" ||
+                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);
     }
@@ -82,13 +81,12 @@ struct swap_base : public test::exception_base
     void check BOOST_PREVENT_MACRO_SUBSTITUTION(data_type const& d) const {
         std::string scope(test::scope);
 
-#if BOOST_UNORDERED_SWAP_METHOD != 2
+        // TODO: In C++11 exceptions are only allowed in the swap function.
         BOOST_TEST(
-                scope == "hash::operator(hash)" ||
+                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/count.hpp

@@ -75,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/invariants.hpp

@@ -38,7 +38,7 @@ namespace test
             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);
@@ -65,37 +65,32 @@ 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.");
+            std::cout<<x1.size()<<"/"<<size<<std::endl;
+        }
         float load_factor =
             static_cast<float>(size) / static_cast<float>(x1.bucket_count());
         using namespace std;

test/helpers/memory.hpp

@@ -70,7 +70,7 @@ namespace test
         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;
 
@@ -137,7 +137,7 @@ namespace test
             }
 
             void track_deallocate(void* ptr, std::size_t n, std::size_t size,
-                int tag)
+                int tag, bool check_tag_ = true)
             {
                 BOOST_DEDUCED_TYPENAME allocated_memory_type::iterator pos =
                     allocated_memory.find(
@@ -147,7 +147,7 @@ namespace test
                 } else {
                     BOOST_TEST(pos->first.start == ptr);
                     BOOST_TEST(pos->first.end == (char*) ptr + n * size);
-                    BOOST_TEST(pos->second.tag_ == tag);
+                    if (check_tag_) BOOST_TEST(pos->second.tag_ == tag);
                     allocated_memory.erase(pos);
                 }
                 BOOST_TEST(count_allocations > 0);
@@ -168,6 +168,42 @@ 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 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/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

@@ -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_UNORDERED_STD_FORWARD)
-        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/minimal.hpp

@@ -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,9 +67,7 @@ namespace minimal
     class copy_constructible_equality_comparable
     {
     public:
-        static copy_constructible_equality_comparable create() {
-            return copy_constructible_equality_comparable();
-        }
+        copy_constructible_equality_comparable(constructor_param const&) {}
 
         copy_constructible_equality_comparable(
             copy_constructible_equality_comparable const&)
@@ -63,6 +82,7 @@ namespace minimal
         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==(
@@ -82,10 +102,7 @@ namespace minimal
     class default_copy_constructible
     {
     public:
-        static default_copy_constructible create()
-        {
-            return default_copy_constructible();
-        }
+        default_copy_constructible(constructor_param const&) {}
 
         default_copy_constructible()
         {
@@ -98,62 +115,154 @@ namespace minimal
         ~default_copy_constructible()
         {
         }
+
     private:
         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_; }
@@ -175,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_;
 
@@ -195,6 +301,7 @@ 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_; }
@@ -208,19 +315,15 @@ namespace minimal
         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>
@@ -229,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;
@@ -260,15 +365,15 @@ 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_UNORDERED_STD_FORWARD)
-        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; }
 
@@ -278,6 +383,8 @@ namespace minimal
 #else
     private: allocator& operator=(allocator const&);
 #endif
+    private:
+        ampersand_operator_used operator&() const { return ampersand_operator_used(); }
     };
 
     template <class T>
@@ -296,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>&)
+    {
+    }
 }
 }
 

test/objects/test.hpp

@@ -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_;
@@ -158,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
     {
@@ -241,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_UNORDERED_STD_FORWARD)
-        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();
         }
@@ -271,6 +284,13 @@ 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>
@@ -279,44 +299,6 @@ namespace test
     {
         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

@@ -9,19 +9,23 @@ project unordered-test/unordered
     : requirements
         <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
+        # 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
+        #<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 ]
@@ -30,9 +34,12 @@ test-suite unordered
         [ 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 ]
@@ -43,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

@@ -9,12 +9,17 @@
 #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);
@@ -28,6 +33,8 @@ void assign_tests1(T*,
 
     std::cerr<<"assign_tests1.1\n";
     {
+        test::check_instances check_;
+
         T x;
         x = x;
         BOOST_TEST(x.empty());
@@ -37,6 +44,8 @@ void assign_tests1(T*,
 
     std::cerr<<"assign_tests1.2\n";
     {
+        test::check_instances check_;
+
         test::random_values<T> v(1000, generator);
         T x(v.begin(), v.end());
 
@@ -48,9 +57,12 @@ void assign_tests1(T*,
 
         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_TEST(x.max_load_factor() == y.max_load_factor());
+        BOOST_TEST(x.max_load_factor() == mlf);
+        BOOST_TEST(y.max_load_factor() == mlf);
     }
 }
 
@@ -64,9 +76,13 @@ void assign_tests2(T*,
     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);
@@ -78,13 +94,22 @@ void assign_tests2(T*,
 
     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_TEST(test::equivalent(x2.hash_function(), hf1));
         BOOST_TEST(test::equivalent(x2.key_eq(), eq1));
-        BOOST_TEST(test::equivalent(x2.get_allocator(), al2));
+        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);
     }
 }
@@ -102,16 +127,69 @@ 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))
 )
 

test/unordered/bucket_tests.cpp

@@ -25,6 +25,8 @@ 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);

test/unordered/compile_map.cpp

@@ -17,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,
@@ -32,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,
@@ -50,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,
@@ -64,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);
 }
 
@@ -106,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;
@@ -146,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,
@@ -171,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

@@ -17,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>,
@@ -30,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>,
@@ -41,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>,
@@ -52,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);
 }
 
@@ -87,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";
 
@@ -125,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";
 
@@ -137,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

@@ -22,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&)
@@ -109,30 +111,15 @@ void container_test(X& r, T const&)
     BOOST_TEST(X().size() == 0);
 
     X a,b;
+    X a_const;
 
     sink(X(a));
     X u2(a);
     X u3 = a;
 
-    X* ptr = new X();
-    X& a1 = *ptr;
-    (&a1)->~X();
-
-    X const a_const;
-    test::check_return_type<iterator>::equals(a.begin());
-    test::check_return_type<const_iterator>::equals(a_const.begin());
-    test::check_return_type<const_iterator>::equals(a.cbegin());
-    test::check_return_type<const_iterator>::equals(a_const.cbegin());
-    test::check_return_type<iterator>::equals(a.end());
-    test::check_return_type<const_iterator>::equals(a_const.end());
-    test::check_return_type<const_iterator>::equals(a.cend());
-    test::check_return_type<const_iterator>::equals(a_const.cend());
-
     a.swap(b);
+    boost::swap(a, b);
     test::check_return_type<X>::equals_ref(r = a);
-    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());
 
     // Allocator
 
@@ -146,6 +133,51 @@ void container_test(X& r, T const&)
     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());
+    test::check_return_type<const_iterator>::equals(a.cbegin());
+    test::check_return_type<const_iterator>::equals(a_const.cbegin());
+    test::check_return_type<iterator>::equals(a.end());
+    test::check_return_type<const_iterator>::equals(a_const.end());
+    test::check_return_type<const_iterator>::equals(a.cend());
+    test::check_return_type<const_iterator>::equals(a_const.cend());
+
+    a.swap(b);
+    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());
+
+    // Allocator
+
+    typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
+    test::check_return_type<allocator_type>::equals(a_const.get_allocator());
+}
+
 template <class X, class Key>
 void unordered_set_test(X&, Key const&)
 {
@@ -160,6 +192,7 @@ 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> >));
 
@@ -180,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>
@@ -211,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;
@@ -277,8 +314,8 @@ void unordered_test(X&, Key& k, T& t, Hash& hf, Pred& eq)
         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));
@@ -316,45 +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));
-    test::check_return_type<iterator>::equals(a.emplace_hint(q, t));
-
-    a.insert(i, j);
     test::check_return_type<size_type>::equals(a.erase(k));
 
-    BOOST_TEST(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));
@@ -388,9 +398,118 @@ void unordered_test(X&, Key& k, T& t, Hash& hf, Pred& eq)
     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

@@ -15,8 +15,6 @@
 #include "../helpers/input_iterator.hpp"
 #include "../helpers/invariants.hpp"
 
-#include <iostream>
-
 namespace constructor_tests {
 
 test::seed_t seed(356730);
@@ -31,6 +29,8 @@ void constructor_tests1(T*,
 
     std::cerr<<"Construct 1\n";
     {
+        test::check_instances check_;
+
         T x(0, hf, eq);
         BOOST_TEST(x.empty());
         BOOST_TEST(test::equivalent(x.hash_function(), hf));
@@ -41,6 +41,8 @@ void constructor_tests1(T*,
 
     std::cerr<<"Construct 2\n";
     {
+        test::check_instances check_;
+
         T x(100, hf);
         BOOST_TEST(x.empty());
         BOOST_TEST(x.bucket_count() >= 100);
@@ -52,6 +54,8 @@ void constructor_tests1(T*,
 
     std::cerr<<"Construct 3\n";
     {
+        test::check_instances check_;
+
         T x(2000);
         BOOST_TEST(x.empty());
         BOOST_TEST(x.bucket_count() >= 2000);
@@ -63,6 +67,8 @@ void constructor_tests1(T*,
 
     std::cerr<<"Construct 4\n";
     {
+        test::check_instances check_;
+
         T x;
         BOOST_TEST(x.empty());
         BOOST_TEST(test::equivalent(x.hash_function(), hf));
@@ -73,6 +79,8 @@ void constructor_tests1(T*,
 
     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_TEST(x.bucket_count() >= 10000);
@@ -85,6 +93,8 @@ void constructor_tests1(T*,
 
     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_TEST(x.bucket_count() >= 10000);
@@ -97,6 +107,8 @@ void constructor_tests1(T*,
 
     std::cerr<<"Construct 7\n";
     {
+        test::check_instances check_;
+
         test::random_values<T> v(100, generator);
         T x(v.begin(), v.end(), 100);
         BOOST_TEST(x.bucket_count() >= 100);
@@ -109,6 +121,8 @@ void constructor_tests1(T*,
 
     std::cerr<<"Construct 8\n";
     {
+        test::check_instances check_;
+
         test::random_values<T> v(1, generator);
         T x(v.begin(), v.end());
         BOOST_TEST(test::equivalent(x.hash_function(), hf));
@@ -120,6 +134,8 @@ void constructor_tests1(T*,
 
     std::cerr<<"Construct 9\n";
     {
+        test::check_instances check_;
+
         T x(0, hf, eq, al);
         BOOST_TEST(x.empty());
         BOOST_TEST(test::equivalent(x.hash_function(), hf));
@@ -130,6 +146,8 @@ void constructor_tests1(T*,
 
     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_TEST(x.bucket_count() >= 10000);
@@ -142,6 +160,8 @@ void constructor_tests1(T*,
 
     std::cerr<<"Construct 11\n";
     {
+        test::check_instances check_;
+
         T x(al);
         BOOST_TEST(x.empty());
         BOOST_TEST(test::equivalent(x.hash_function(), hf));
@@ -167,6 +187,7 @@ void constructor_tests2(T*,
 
     std::cerr<<"Construct 1\n";
     {
+        test::check_instances check_;
         T x(10000, hf1, eq1);
         BOOST_TEST(x.bucket_count() >= 10000);
         BOOST_TEST(test::equivalent(x.hash_function(), hf1));
@@ -177,6 +198,7 @@ void constructor_tests2(T*,
 
     std::cerr<<"Construct 2\n";
     {
+        test::check_instances check_;
         T x(100, hf1);
         BOOST_TEST(x.empty());
         BOOST_TEST(x.bucket_count() >= 100);
@@ -188,6 +210,7 @@ void constructor_tests2(T*,
 
     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_TEST(test::equivalent(x.hash_function(), hf1));
@@ -199,6 +222,7 @@ void constructor_tests2(T*,
 
     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_TEST(x.bucket_count() >= 1000);
@@ -212,6 +236,7 @@ void constructor_tests2(T*,
 
     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);
@@ -223,6 +248,7 @@ void constructor_tests2(T*,
 
     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);
@@ -234,6 +260,7 @@ void constructor_tests2(T*,
 
     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);
@@ -245,6 +272,7 @@ void constructor_tests2(T*,
 
     std::cerr<<"Construct 8 - from input iterator\n";
     {
+        test::check_instances check_;
         test::random_values<T> v(100, generator);
         BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
             v_begin = v.begin(), v_end = v.end();
@@ -262,6 +290,7 @@ void constructor_tests2(T*,
     
     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);
@@ -275,6 +304,8 @@ void constructor_tests2(T*,
     
     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);
@@ -291,6 +322,8 @@ void constructor_tests2(T*,
     
     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));
@@ -300,6 +333,8 @@ void constructor_tests2(T*,
 
     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);
@@ -310,6 +345,8 @@ void constructor_tests2(T*,
 
     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);
@@ -320,6 +357,8 @@ void constructor_tests2(T*,
 
     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);
@@ -330,6 +369,8 @@ void constructor_tests2(T*,
 
     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);

test/unordered/copy_tests.cpp

@@ -9,6 +9,7 @@
 #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"
@@ -23,11 +24,15 @@ template <class T>
 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_TEST(y.empty());
@@ -35,20 +40,28 @@ void copy_construct_tests1(T*,
         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);
         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
@@ -61,6 +74,8 @@ void copy_construct_tests1(T*,
         BOOST_TEST(equivalent(y));
         // This isn't guaranteed:
         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);
     }
 }
@@ -75,8 +90,12 @@ void copy_construct_tests2(T* ptr,
     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_TEST(y.empty());
@@ -84,10 +103,14 @@ void copy_construct_tests2(T* ptr,
         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_TEST(y.empty());
@@ -95,10 +118,13 @@ void copy_construct_tests2(T* ptr,
         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);
@@ -106,10 +132,14 @@ void copy_construct_tests2(T* ptr,
         test::unordered_equivalence_tester<T> equivalent(x);
         BOOST_TEST(equivalent(y));
         test::check_equivalent_keys(y);
+        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);
@@ -117,6 +147,7 @@ void copy_construct_tests2(T* ptr,
         test::unordered_equivalence_tester<T> equivalent(x);
         BOOST_TEST(equivalent(y));
         test::check_equivalent_keys(y);
+        BOOST_TEST(test::selected_count(y.get_allocator()) == 0);
         BOOST_TEST(test::equivalent(y.get_allocator(), al2));
     }
 }
@@ -134,15 +165,55 @@ 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

@@ -136,15 +136,17 @@ namespace equality_tests
         UNORDERED_EQUALITY_MULTIMAP_TEST(
             ((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

test/unordered/erase_tests.cpp

@@ -28,6 +28,8 @@ void erase_tests1(Container*,
 {
     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
@@ -44,6 +46,8 @@ void erase_tests1(Container*,
 
     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();
@@ -64,6 +68,8 @@ void erase_tests1(Container*,
 
     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();
@@ -96,6 +102,8 @@ void erase_tests1(Container*,
 
     std::cerr<<"erase(ranges).\n";
     {
+        test::check_instances check_;
+
         test::random_values<Container> v(500, generator);
         Container x(v.begin(), v.end());
 
@@ -118,6 +126,8 @@ void erase_tests1(Container*,
 
     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();
@@ -136,6 +146,8 @@ void erase_tests1(Container*,
 
     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();
@@ -169,6 +181,8 @@ void erase_tests1(Container*,
 
     std::cerr<<"clear().\n";
     {
+        test::check_instances check_;
+
         test::random_values<Container> v(500, generator);
         Container x(v.begin(), v.end());
         x.clear();

test/unordered/find_tests.cpp

@@ -24,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;
@@ -69,6 +71,8 @@ void find_tests1(X*, test::random_generator generator = test::default_generator)
     }
 
     {
+        test::check_instances check_;
+
         X x;
 
         test::random_values<X> v2(5, generator);

test/unordered/fwd_map_test.cpp

@@ -7,37 +7,54 @@
 
 #include <boost/unordered/unordered_map_fwd.hpp>
 
-typedef boost::unordered_map<int, int> int_map;
-
-void call_swap(int_map& x, int_map& y) {
+template <typename T>
+void call_swap(boost::unordered_map<T,T>& x,
+    boost::unordered_map<T,T>& y)
+{
     swap(x,y);
 }
 
-bool call_equals(int_map& x, int_map& y) {
+template <typename T>
+bool call_equals(boost::unordered_map<T,T>& x,
+    boost::unordered_map<T,T>& y)
+{
     return x == y;
 }
 
-bool call_not_equals(int_map& x, int_map& y) {
+template <typename T>
+bool call_not_equals(boost::unordered_map<T,T>& x,
+    boost::unordered_map<T,T>& y)
+{
     return x != y;
 }
 
-typedef boost::unordered_multimap<int, int> int_multimap;
-
-void call_swap(int_multimap& x, int_multimap& y) {
+template <typename T>
+void call_swap(boost::unordered_multimap<T,T>& x,
+    boost::unordered_multimap<T,T>& y)
+{
     swap(x,y);
 }
 
-bool call_equals(int_multimap& x, int_multimap& y) {
+template <typename T>
+bool call_equals(boost::unordered_multimap<T,T>& x,
+    boost::unordered_multimap<T,T>& y)
+{
     return x == y;
 }
 
-bool call_not_equals(int_multimap& x, int_multimap& 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;

test/unordered/fwd_set_test.cpp

@@ -16,36 +16,53 @@ template <class Value, class Hash, class Pred, class Alloc>
 true_type is_unordered_set_impl(
         boost::unordered_set<Value, Hash, Pred, Alloc>*);
 
-typedef boost::unordered_set<int> int_set;
-
-void call_swap(int_set& x, int_set& y) {
+template<typename T>
+void call_swap(boost::unordered_set<T>& x,
+    boost::unordered_set<T>& y)
+{
     swap(x,y);
 }
 
-bool call_equals(int_set& x, int_set& y) {
+template<typename T>
+bool call_equals(boost::unordered_set<T>& x,
+    boost::unordered_set<T>& y)
+{
     return x == y;
 }
 
-bool call_not_equals(int_set& x, int_set& y) {
+template<typename T>
+bool call_not_equals(boost::unordered_set<T>& x,
+    boost::unordered_set<T>& y)
+{
     return x != y;
 }
 
-typedef boost::unordered_multiset<int> int_multiset;
-
-void call_swap(int_multiset& x, int_multiset& y) {
+template<typename T>
+void call_swap(boost::unordered_multiset<T>& x,
+    boost::unordered_multiset<T>& y)
+{
     swap(x,y);
 }
 
-bool call_equals(int_multiset& x, int_multiset& y) {
+template<typename T>
+bool call_equals(boost::unordered_multiset<T>& x,
+    boost::unordered_multiset<T>& y)
+{
     return x == y;
 }
 
-bool call_not_equals(int_multiset& x, int_multiset& 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));

test/unordered/incomplete_test.cpp

@@ -5,6 +5,7 @@
 
 #include "../helpers/prefix.hpp"
 
+#include <utility>
 #include <boost/unordered_map.hpp>
 #include <boost/unordered_set.hpp>
 

test/unordered/insert_tests.cpp

@@ -26,6 +26,8 @@ template <class X>
 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;
 
@@ -52,7 +54,7 @@ void unique_insert_tests1(X*,
 
         tracker.compare_key(x, *it);
 
-        if(x.size() < b * old_bucket_count)
+        if(static_cast<double>(x.size()) < b * static_cast<double>(old_bucket_count))
             BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 
@@ -65,6 +67,9 @@ void equivalent_insert_tests1(X*,
 {
     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);
 
@@ -83,7 +88,7 @@ void equivalent_insert_tests1(X*,
 
         tracker.compare_key(x, *it);
 
-        if(x.size() < b * old_bucket_count)
+        if(static_cast<double>(x.size()) < b * static_cast<double>(old_bucket_count))
             BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 
@@ -102,6 +107,8 @@ void insert_tests2(X*,
     std::cerr<<"insert(begin(), value) tests.\n";
 
     {
+        test::check_instances check_;
+
         X x;
         tracker_type tracker = test::create_ordered(x);
 
@@ -118,7 +125,7 @@ void insert_tests2(X*,
             BOOST_TEST(*r1 == *r2);
             tracker.compare_key(x, *it);
 
-            if(x.size() < b * old_bucket_count)
+            if(static_cast<double>(x.size()) < b * static_cast<double>(old_bucket_count))
                 BOOST_TEST(x.bucket_count() == old_bucket_count);
         }
 
@@ -128,6 +135,8 @@ void insert_tests2(X*,
     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);
@@ -145,7 +154,7 @@ void insert_tests2(X*,
             BOOST_TEST(*r1 == *r2);
             tracker.compare_key(x, *it);
 
-            if(x.size() < b * old_bucket_count)
+            if(static_cast<double>(x.size()) < b * static_cast<double>(old_bucket_count))
                 BOOST_TEST(x.bucket_count() == old_bucket_count);
         }
 
@@ -155,6 +164,8 @@ void insert_tests2(X*,
     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);
@@ -172,7 +183,7 @@ void insert_tests2(X*,
             BOOST_TEST(*pos == *r2);
             tracker.compare_key(x, *it);
 
-            if(x.size() < b * old_bucket_count)
+            if(static_cast<double>(x.size()) < b * static_cast<double>(old_bucket_count))
                 BOOST_TEST(x.bucket_count() == old_bucket_count);
         }
 
@@ -182,6 +193,8 @@ void insert_tests2(X*,
     std::cerr<<"insert single item range tests.\n";
 
     {
+        test::check_instances check_;
+
         X x;
         tracker_type tracker = test::create_ordered(x);
 
@@ -197,7 +210,7 @@ void insert_tests2(X*,
             tracker.insert(*it);
             tracker.compare_key(x, *it);
 
-            if(x.size() < b * old_bucket_count)
+            if(static_cast<double>(x.size()) < b * static_cast<double>(old_bucket_count))
                 BOOST_TEST(x.bucket_count() == old_bucket_count);
         }
 
@@ -207,6 +220,8 @@ void insert_tests2(X*,
     std::cerr<<"insert range tests.\n";
 
     {
+        test::check_instances check_;
+
         X x;
 
         test::random_values<X> v(1000, generator);
@@ -219,6 +234,8 @@ void insert_tests2(X*,
     std::cerr<<"insert input iterator range tests.\n";
 
     {
+        test::check_instances check_;
+
         X x;
 
         test::random_values<X> v(1000, generator);
@@ -233,6 +250,8 @@ void insert_tests2(X*,
     std::cerr<<"insert copy iterator range tests.\n";
 
     {
+        test::check_instances check_;
+
         X x;
 
         test::random_values<X> v(1000, generator);
@@ -275,7 +294,7 @@ void unique_emplace_tests1(X*,
 
         tracker.compare_key(x, *it);
 
-        if(x.size() < b * old_bucket_count)
+        if(static_cast<double>(x.size()) < b * static_cast<double>(old_bucket_count))
             BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 
@@ -306,7 +325,7 @@ void equivalent_emplace_tests1(X*,
 
         tracker.compare_key(x, *it);
 
-        if(x.size() < b * old_bucket_count)
+        if(static_cast<double>(x.size()) < b * static_cast<double>(old_bucket_count))
             BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 
@@ -335,7 +354,7 @@ void map_tests(X*, test::random_generator generator = test::default_generator)
 
         tracker.compare_key(x, *it);
 
-        if(x.size() < b * old_bucket_count)
+        if(static_cast<double>(x.size()) < b * static_cast<double>(old_bucket_count))
             BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 
@@ -351,6 +370,8 @@ void map_insert_range_test1(X*,
 {
     std::cerr<<"map_insert_range_test1\n";
 
+    test::check_instances check_;
+
     typedef test::list<
         std::pair<
             BOOST_DEDUCED_TYPENAME X::key_type,
@@ -371,11 +392,13 @@ void map_insert_range_test2(X*,
 {
     std::cerr<<"map_insert_range_test2\n";
 
+    test::check_instances check_;
+
     typedef test::list<
-        std::pair<BOOST_DEDUCED_TYPENAME X::key_type const, int>
+        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, int>
+        boost::unordered_map<BOOST_DEDUCED_TYPENAME X::key_type, test::implicitly_convertible>
     > v(1000, generator);
     list l(v.begin(), v.end());
 
@@ -491,6 +514,120 @@ UNORDERED_AUTO_TEST(insert_initializer_list_multimap)
 
 #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/load_factor_tests.cpp

@@ -51,7 +51,7 @@ void insert_test(X*, float mlf,
         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)
+        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

@@ -9,14 +9,24 @@
 #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*) {
@@ -54,6 +64,8 @@ namespace move_tests
         BOOST_DEDUCED_TYPENAME T::allocator_type al;
 
         {
+            test::check_instances check_;
+
             T y(empty(ptr));
             BOOST_TEST(y.empty());
             BOOST_TEST(test::equivalent(y.hash_function(), hf));
@@ -64,6 +76,8 @@ namespace move_tests
         }
 
         {
+            test::check_instances check_;
+
             test::random_values<T> v(1000, generator);
             test::object_count count;
             T y(create(v, count));
@@ -80,11 +94,13 @@ namespace move_tests
         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);
-#if defined(BOOST_HAS_NRVO)
+#if BOOST_UNORDERED_TEST_MOVING && defined(BOOST_HAS_NRVO)
             BOOST_TEST(count == test::global_object_count);
 #endif
             test::check_container(y, v);
@@ -104,6 +120,8 @@ 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));
 #if defined(BOOST_HAS_NRVO)
@@ -118,6 +136,8 @@ namespace move_tests
         }
 
         {
+            test::check_instances check_;
+
             // TODO: To do this correctly requires the fancy new allocator
             // stuff.
             test::random_values<T> v(500, generator);
@@ -130,17 +150,24 @@ namespace move_tests
             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);
-#else
+#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));
@@ -149,7 +176,144 @@ namespace move_tests
             BOOST_TEST(y.max_load_factor() == 1.0); // Not necessarily required.
             test::check_equivalent_keys(y);
         }
-*/    }
+    }
+
+    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,
@@ -164,19 +328,68 @@ namespace move_tests
         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

@@ -19,7 +19,8 @@ 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() &&
+    return static_cast<double>(x.bucket_count()) >
+        static_cast<double>(x.size()) / x.max_load_factor() &&
         x.bucket_count() >= n;
 }
 

test/unordered/swap_tests.cpp

@@ -12,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
 {
 
@@ -37,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);
@@ -54,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);
@@ -72,12 +85,16 @@ void swap_tests2(X* ptr = 0,
     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));
@@ -85,6 +102,8 @@ void swap_tests2(X* ptr = 0,
     }
 
     {
+        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));
@@ -92,57 +111,113 @@ void swap_tests2(X* ptr = 0,
         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);
+
+        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;
+        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;
+        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;
+        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;
+        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,4 +1,4 @@
-
+#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)
@@ -9,10 +9,30 @@
 #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; }
@@ -31,14 +51,25 @@ namespace unnecessary_copy_tests
             : tag_(x.tag_) { ++copies; }
 
         count_copies(count_copies const& x) : tag_(x.tag_) { ++copies; }
-#if !defined(BOOST_NO_RVALUE_REFERENCES)
-        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) {
@@ -68,31 +99,37 @@ namespace unnecessary_copy_tests
 }
 
 #define COPY_COUNT(n)                                                       \
-    if(count_copies::copies != n) {                                         \
+    if(::unnecessary_copy_tests::count_copies::copies != n) {               \
         BOOST_ERROR("Wrong number of copies.");                             \
         std::cerr                                                           \
-            << "Number of copies: " << count_copies::copies                 \
+            << "Number of copies: "                                         \
+            << ::unnecessary_copy_tests::count_copies::copies               \
             << " expecting: " << n << std::endl;                            \
     }
 #define MOVE_COUNT(n)                                                       \
-    if(count_copies::moves != n) {                                          \
+    if(::unnecessary_copy_tests::count_copies::moves != n) {                \
         BOOST_ERROR("Wrong number of moves.");                              \
         std::cerr                                                           \
-            << "Number of moves: " << count_copies::moves                   \
+            << "Number of moves: "                                          \
+            << ::unnecessary_copy_tests::count_copies::moves                \
             << " expecting: " <<n << std::endl;                             \
     }
 #define COPY_COUNT_RANGE(a, b)                                              \
-    if(count_copies::copies < a || count_copies::copies > 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: " << count_copies::copies                 \
+            << "Number of copies: "                                         \
+            << ::unnecessary_copy_tests::count_copies::copies               \
             << " expecting: [" << a << ", " << b << "]" << std::endl;       \
     }
 #define MOVE_COUNT_RANGE(a, b)                                              \
-    if(count_copies::moves < a || count_copies::moves > 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: " << count_copies::copies                  \
+            << "Number of moves: "                                          \
+            << ::unnecessary_copy_tests::count_copies::copies               \
             << " expecting: [" << a << ", " << b << "]" << std::endl;       \
     }
 
@@ -136,7 +173,7 @@ namespace unnecessary_copy_tests
         reset();
         T x;
         x.emplace(source<BOOST_DEDUCED_TYPENAME T::value_type>());
-#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
+#if !defined(BOOST_NO_RVALUE_REFERENCES)
         COPY_COUNT(1);
 #else
         COPY_COUNT(2);
@@ -148,7 +185,7 @@ namespace unnecessary_copy_tests
     UNORDERED_TEST(unnecessary_copy_emplace_rvalue_test,
             ((set)(multiset)(map)(multimap)))
 
-#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
+#if defined(BOOST_UNORDERED_STD_FORWARD_MOVE)
     template <class T>
     void unnecessary_copy_emplace_move_test(T*)
     {
@@ -162,11 +199,52 @@ namespace unnecessary_copy_tests
 
     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;
@@ -177,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
@@ -197,9 +282,9 @@ 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_NO_RVALUE_REFERENCES)
+#if defined(BOOST_UNORDERED_STD_FORWARD_MOVE)
         // No move should take place.
         reset();
         x.emplace(std::move(a));
@@ -233,6 +318,19 @@ namespace unnecessary_copy_tests
 
     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.
@@ -244,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
@@ -261,45 +368,92 @@ namespace unnecessary_copy_tests
         // copied.
         reset();
         x.emplace(source<std::pair<count_copies, count_copies> >());
+        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(2); MOVE_COUNT(0);
 
-        // TODO: This doesn't work on older versions of gcc.
-        //count_copies part;
-        std::pair<count_copies const, count_copies> b;
-        //reset();
-        //std::pair<count_copies const&, count_copies const&> a_ref(part, part);
-        //x.emplace(a_ref);
-        //COPY_COUNT(0); MOVE_COUNT(0);
+#endif
+
+#if defined(BOOST_UNORDERED_STD_FORWARD_MOVE)
 
-#if !defined(BOOST_NO_RVALUE_REFERENCES)
         // No move should take place.
         // (since a is already in the container)
         reset();
         x.emplace(std::move(a));
         COPY_COUNT(0); MOVE_COUNT(0);
-#endif
 
+#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(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
+
     }
 }