Release 1.51.0

[SVN r80098]
Unordered: Merge from trunk
2012-08-20 22:07:05 +00:00 · 2012-08-05 08:34:44 +00:00 · 2012-07-15 23:58:02 +00:00 · 2012-07-15 23:47:12 +00:00 · 2012-07-15 23:44:41 +00:00
39 changed files with 1138 additions and 1172 deletions
@@ -1,23 +1,514 @@

 // Copyright 2005-2011 Daniel James.
 // Copyright 2009 Pablo Halpern.
-//
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-// Allocator traits written by Daniel James based on Pablo Halpern's
-// implementation.

-#ifndef BOOST_UNORDERED_DETAIL_ALLOCATOR_UTILITIES_HPP_INCLUDED
-#define BOOST_UNORDERED_DETAIL_ALLOCATOR_UTILITIES_HPP_INCLUDED
+//  See http://www.boost.org/libs/unordered for documentation
+
+#ifndef BOOST_UNORDERED_ALLOCATE_HPP
+#define BOOST_UNORDERED_ALLOCATE_HPP

 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif

-#include <boost/unordered/detail/emplace_args.hpp>
-#include <boost/assert.hpp>
+#include <boost/unordered/detail/fwd.hpp>
+#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/type_traits/add_lvalue_reference.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <boost/utility/enable_if.hpp>
 #include <boost/utility/addressof.hpp>
+#include <boost/detail/select_type.hpp>
+#include <boost/assert.hpp>
+#include <utility>
+
+#if !defined(BOOST_NO_CXX11_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
+
+namespace boost { namespace unordered { namespace detail {
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Bits and pieces for implementing traits
+
+    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&);
+    };
+
+    ////////////////////////////////////////////////////////////////////////////
+    // emplace_args
+    //
+    // Either forwarding variadic arguments, or storing the arguments in
+    // emplace_args##n
+
+#if !defined(BOOST_NO_VARIADIC_TEMPLATES)
+
+#define BOOST_UNORDERED_EMPLACE_TEMPLATE typename... Args
+#define BOOST_UNORDERED_EMPLACE_ARGS BOOST_FWD_REF(Args)... args
+#define BOOST_UNORDERED_EMPLACE_FORWARD boost::forward<Args>(args)...
+
+#define BOOST_UNORDERED_EMPLACE_ARGS1(a0) a0
+#define BOOST_UNORDERED_EMPLACE_ARGS2(a0, a1) a0, a1
+#define BOOST_UNORDERED_EMPLACE_ARGS3(a0, a1, a2) a0, a1, a2
+
+#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, b)                     \
+        ) : 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, b)                  \
+    )                                                                       \
+    {                                                                       \
+        BOOST_PP_CAT(emplace_args, n) <                                     \
+            BOOST_PP_ENUM_PARAMS_Z(z, n, A)                                 \
+        > e(BOOST_PP_ENUM_PARAMS_Z(z, n, b));                               \
+        return e;                                                           \
+    }
+
+#define BOOST_UNORDERED_EMPLACE_ARGS1 create_emplace_args
+#define BOOST_UNORDERED_EMPLACE_ARGS2 create_emplace_args
+#define BOOST_UNORDERED_EMPLACE_ARGS3 create_emplace_args
+
+#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(b, 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(b, 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 !defined(__SUNPRO_CC)
+
+#   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)
+
+#else
+
+    template <int N> struct length {};
+
+#   define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(n, namespace_)              \
+    template<typename T>                                                    \
+    void construct_from_tuple_impl(                                         \
+            boost::unordered::detail::length<0>, 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_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, namespace_)                  \
+    namespace_ get<n>(x)
+
+#endif
+
+BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, boost::)
+
+#if !defined(__SUNPRO_CC) && !defined(BOOST_NO_CXX11_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
+
+#if defined(__SUNPRO_CC)
+
+    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);
+    }
+
+#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_NO_VARIADIC_TEMPLATES)
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Construct from variadic parameters
+
+    template <typename T, typename... Args>
+    inline void construct_impl(T* address, BOOST_FWD_REF(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,
+            BOOST_FWD_REF(A0), BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
+    {
+        boost::unordered::detail::construct_from_tuple(
+            boost::addressof(address->first), boost::forward<A1>(a1));
+        boost::unordered::detail::construct_from_tuple(
+            boost::addressof(address->second), boost::forward<A2>(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_FWD_REF(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,
+            BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(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,
+            BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2,
+            BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(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_NO_VARIADIC_TEMPLATES
+
+////////////////////////////////////////////////////////////////////////////////
+// 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 void construct_impl(std::pair<A, B>* address,
+            boost::unordered::detail::emplace_args3<A0, A1, A2> const& args,
+            typename enable_if<piecewise3<A, B, A0>, void*>::type = 0)
+    {
+        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 void construct_impl(std::pair<A, B>* address,
+            boost::unordered::detail::emplace_args1<A0> const& args,
+            typename enable_if<emulation1<A, B, A0>, void*>::type = 0)
+    {
+        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 void construct_impl(std::pair<A, B>* address,
+            boost::unordered::detail::emplace_args3<A0, A1, A2> const& args,
+            typename enable_if<emulation3<A, B, A0>, void*>::type = 0)
+    {
+        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_NO_VARIADIC_TEMPLATES
+
+}}}

 ////////////////////////////////////////////////////////////////////////////////
 //
@@ -30,7 +521,7 @@
 #if !defined(BOOST_UNORDERED_USE_ALLOCATOR_TRAITS)
 #   if defined(__GXX_EXPERIMENTAL_CXX0X__) && \
            (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7))
-#       define BOOST_UNORDERED_USE_ALLOCATOR_TRAITS 1
+#       define BOOST_UNORDERED_USE_ALLOCATOR_TRAITS 0
 #   elif defined(BOOST_MSVC)
 #       if BOOST_MSVC < 1400
            // Use container's allocator_traits for older versions of Visual
@@ -49,7 +540,7 @@
 // Some utilities for implementing allocator_traits, but useful elsewhere so
 // they're always defined.

-#if !defined(BOOST_NO_0X_HDR_TYPE_TRAITS)
+#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
 #  include <type_traits>
 #endif

@@ -60,7 +551,7 @@ namespace boost { namespace unordered { namespace detail {
    //
    // Uses the standard versions if available.

-#if !defined(BOOST_NO_0X_HDR_TYPE_TRAITS)
+#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)

    using std::integral_constant;
    using std::true_type;
@@ -192,7 +683,7 @@ namespace boost { namespace unordered { namespace detail {
 #       include <boost/type_traits/is_same.hpp>
 #   endif

-#   if defined(BOOST_UNORDERED_VARIADIC_MOVE) && \
+#   if !defined(BOOST_NO_VARIADIC_TEMPLATES) && \
        !defined(BOOST_NO_SFINAE_EXPR)
 #       define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 1
 #   else
@@ -282,7 +773,7 @@ namespace boost { namespace unordered { namespace detail {
        max_size, U const, (), 0
    );

-#       if defined(BOOST_UNORDERED_VARIADIC_MOVE)
+#       if !defined(BOOST_NO_VARIADIC_TEMPLATES)

    template <typename T, typename ValueType, typename... Args>
    BOOST_UNORDERED_HAS_FUNCTION(
@@ -324,35 +815,38 @@ namespace boost { namespace unordered { namespace detail {
 #   endif

    template <typename Alloc>
-    inline typename boost::enable_if_c<
+    inline Alloc call_select_on_container_copy_construction(const Alloc& rhs,
+        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)
+            has_select_on_container_copy_construction<Alloc>::value, void*
+        >::type = 0)
    {
        return rhs.select_on_container_copy_construction();
    }

    template <typename Alloc>
-    inline typename boost::disable_if_c<
+    inline Alloc call_select_on_container_copy_construction(const Alloc& rhs,
+        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)
+            has_select_on_container_copy_construction<Alloc>::value, void*
+        >::type = 0)
    {
        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)
+    inline SizeType call_max_size(const Alloc& a,
+        typename boost::enable_if_c<
+            boost::unordered::detail::has_max_size<Alloc>::value, void*
+        >::type = 0)
    {
        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&)
+    inline SizeType call_max_size(const Alloc&, typename boost::disable_if_c<
+            boost::unordered::detail::has_max_size<Alloc>::value, void*
+        >::type = 0)
    {
        return (std::numeric_limits<SizeType>::max)();
    }
@@ -409,7 +903,7 @@ namespace boost { namespace unordered { namespace detail {
        static typename boost::enable_if_c<
                boost::unordered::detail::has_construct<Alloc, T, Args...>
                ::value>::type
-            construct(Alloc& a, T* p, Args&&... x)
+            construct(Alloc& a, T* p, BOOST_FWD_REF(Args)... x)
        {
            a.construct(p, boost::forward<Args>(x)...);
        }
@@ -418,7 +912,7 @@ namespace boost { namespace unordered { namespace detail {
        static typename boost::disable_if_c<
                boost::unordered::detail::has_construct<Alloc, T, Args...>
                ::value>::type
-            construct(Alloc&, T* p, Args&&... x)
+            construct(Alloc&, T* p, BOOST_FWD_REF(Args)... x)
        {
            new ((void*) p) T(boost::forward<Args>(x)...);
        }
@@ -480,41 +974,41 @@ namespace boost { namespace unordered { namespace detail {
        // the only construct method that old fashioned allocators support.

        template <typename T>
-        static typename boost::enable_if_c<
-                boost::unordered::detail::has_construct<Alloc, T>::value &&
-                boost::is_same<T, value_type>::value
-            >::type
-            construct(Alloc& a, T* p, T const& x)
+        static void construct(Alloc& a, T* p, T const& x,
+            typename boost::enable_if_c<
+                    boost::unordered::detail::has_construct<Alloc, T>::value &&
+                    boost::is_same<T, value_type>::value,
+                    void*>::type = 0)
        {
            a.construct(p, x);
        }

        template <typename T>
-        static typename boost::disable_if_c<
+        static void construct(Alloc&, T* p, T const& x,
+            typename boost::disable_if_c<
                boost::unordered::detail::has_construct<Alloc, T>::value &&
-                boost::is_same<T, value_type>::value
-            >::type
-            construct(Alloc&, T* p, T const& x)
+                boost::is_same<T, value_type>::value,
+                void*>::type = 0)
        {
            new ((void*) p) T(x);
        }

        template <typename T>
-        static typename boost::enable_if_c<
+        static void destroy(Alloc& a, T* p,
+            typename boost::enable_if_c<
                boost::unordered::detail::has_destroy<Alloc, T>::value &&
-                boost::is_same<T, value_type>::value
-            >::type
-            destroy(Alloc& a, T* p)
+                boost::is_same<T, value_type>::value,
+                void*>::type = 0)
        {
            a.destroy(p);
        }

        template <typename T>
-        static typename boost::disable_if_c<
+        static void destroy(Alloc&, T* p,
+            typename boost::disable_if_c<
                boost::unordered::detail::has_destroy<Alloc, T>::value &&
-                boost::is_same<T, value_type>::value
-            >::type
-            destroy(Alloc&, T* p)
+                boost::is_same<T, value_type>::value,
+                void*>::type = 0)
        {
            boost::unordered::detail::destroy(p);
        }
@@ -577,7 +1071,7 @@ namespace boost { namespace unordered { namespace detail {
 ////////////////////////////////////////////////////////////////////////////////
 //
 // boost::container::allocator_traits
- 
+
 #elif BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 2

 #   include <boost/container/allocator_traits.hpp>
@@ -633,17 +1127,42 @@ namespace boost { namespace unordered { namespace detail {

 #else

+    template <typename AllocTraits, typename T>
+    struct value_construct
+    {
+        typedef BOOST_DEDUCED_TYPENAME AllocTraits::allocator_type allocator;
+
+        allocator& alloc;
+        T* ptr;
+
+        value_construct(allocator& a, T* p) : alloc(a), ptr(p)
+        {
+            AllocTraits::construct(alloc, ptr, T());
+        }
+
+        void release()
+        {
+            ptr = 0;
+        }
+
+        ~value_construct()
+        {
+            if (ptr) AllocTraits::destroy(alloc, ptr);
+        }
+
+    private:
+        value_construct(value_construct const&);
+        value_construct& operator=(value_construct const&);
+    };
+
    template <typename Alloc, typename T, BOOST_UNORDERED_EMPLACE_TEMPLATE>
    inline void construct_node(Alloc& a, T* p, BOOST_UNORDERED_EMPLACE_ARGS)
    {
-        boost::unordered::detail::allocator_traits<Alloc>::construct(a, p, T());
-        try {
-            boost::unordered::detail::construct_impl(
-                p->value_ptr(), BOOST_UNORDERED_EMPLACE_FORWARD);
-        } catch(...) {
-            boost::unordered::detail::allocator_traits<Alloc>::destroy(a, p);
-            throw;
-        }
+        value_construct<boost::unordered::detail::allocator_traits<Alloc>, T>
+            construct_guard(a, p);
+        boost::unordered::detail::construct_impl(
+            p->value_ptr(), BOOST_UNORDERED_EMPLACE_FORWARD);
+        construct_guard.release();
    }

    template <typename Alloc, typename T>
@@ -720,4 +1239,8 @@ namespace boost { namespace unordered { namespace detail {
    };
 }}}

+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
+
 #endif
@@ -12,7 +12,7 @@
 #endif

 #include <boost/unordered/detail/util.hpp>
-#include <boost/unordered/detail/allocator_helpers.hpp>
+#include <boost/unordered/detail/allocate.hpp>
 #include <boost/type_traits/aligned_storage.hpp>
 #include <boost/type_traits/alignment_of.hpp>
 #include <boost/swap.hpp>
@@ -82,15 +82,11 @@ namespace boost { namespace unordered { namespace detail {
        void construct_value2(BOOST_FWD_REF(A0) a0)
        {
            BOOST_ASSERT(node_ && !constructed_);
-#   if defined(BOOST_UNORDERED_VARIADIC_MOVE)
-            boost::unordered::detail::construct_node(alloc_,
-                boost::addressof(*node_), boost::forward<A0>(a0));
-#   else
+
            boost::unordered::detail::construct_node(alloc_,
                boost::addressof(*node_),
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0)));
-#   endif
+                BOOST_UNORDERED_EMPLACE_ARGS1(boost::forward<A0>(a0)));
+
            constructed_ = true;
            node_->init(static_cast<typename node::link_pointer>(node_));
        }
@@ -1,518 +0,0 @@
-
-// 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/unordered/detail/fwd.hpp>
-#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/type_traits/add_lvalue_reference.hpp>
-#include <boost/tuple/tuple.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/detail/select_type.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 {
-
-    ////////////////////////////////////////////////////////////////////////////
-    // Bits and pieces for implementing traits
-
-    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&);
-    };
-
-    ////////////////////////////////////////////////////////////////////////////
-    // 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, b)                     \
-        ) : 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, b)                  \
-    )                                                                       \
-    {                                                                       \
-        BOOST_PP_CAT(emplace_args, n) <                                     \
-            BOOST_PP_ENUM_PARAMS_Z(z, n, A)                                 \
-        > e(BOOST_PP_ENUM_PARAMS_Z(z, n, b));                               \
-        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(b, 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(b, 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 !defined(__SUNPRO_CC)
-
-#   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)
-
-#else
-
-    template <int N> struct length {};
-
-#   define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(n, namespace_)              \
-    template<typename T>                                                    \
-    void construct_from_tuple_impl(                                         \
-            boost::unordered::detail::length<0>, 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_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, namespace_)                  \
-    namespace_ get<n>(x)
-
-#endif
-
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, boost::)
-
-#if !defined(__SUNPRO_CC) && !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
-
-#if defined(__SUNPRO_CC)
-
-    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);
-    }
-
-#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
@@ -37,7 +37,7 @@ namespace boost { namespace unordered { namespace detail {

 #if BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT
        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
-        grouped_node(BOOST_UNORDERED_EMPLACE_ARGS) :
+        explicit grouped_node(BOOST_UNORDERED_EMPLACE_ARGS) :
            node_base(),
            group_prev_(),
            hash_(0)
@@ -49,6 +49,10 @@ namespace boost { namespace unordered { namespace detail {
        ~grouped_node() {
            boost::unordered::detail::destroy(this->value_ptr());
        }
+
+        grouped_node(grouped_node const&) {
+            assert(false);
+        }
 #else
        grouped_node() :
            node_base(),
@@ -61,6 +65,9 @@ namespace boost { namespace unordered { namespace detail {
        {
            group_prev_ = self;
        }
+
+    private:
+        grouped_node& operator=(grouped_node const&);
    };

    template <typename T>
@@ -77,7 +84,7 @@ namespace boost { namespace unordered { namespace detail {

 #if BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT
        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
-        grouped_ptr_node(BOOST_UNORDERED_EMPLACE_ARGS) :
+        explicit grouped_ptr_node(BOOST_UNORDERED_EMPLACE_ARGS) :
            bucket_base(),
            group_prev_(0),
            hash_(0)
@@ -89,6 +96,10 @@ namespace boost { namespace unordered { namespace detail {
        ~grouped_ptr_node() {
            boost::unordered::detail::destroy(this->value_ptr());
        }
+
+        grouped_ptr_node(grouped_ptr_node const&) {
+            assert(false);
+        }
 #else
        grouped_ptr_node() :
            bucket_base(),
@@ -101,6 +112,9 @@ namespace boost { namespace unordered { namespace detail {
        {
            group_prev_ = self;
        }
+
+    private:
+        grouped_ptr_node& operator=(grouped_ptr_node const&);
    };

    // If the allocator uses raw pointers use grouped_ptr_node
@@ -497,12 +511,21 @@ namespace boost { namespace unordered { namespace detail {
        }

 #if defined(BOOST_NO_RVALUE_REFERENCES)
+#   if defined(BOOST_NO_VARIADIC_TEMPLATES)
        iterator emplace(boost::unordered::detail::emplace_args1<
                boost::unordered::detail::please_ignore_this_overload> const&)
        {
            BOOST_ASSERT(false);
            return iterator();
        }
+#   else
+        iterator emplace(
+                boost::unordered::detail::please_ignore_this_overload const&)
+        {
+            BOOST_ASSERT(false);
+            return iterator();
+        }
+#   endif
 #endif

        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
@@ -56,7 +56,7 @@ namespace detail {
            return no_key();
        }
        
-#if defined(BOOST_UNORDERED_VARIADIC_MOVE)
+#if !defined(BOOST_NO_VARIADIC_TEMPLATES)
        template <class... Args>
        static no_key extract(Args const&...)
        {
@@ -111,7 +111,7 @@ namespace detail {
            return v.first;
        }

-#if defined(BOOST_UNORDERED_VARIADIC_MOVE)
+#if !defined(BOOST_NO_VARIADIC_TEMPLATES)
        template <class Arg1, class... Args>
        static key_type const& extract(key_type const& k,
            Arg1 const&, Args const&...)
@@ -150,12 +150,12 @@ namespace detail {
        }
 #endif

-#if defined(BOOST_UNORDERED_VARIADIC_MOVE)
+#if !defined(BOOST_NO_VARIADIC_TEMPLATES)

 #define BOOST_UNORDERED_KEY_FROM_TUPLE(namespace_)                          \
        template <typename T2>                                              \
        static no_key extract(boost::unordered::piecewise_construct_t,      \
-                namespace_::tuple<> const&, T2&&)                           \
+                namespace_::tuple<> const&, BOOST_FWD_REF(T2))              \
        {                                                                   \
            return no_key();                                                \
        }                                                                   \
@@ -163,7 +163,7 @@ namespace detail {
        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&&)                        \
+                namespace_::tuple<T> const& k, BOOST_FWD_REF(T2))           \
        {                                                                   \
            return typename is_key<key_type, T>::type(                      \
                namespace_::get<0>(k));                                     \
@@ -191,7 +191,7 @@ namespace detail {

 BOOST_UNORDERED_KEY_FROM_TUPLE(boost)

-#if !defined(BOOST_NO_0X_HDR_TUPLE)
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE)
 BOOST_UNORDERED_KEY_FROM_TUPLE(std)
 #endif

@@ -38,7 +38,7 @@ namespace boost { namespace unordered { namespace detail {

 #if BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT
        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
-        unique_node(BOOST_UNORDERED_EMPLACE_ARGS) :
+        explicit unique_node(BOOST_UNORDERED_EMPLACE_ARGS) :
            node_base(),
            hash_(0)
        {
@@ -49,6 +49,10 @@ namespace boost { namespace unordered { namespace detail {
        ~unique_node() {
            boost::unordered::detail::destroy(this->value_ptr());
        }
+
+        unique_node(unique_node const&) {
+            BOOST_ASSERT(false);
+        }
 #else
        unique_node() :
            node_base(),
@@ -59,6 +63,9 @@ namespace boost { namespace unordered { namespace detail {
        void init(link_pointer)
        {
        }
+
+    private:
+        unique_node& operator=(unique_node const&);
    };

    template <typename T>
@@ -74,7 +81,7 @@ namespace boost { namespace unordered { namespace detail {

 #if BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT
        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
-        ptr_node(BOOST_UNORDERED_EMPLACE_ARGS) :
+        explicit ptr_node(BOOST_UNORDERED_EMPLACE_ARGS) :
            bucket_base(),
            hash_(0)
        {
@@ -85,6 +92,10 @@ namespace boost { namespace unordered { namespace detail {
        ~ptr_node() {
            boost::unordered::detail::destroy(this->value_ptr());
        }
+
+        ptr_node(ptr_node const&) {
+            BOOST_ASSERT(false);
+        }
 #else
        ptr_node() :
            bucket_base(),
@@ -95,6 +106,9 @@ namespace boost { namespace unordered { namespace detail {
        void init(link_pointer)
        {
        }
+
+    private:
+        ptr_node& operator=(ptr_node const&);
    };

    // If the allocator uses raw pointers use ptr_node
@@ -379,38 +393,41 @@ namespace boost { namespace unordered { namespace detail {
            // exception (need strong safety in such a case).
            node_constructor a(this->node_alloc());
            a.construct_node();
-#if defined(BOOST_UNORDERED_VARIADIC_MOVE)
-            a.construct_value(boost::unordered::piecewise_construct,
-                boost::make_tuple(k), boost::make_tuple());
-#else
-            a.construct_value(
-                boost::unordered::detail::create_emplace_args(
-                    boost::unordered::piecewise_construct,
-                    boost::make_tuple(k),
-                    boost::make_tuple()));
-#endif
+
+            a.construct_value(BOOST_UNORDERED_EMPLACE_ARGS3(
+                boost::unordered::piecewise_construct,
+                boost::make_tuple(k),
+                boost::make_tuple()));
    
            this->reserve_for_insert(this->size_ + 1);
            return *add_node(a, key_hash);
        }

 #if defined(BOOST_NO_RVALUE_REFERENCES)
+#   if defined(BOOST_NO_VARIADIC_TEMPLATES)
        emplace_return emplace(boost::unordered::detail::emplace_args1<
                boost::unordered::detail::please_ignore_this_overload> const&)
        {
            BOOST_ASSERT(false);
            return emplace_return(this->begin(), false);
        }
+#   else
+        emplace_return emplace(
+                boost::unordered::detail::please_ignore_this_overload const&)
+        {
+            BOOST_ASSERT(false);
+            return emplace_return(this->begin(), false);
+        }
+#   endif
 #endif

        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
        emplace_return emplace(BOOST_UNORDERED_EMPLACE_ARGS)
        {
-#if defined(BOOST_UNORDERED_VARIADIC_MOVE)
+#if !defined(BOOST_NO_VARIADIC_TEMPLATES)
            return emplace_impl(
                extractor::extract(BOOST_UNORDERED_EMPLACE_FORWARD),
                BOOST_UNORDERED_EMPLACE_FORWARD);
-
 #else
            return emplace_impl(
                extractor::extract(args.a0, args.a1),
@@ -418,7 +435,7 @@ namespace boost { namespace unordered { namespace detail {
 #endif
        }

-#if !defined(BOOST_UNORDERED_VARIADIC_MOVE)
+#if defined(BOOST_NO_VARIADIC_TEMPLATES)
        template <typename A0>
        emplace_return emplace(
                boost::unordered::detail::emplace_args1<A0> const& args)
@@ -14,14 +14,13 @@
 #endif

 #include <boost/unordered/unordered_map_fwd.hpp>
-#include <boost/unordered/detail/allocator_helpers.hpp>
 #include <boost/unordered/detail/equivalent.hpp>
 #include <boost/unordered/detail/unique.hpp>
 #include <boost/unordered/detail/util.hpp>
 #include <boost/functional/hash.hpp>
 #include <boost/move/move.hpp>

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 #include <initializer_list>
 #endif

@@ -133,7 +132,7 @@ namespace unordered
        unordered_map(unordered_map&&, allocator_type const&);
 #endif

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
        unordered_map(
                std::initializer_list<value_type>,
                size_type = boost::unordered::detail::default_bucket_count,
@@ -176,7 +175,7 @@ namespace unordered
 #endif
 #endif

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
        unordered_map& operator=(std::initializer_list<value_type>);
 #endif

@@ -233,15 +232,15 @@ namespace unordered

        // emplace

-#if defined(BOOST_UNORDERED_VARIADIC_MOVE)
+#if !defined(BOOST_NO_VARIADIC_TEMPLATES)
        template <class... Args>
-        std::pair<iterator, bool> emplace(Args&&... args)
+        std::pair<iterator, bool> emplace(BOOST_FWD_REF(Args)... args)
        {
            return table_.emplace(boost::forward<Args>(args)...);
        }

        template <class... Args>
-        iterator emplace_hint(const_iterator, Args&&... args)
+        iterator emplace_hint(const_iterator, BOOST_FWD_REF(Args)... args)
        {
            return table_.emplace(boost::forward<Args>(args)...).first;
        }
@@ -401,7 +400,7 @@ namespace unordered

        template <class InputIt> void insert(InputIt, InputIt);

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
        void insert(std::initializer_list<value_type>);
 #endif

@@ -619,7 +618,7 @@ namespace unordered
        unordered_multimap(unordered_multimap&&, allocator_type const&);
 #endif

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
        unordered_multimap(
                std::initializer_list<value_type>,
                size_type = boost::unordered::detail::default_bucket_count,
@@ -663,7 +662,7 @@ namespace unordered
 #endif
 #endif

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
        unordered_multimap& operator=(std::initializer_list<value_type>);
 #endif

@@ -720,15 +719,15 @@ namespace unordered

        // emplace

-#if defined(BOOST_UNORDERED_VARIADIC_MOVE)
+#if !defined(BOOST_NO_VARIADIC_TEMPLATES)
        template <class... Args>
-        iterator emplace(Args&&... args)
+        iterator emplace(BOOST_FWD_REF(Args)... args)
        {
            return table_.emplace(boost::forward<Args>(args)...);
        }

        template <class... Args>
-        iterator emplace_hint(const_iterator, Args&&... args)
+        iterator emplace_hint(const_iterator, BOOST_FWD_REF(Args)... args)
        {
            return table_.emplace(boost::forward<Args>(args)...);
        }
@@ -888,7 +887,7 @@ namespace unordered

        template <class InputIt> void insert(InputIt, InputIt);

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
        void insert(std::initializer_list<value_type>);
 #endif

@@ -1088,7 +1087,7 @@ namespace unordered

 #endif

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)

    template <class K, class T, class H, class P, class A>
    unordered_map<K,T,H,P,A>::unordered_map(
@@ -1130,7 +1129,7 @@ namespace unordered
        table_.insert_range(first, last);
    }

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
    template <class K, class T, class H, class P, class A>
    void unordered_map<K,T,H,P,A>::insert(
            std::initializer_list<value_type> list)
@@ -1421,7 +1420,7 @@ namespace unordered

 #endif

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)

    template <class K, class T, class H, class P, class A>
    unordered_multimap<K,T,H,P,A>::unordered_multimap(
@@ -1463,7 +1462,7 @@ namespace unordered
        table_.insert_range(first, last);
    }

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
    template <class K, class T, class H, class P, class A>
    void unordered_multimap<K,T,H,P,A>::insert(
            std::initializer_list<value_type> list)
@@ -14,14 +14,13 @@
 #endif

 #include <boost/unordered/unordered_set_fwd.hpp>
-#include <boost/unordered/detail/allocator_helpers.hpp>
 #include <boost/unordered/detail/equivalent.hpp>
 #include <boost/unordered/detail/unique.hpp>
 #include <boost/unordered/detail/util.hpp>
 #include <boost/functional/hash.hpp>
 #include <boost/move/move.hpp>

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 #include <initializer_list>
 #endif

@@ -131,7 +130,7 @@ namespace unordered
        unordered_set(unordered_set&&, allocator_type const&);
 #endif

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
        unordered_set(
                std::initializer_list<value_type>,
                size_type = boost::unordered::detail::default_bucket_count,
@@ -174,7 +173,7 @@ namespace unordered
 #endif
 #endif

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
        unordered_set& operator=(std::initializer_list<value_type>);
 #endif

@@ -231,15 +230,15 @@ namespace unordered

        // emplace

-#if defined(BOOST_UNORDERED_VARIADIC_MOVE)
+#if !defined(BOOST_NO_VARIADIC_TEMPLATES)
        template <class... Args>
-        std::pair<iterator, bool> emplace(Args&&... args)
+        std::pair<iterator, bool> emplace(BOOST_FWD_REF(Args)... args)
        {
            return table_.emplace(boost::forward<Args>(args)...);
        }

        template <class... Args>
-        iterator emplace_hint(const_iterator, Args&&... args)
+        iterator emplace_hint(const_iterator, BOOST_FWD_REF(Args)... args)
        {
            return table_.emplace(boost::forward<Args>(args)...).first;
        }
@@ -400,7 +399,7 @@ namespace unordered

        template <class InputIt> void insert(InputIt, InputIt);

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
        void insert(std::initializer_list<value_type>);
 #endif

@@ -603,7 +602,7 @@ namespace unordered
        unordered_multiset(unordered_multiset&&, allocator_type const&);
 #endif

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
        unordered_multiset(
                std::initializer_list<value_type>,
                size_type = boost::unordered::detail::default_bucket_count,
@@ -647,7 +646,7 @@ namespace unordered
 #endif
 #endif

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
        unordered_multiset& operator=(std::initializer_list<value_type>);
 #endif

@@ -704,15 +703,15 @@ namespace unordered

        // emplace

-#if defined(BOOST_UNORDERED_VARIADIC_MOVE)
+#if !defined(BOOST_NO_VARIADIC_TEMPLATES)
        template <class... Args>
-        iterator emplace(Args&&... args)
+        iterator emplace(BOOST_FWD_REF(Args)... args)
        {
            return table_.emplace(boost::forward<Args>(args)...);
        }

        template <class... Args>
-        iterator emplace_hint(const_iterator, Args&&... args)
+        iterator emplace_hint(const_iterator, BOOST_FWD_REF(Args)... args)
        {
            return table_.emplace(boost::forward<Args>(args)...);
        }
@@ -873,7 +872,7 @@ namespace unordered

        template <class InputIt> void insert(InputIt, InputIt);

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
        void insert(std::initializer_list<value_type>);
 #endif

@@ -1063,7 +1062,7 @@ namespace unordered

 #endif

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)

    template <class T, class H, class P, class A>
    unordered_set<T,H,P,A>::unordered_set(
@@ -1105,7 +1104,7 @@ namespace unordered
        table_.insert_range(first, last);
    }

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
    template <class T, class H, class P, class A>
    void unordered_set<T,H,P,A>::insert(
            std::initializer_list<value_type> list)
@@ -1347,7 +1346,7 @@ namespace unordered

 #endif

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)

    template <class T, class H, class P, class A>
    unordered_multiset<T,H,P,A>::unordered_multiset(
@@ -1389,7 +1388,7 @@ namespace unordered
        table_.insert_range(first, last);
    }

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
    template <class T, class H, class P, class A>
    void unordered_multiset<T,H,P,A>::insert(
            std::initializer_list<value_type> list)
@@ -32,7 +32,7 @@ struct insert_test_base : public test::exception_base
        std::string scope(test::scope);

        if(scope.find("hash::operator()") == std::string::npos)
-            strong.test(x, test::exception::detail::tracker.count_allocations);
+            strong.test(x, test::detail::tracker.count_allocations);
        test::check_equivalent_keys(x);
    }
 };
@@ -49,7 +49,7 @@ struct emplace_test1 : public insert_test_base<T>
            it = this->values.begin(), end = this->values.end();
            it != end; ++it)
        {
-            strong.store(x, test::exception::detail::tracker.count_allocations);
+            strong.store(x, test::detail::tracker.count_allocations);
            x.emplace(*it);
        }
    }
@@ -67,7 +67,7 @@ struct insert_test1 : public insert_test_base<T>
            it = this->values.begin(), end = this->values.end();
            it != end; ++it)
        {
-            strong.store(x, test::exception::detail::tracker.count_allocations);
+            strong.store(x, test::detail::tracker.count_allocations);
            x.insert(*it);
        }
    }
@@ -83,7 +83,7 @@ struct insert_test2 : public insert_test_base<T>
            it = this->values.begin(), end = this->values.end();
            it != end; ++it)
        {
-            strong.store(x, test::exception::detail::tracker.count_allocations);
+            strong.store(x, test::detail::tracker.count_allocations);
            x.insert(x.begin(), *it);
        }
    }
@@ -111,7 +111,7 @@ struct insert_test4 : public insert_test_base<T>
            it = this->values.begin(), end = this->values.end();
            it != end; ++it)
        {
-            strong.store(x, test::exception::detail::tracker.count_allocations);
+            strong.store(x, test::detail::tracker.count_allocations);
            x.insert(it, boost::next(it));
        }
    }
@@ -150,7 +150,7 @@ struct insert_test_rehash1 : public insert_test_base<T>
                end = this->values.end();
            it != end && count < 10; ++it, ++count)
        {
-            strong.store(x, test::exception::detail::tracker.count_allocations);
+            strong.store(x, test::detail::tracker.count_allocations);
            pos = x.insert(pos, *it);
        }

@@ -174,7 +174,7 @@ struct insert_test_rehash2 : public insert_test_rehash1<T>
                end = this->values.end();
            it != end && count < 10; ++it, ++count)
        {
-            strong.store(x, test::exception::detail::tracker.count_allocations);
+            strong.store(x, test::detail::tracker.count_allocations);
            x.insert(*it);
        }

@@ -1,84 +0,0 @@
-
-// Copyright 2006-2009 Daniel James.
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#if !defined(BOOST_UNORDERED_TEST_MALLOC_ALLOCATOR_HEADER)
-#define BOOST_UNORDERED_TEST_MALLOC_ALLOCATOR_HEADER
-
-#include <cstddef>
-#include <cstdlib>
-#include <boost/limits.hpp>
-#include <new>
-
-#if defined(BOOST_MSVC)
-#pragma warning(push)
-#pragma warning(disable:4100) // unreferenced formal parameter
-#endif
-
-namespace test
-{
-    template <class T>
-    struct malloc_allocator
-    {
-        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;
-
-        template <class U> struct rebind { typedef malloc_allocator<U> other; };
-
-        malloc_allocator() {}
-        template <class Y> malloc_allocator(malloc_allocator<Y> const&) {}
-        malloc_allocator(malloc_allocator const&) {}
-
-        pointer address(reference r) { return &r; }
-        const_pointer address(const_reference r) { return &r; }
-
-        pointer allocate(size_type n) {
-            using namespace std;
-            T* ptr = static_cast<T*>(malloc(n * sizeof(T)));
-            if(!ptr) throw std::bad_alloc();
-            return ptr;
-        }
-
-        pointer allocate(size_type n, void const* u) { return allocate(n); }
-
-        void deallocate(pointer p, size_type) {
-            using namespace std;
-            free(p);
-        }
-        void construct(pointer p, T const& t) { new(p) T(t); }
-        void destroy(pointer p) { p->~T(); }
-
-        size_type max_size() const {
-            return (std::numeric_limits<size_type>::max)();
-        }
-
-        bool operator==(malloc_allocator const&) const { return true; }
-        bool operator!=(malloc_allocator const&) const { return false; }
-
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-        template <class T> void deallocate(T* p, size_type) {
-            using namespace std;
-            free(p);
-        }
-        char* _Charalloc(size_type n) {
-            using namespace std;
-            T* ptr = static_cast<T*>(malloc(n * sizeof(char)));
-            if(!ptr) throw std::bad_alloc();
-            return (char*) ptr;
-        }
-#endif
-    };
-}
-
-#if defined(BOOST_MSVC)
-#pragma warning(pop)
-#pragma warning(disable:4100) // unreferenced formal parameter
-#endif
-
-#endif
@@ -6,7 +6,7 @@
 #if !defined(BOOST_UNORDERED_TEST_HELPERS_CHECK_RETURN_TYPE_HEADER)
 #define BOOST_UNORDERED_TEST_HELPERS_CHECK_RETURN_TYPE_HEADER

-#include <boost/mpl/assert.hpp>
+#include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/is_convertible.hpp>

@@ -18,19 +18,19 @@ namespace test
        template <class T2>
        static void equals(T2)
        {
-            BOOST_MPL_ASSERT((boost::is_same<T1, T2>));
+            BOOST_STATIC_ASSERT((boost::is_same<T1, T2>::value));
        }

        template <class T2>
        static void equals_ref(T2&)
        {
-            BOOST_MPL_ASSERT((boost::is_same<T1, T2>));
+            BOOST_STATIC_ASSERT((boost::is_same<T1, T2>::value));
        }

        template <class T2>
        static void convertible(T2)
        {
-            BOOST_MPL_ASSERT((boost::is_convertible<T2, T1>));
+            BOOST_STATIC_ASSERT((boost::is_convertible<T2, T1>::value));
        }
    };
 }
@@ -52,30 +52,22 @@ namespace test {
        }
    };

-    template <class T>
-    struct counted_object
-    {
-        static object_count count_;
-
-        counted_object() { count_.construct(); }
-        counted_object(counted_object const&) { count_.construct(); }
-        ~counted_object() { count_.destruct(); }
-    };
-
-    template <class T> object_count counted_object<T>::count_;
-
-    struct globally_counted_object
-        : counted_object<globally_counted_object> {};
-
    // 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 {
-        object_count& global_object_count = globally_counted_object::count_;
+        object_count global_object_count;
    }
    
+    struct counted_object
+    {
+        counted_object() { global_object_count.construct(); }
+        counted_object(counted_object const&) { global_object_count.construct(); }
+        ~counted_object() { global_object_count.destruct(); }
+    };
+
    struct check_instances {
        int instances;
        
@@ -13,7 +13,6 @@
 #include <cmath>
 #include "./metafunctions.hpp"
 #include "./helpers.hpp"
-#include "./allocator.hpp"

 #if defined(BOOST_MSVC)
 #pragma warning(push)
@@ -29,10 +28,7 @@ namespace test
    {
        BOOST_DEDUCED_TYPENAME X::key_equal eq = x1.key_eq();
        typedef BOOST_DEDUCED_TYPENAME X::key_type key_type;
-        // Boost.Test was reporting memory leaks for std::set on g++-3.3.
-        // So I work around it by using malloc.
-        std::set<key_type, std::less<key_type>,
-            test::malloc_allocator<key_type> > found_;
+        std::set<key_type, std::less<key_type> > found_;

        BOOST_DEDUCED_TYPENAME X::const_iterator
            it = x1.begin(), end = x1.end();
@@ -8,10 +8,8 @@

 #include <memory>
 #include <map>
-#include <boost/mpl/apply.hpp>
 #include <boost/assert.hpp>
-#include <boost/unordered/detail/allocator_helpers.hpp>
-#include <boost/mpl/aux_/config/eti.hpp>
+#include <boost/unordered/detail/allocate.hpp>
 #include "../helpers/test.hpp"

 namespace test
@@ -53,30 +51,10 @@ namespace test
            }
        };

-        template <class Alloc>
-        struct allocator_memory_type_gen {
-            typedef std::map<memory_area, memory_track, memory_area_compare,
-                Alloc> type;
-        };
-
-#if defined(BOOST_MPL_CFG_MSVC_ETI_BUG)
-        template <>
-        struct allocator_memory_type_gen<int> {
-            typedef std::map<memory_area, memory_track, memory_area_compare>
-                type;
-        };
-#endif
-
-        template <class Alloc = std::allocator<int> >
        struct memory_tracker {
-            typedef BOOST_DEDUCED_TYPENAME
-                ::boost::unordered::detail::rebind_wrap<Alloc,
-                    std::pair<memory_area const, memory_track> >::type
-                allocator_type;
-
-            typedef BOOST_DEDUCED_TYPENAME
-                allocator_memory_type_gen<allocator_type>::type
-                allocated_memory_type;
+            typedef std::map<memory_area, memory_track, memory_area_compare,
+                    std::allocator<std::pair<memory_area const, memory_track> >
+                > allocated_memory_type;

            allocated_memory_type allocated_memory;
            unsigned int count_allocators;
@@ -139,7 +117,7 @@ namespace test
            void track_deallocate(void* ptr, std::size_t n, std::size_t size,
                int tag, bool check_tag_ = true)
            {
-                BOOST_DEDUCED_TYPENAME allocated_memory_type::iterator pos =
+                allocated_memory_type::iterator pos =
                    allocated_memory.find(
                        memory_area(ptr, (char*) ptr + n * size));
                if(pos == allocated_memory.end()) {
@@ -177,33 +155,9 @@ namespace test
        // 
        // boostinspect:nounnamed
        namespace {
-            test::detail::memory_tracker<std::allocator<int> > tracker;
+            test::detail::memory_tracker 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
@@ -8,72 +8,33 @@

 #include <boost/config.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <boost/mpl/not.hpp>
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>

 namespace test
 {
-    /*
-    struct unordered_set_type { char x[100]; };
-    struct unordered_multiset_type { char x[200]; };
-    struct unordered_map_type { char x[300]; };
-    struct unordered_multimap_type { char x[400]; };
-
-    template <class V, class H, class P, class A>
-    unordered_set_type container_type(
-            boost::unordered_set<V, H, P, A> const*);
-    template <class V, class H, class P, class A>
-    unordered_multiset_type container_type(
-            boost::unordered_multiset<V, H, P, A> const*);
-    template <class K, class M, class H, class P, class A>
-    unordered_map_type container_type(
-            boost::unordered_map<K, M, H, P, A> const*);
-    template <class K, class M, class H, class P, class A>
-    unordered_multimap_type container_type(
-            boost::unordered_multimap<K, M, H, P, A> const*);
-    */
-
    template <class Container>
    struct is_set
        : public boost::is_same<
            BOOST_DEDUCED_TYPENAME Container::key_type,
            BOOST_DEDUCED_TYPENAME Container::value_type> {};

-    template <class Container>
-    struct is_map
-        : public boost::mpl::not_<is_set<Container> > {};
-
-    struct yes_type { char x[100]; };
-    struct no_type { char x[200]; };
-
-    template <class V, class H, class P, class A>
-    yes_type has_unique_key_impl(
-            boost::unordered_set<V, H, P, A> const*);
-    template <class V, class H, class P, class A>
-    no_type has_unique_key_impl(
-            boost::unordered_multiset<V, H, P, A> const*);
-    template <class K, class M, class H, class P, class A>
-    yes_type has_unique_key_impl(
-            boost::unordered_map<K, M, H, P, A> const*);
-    template <class K, class M, class H, class P, class A>
-    no_type has_unique_key_impl(
-            boost::unordered_multimap<K, M, H, P, A> const*);
-
    template <class Container>
    struct has_unique_keys
    {
-        BOOST_STATIC_CONSTANT(bool, value = 
-            sizeof(has_unique_key_impl((Container const*)0))
-                == sizeof(yes_type));
+        BOOST_STATIC_CONSTANT(bool, value = false);
    };

-    template <class Container>
-    struct has_equivalent_keys
+    template <class V, class H, class P, class A>
+    struct has_unique_keys<boost::unordered_set<V, H, P, A> >
    {
-        BOOST_STATIC_CONSTANT(bool, value = 
-            sizeof(has_unique_key_impl((Container const*)0))
-                == sizeof(no_type));
+        BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+
+    template <class K, class M, class H, class P, class A>
+    struct has_unique_keys<boost::unordered_map<K, M, H, P, A> >
+    {
+        BOOST_STATIC_CONSTANT(bool, value = true);
    };
 }

@@ -8,7 +8,7 @@

 #include "./list.hpp"
 #include <algorithm>
-#include <boost/mpl/if.hpp>
+#include <boost/detail/select_type.hpp>
 #include "./generators.hpp"
 #include "./metafunctions.hpp"

@@ -81,10 +81,12 @@ namespace test

    template <class X>
    struct unordered_generator_base
-        : public boost::mpl::if_<
-            test::is_set<X>,
+        : public boost::detail::if_true<
+            test::is_set<X>::value
+        >::BOOST_NESTED_TEMPLATE then<
            test::unordered_generator_set<X>,
-            test::unordered_generator_map<X> >
+            test::unordered_generator_map<X>
+        >
    {
    };

@@ -8,7 +8,6 @@

 #include <boost/config.hpp>
 #include <iterator>
-#include "./metafunctions.hpp"
 #include "./equivalent.hpp"
 #include "./list.hpp"
 #include "./exception_test.hpp"
@@ -13,9 +13,6 @@
 #include <map>
 #include <iterator>
 #include <algorithm>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include "../objects/fwd.hpp"
 #include "./metafunctions.hpp"
@@ -25,21 +22,17 @@

 namespace test
 {
-    template <class X>
-    struct equals_to_compare2
-        : public boost::mpl::identity<
-            std::less<BOOST_DEDUCED_TYPENAME X::first_argument_type> >
+    template <typename X>
+    struct equals_to_compare
    {
+        typedef std::less<BOOST_DEDUCED_TYPENAME X::first_argument_type>
+            type;
    };

-    template <class X>
-    struct equals_to_compare
-        : public boost::mpl::eval_if<
-            boost::is_same<X, test::equal_to>,
-            boost::mpl::identity<test::less>,
-            equals_to_compare2<X>
-        >
+    template <>
+    struct equals_to_compare<test::equal_to>
    {
+        typedef test::less type;
    };

    template <class X1, class X2>
@@ -67,51 +60,40 @@ namespace test
                    values2.begin(), test::equivalent));
    }

-    template <class X>
-    struct ordered_set : public
-        boost::mpl::if_<
-            test::has_unique_keys<X>,
-            std::set<
-                BOOST_DEDUCED_TYPENAME X::value_type,
-                BOOST_DEDUCED_TYPENAME equals_to_compare<
-                    BOOST_DEDUCED_TYPENAME X::key_equal
-                >::type
-            >,
-            std::multiset<
-                BOOST_DEDUCED_TYPENAME X::value_type,
-                BOOST_DEDUCED_TYPENAME equals_to_compare<
-                    BOOST_DEDUCED_TYPENAME X::key_equal
-                >::type
-            >
-        > {};
+    template <typename X>
+    struct ordered_base;

-    template <class X>
-    struct ordered_map : public
-        boost::mpl::if_<
-            test::has_unique_keys<X>,
-            std::map<
-                BOOST_DEDUCED_TYPENAME X::key_type,
-                BOOST_DEDUCED_TYPENAME X::mapped_type,
-                BOOST_DEDUCED_TYPENAME equals_to_compare<
-                    BOOST_DEDUCED_TYPENAME X::key_equal
-                >::type
-            >,
-            std::multimap<
-                BOOST_DEDUCED_TYPENAME X::key_type,
-                BOOST_DEDUCED_TYPENAME X::mapped_type,
-                BOOST_DEDUCED_TYPENAME equals_to_compare<
-                    BOOST_DEDUCED_TYPENAME X::key_equal
-                >::type
-            >
-        > {};
+    template <class V, class H, class P, class A>
+    struct ordered_base<boost::unordered_set<V, H, P, A> >
+    {
+        typedef std::set<V,
+            BOOST_DEDUCED_TYPENAME equals_to_compare<P>::type>
+            type;
+    };

-    template <class X>
-    struct ordered_base : public
-        boost::mpl::eval_if<
-            test::is_set<X>,
-            test::ordered_set<X>,
-            test::ordered_map<X>
-        > {};
+    template <class V, class H, class P, class A>
+    struct ordered_base<boost::unordered_multiset<V, H, P, A> >
+    {
+        typedef std::multiset<V,
+            BOOST_DEDUCED_TYPENAME equals_to_compare<P>::type>
+            type;
+    };
+
+    template <class K, class M, class H, class P, class A>
+    struct ordered_base<boost::unordered_map<K, M, H, P, A> >
+    {
+        typedef std::map<K, M,
+            BOOST_DEDUCED_TYPENAME equals_to_compare<P>::type>
+            type;
+    };
+
+    template <class K, class M, class H, class P, class A>
+    struct ordered_base<boost::unordered_multimap<K, M, H, P, A> >
+    {
+        typedef std::multimap<K, M,
+            BOOST_DEDUCED_TYPENAME equals_to_compare<P>::type>
+            type;
+    };

    template <class X>
    class ordered : public ordered_base<X>::type
@@ -21,7 +21,8 @@ namespace test
            is_select_on_copy = 0,
            is_propagate_on_swap = 0,
            is_propagate_on_assign = 0,
-            is_propagate_on_move = 0
+            is_propagate_on_move = 0,
+            cxx11_construct = 0
        };
    };

@@ -31,7 +32,8 @@ namespace test
            is_select_on_copy = 1,
            is_propagate_on_swap = 1,
            is_propagate_on_assign = 1,
-            is_propagate_on_move = 1
+            is_propagate_on_move = 1,
+            cxx11_construct = 1
        };
    };
    
@@ -168,8 +170,8 @@ namespace test
            new(p) T(t);
        }

-#if defined(BOOST_UNORDERED_VARIADIC_MOVE)
-        template<typename... Args> void construct(T* p, Args&&... args) {
+#if !defined(BOOST_NO_VARIADIC_TEMPLATES)
+        template<typename... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
            detail::tracker.track_construct((void*) p, sizeof(T), tag_);
            new(p) T(boost::forward<Args>(args)...);
        }
@@ -291,6 +293,20 @@ namespace test
        return x.tag_ == y.tag_;
    }

+    // Function to check how many times an allocator has been selected,
+    // return 0 for other allocators.
+
+    struct convert_from_anything
+    {
+        template <typename T>
+        convert_from_anything(T const&) {}
+    };
+
+    inline int selected_count(convert_from_anything)
+    {
+        return 0;
+    }
+
    template <typename T, typename Flags>
    int selected_count(cxx11_allocator<T, Flags> const& x)
    {
@@ -13,21 +13,12 @@
 #include <boost/limits.hpp>
 #include <new>
 #include "../helpers/fwd.hpp"
-#include "../helpers/allocator.hpp"
 #include "../helpers/memory.hpp"

 namespace test
 {
 namespace exception
 {
-    namespace detail
-    {
-        namespace
-        {
-            test::detail::memory_tracker<test::malloc_allocator<int> > tracker;
-        }
-    }
-
    class object;
    class hash;
    class equal_to;
@@ -259,7 +250,7 @@ namespace exception
            UNORDERED_SCOPE(allocator::allocator()) {
                UNORDERED_EPOINT("Mock allocator default constructor.");
            }
-            detail::tracker.allocator_ref();
+            test::detail::tracker.allocator_ref();
        }

        template <class Y> allocator(allocator<Y> const& x) : tag_(x.tag_)
@@ -267,7 +258,7 @@ namespace exception
            UNORDERED_SCOPE(allocator::allocator()) {
                UNORDERED_EPOINT("Mock allocator template copy constructor.");
            }
-            detail::tracker.allocator_ref();
+            test::detail::tracker.allocator_ref();
        }

        allocator(allocator const& x) : tag_(x.tag_)
@@ -275,11 +266,11 @@ namespace exception
            UNORDERED_SCOPE(allocator::allocator()) {
                UNORDERED_EPOINT("Mock allocator copy constructor.");
            }
-            detail::tracker.allocator_ref();
+            test::detail::tracker.allocator_ref();
        }

        ~allocator() {
-            detail::tracker.allocator_unref();
+            test::detail::tracker.allocator_unref();
        }

        allocator& operator=(allocator const& x) {
@@ -317,7 +308,7 @@ namespace exception
                ptr = (T*) malloc(n * sizeof(T));
                if(!ptr) throw std::bad_alloc();
            }
-            detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
+            test::detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
            return pointer(ptr);

            //return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
@@ -333,7 +324,7 @@ namespace exception
                ptr = (T*) malloc(n * sizeof(T));
                if(!ptr) throw std::bad_alloc();
            }
-            detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
+            test::detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
            return pointer(ptr);

            //return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
@@ -343,7 +334,7 @@ namespace exception
        {
            //::operator delete((void*) p);
            if(p) {
-                detail::tracker.track_deallocate((void*) p, n, sizeof(T), tag_);
+                test::detail::tracker.track_deallocate((void*) p, n, sizeof(T), tag_);
                using namespace std;
                free(p);
            }
@@ -354,21 +345,21 @@ namespace exception
                UNORDERED_EPOINT("Mock allocator construct function.");
                new(p) T(t);
            }
-            detail::tracker.track_construct((void*) p, sizeof(T), tag_);
+            test::detail::tracker.track_construct((void*) p, sizeof(T), tag_);
        }

-#if defined(BOOST_UNORDERED_VARIADIC_MOVE)
-        template<class... Args> void construct(T* p, Args&&... args) {
-            UNORDERED_SCOPE(allocator::construct(pointer, Args&&...)) {
+#if !defined(BOOST_NO_VARIADIC_TEMPLATES)
+        template<class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
+            UNORDERED_SCOPE(allocator::construct(pointer, BOOST_FWD_REF(Args)...)) {
                UNORDERED_EPOINT("Mock allocator construct function.");
                new(p) T(boost::forward<Args>(args)...);
            }
-            detail::tracker.track_construct((void*) p, sizeof(T), tag_);
+            test::detail::tracker.track_construct((void*) p, sizeof(T), tag_);
        }
 #endif

        void destroy(T* p) {
-            detail::tracker.track_destroy((void*) p, sizeof(T), tag_);
+            test::detail::tracker.track_destroy((void*) p, sizeof(T), tag_);
            p->~T();
        }

@@ -367,8 +367,8 @@ namespace minimal

        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) {
+#if !defined(BOOST_NO_VARIADIC_TEMPLATES)
+        template<class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
            new((void*)p) T(boost::forward<Args>(args)...);
        }
 #endif
@@ -439,8 +439,8 @@ namespace minimal

        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) {
+#if !defined(BOOST_NO_VARIADIC_TEMPLATES)
+        template<class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
            new((void*)p) T(boost::forward<Args>(args)...);
        }
 #endif
@@ -22,11 +22,14 @@ namespace test
    class hash;
    class less;
    class equal_to;
-    template <class T> class allocator;
+    template <class T> class allocator1;
+    template <class T> class allocator2;
    object generate(object const*);
    implicitly_convertible generate(implicitly_convertible const*);
-    
-    class object : private globally_counted_object
+
+    inline void ignore_variable(void const*) {}
+
+    class object : private counted_object
    {
        friend class hash;
        friend class equal_to;
@@ -64,7 +67,7 @@ namespace test
        }
    };

-    class implicitly_convertible : private globally_counted_object
+    class implicitly_convertible : private counted_object
    {
        int tag1_, tag2_;
    public:
@@ -183,13 +186,100 @@ namespace test
        }
    };

+    // allocator1 and allocator2 are pretty similar.
+    // allocator1 only has the old fashioned 'construct' method and has
+    // a few less typedefs
+
    template <class T>
-    class allocator
+    class allocator1
+    {
+    public:
+        int tag_;
+
+        typedef T value_type;
+
+        template <class U> struct rebind { typedef allocator1<U> other; };
+
+        explicit allocator1(int t = 0) : tag_(t)
+        {
+            detail::tracker.allocator_ref();
+        }
+
+        template <class Y> allocator1(allocator1<Y> const& x)
+            : tag_(x.tag_)
+        {
+            detail::tracker.allocator_ref();
+        }
+
+        allocator1(allocator1 const& x)
+            : tag_(x.tag_)
+        {
+            detail::tracker.allocator_ref();
+        }
+
+        ~allocator1()
+        {
+            detail::tracker.allocator_unref();
+        }
+
+        T* allocate(std::size_t n) {
+            T* ptr(static_cast<T*>(::operator new(n * sizeof(T))));
+            detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
+            return ptr;
+        }
+
+        T* allocate(std::size_t n, void const* u)
+        {
+            T* ptr(static_cast<T*>(::operator new(n * sizeof(T))));
+            detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
+            return ptr;
+        }
+
+        void deallocate(T* p, std::size_t n)
+        {
+            detail::tracker.track_deallocate((void*) p, n, sizeof(T), tag_);
+            ::operator delete((void*) p);
+        }
+
+        void construct(T* p, T const& t) {
+            // Don't count constructions here as it isn't always called.
+            //detail::tracker.track_construct((void*) p, sizeof(T), tag_);
+            new(p) T(t);
+        }
+
+        void destroy(T* p) {
+            //detail::tracker.track_destroy((void*) p, sizeof(T), tag_);
+            p->~T();
+
+            // Work around MSVC buggy unused parameter warning.
+            ignore_variable(&p);
+        }
+
+        bool operator==(allocator1 const& x) const
+        {
+            return tag_ == x.tag_;
+        }
+
+        bool operator!=(allocator1 const& x) const
+        {
+            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>
+    class allocator2
    {
 # ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
    public:
 # else
-        template <class> friend class allocator;
+        template <class> friend class allocator2;
 # endif
        int tag_;
    public:
@@ -201,26 +291,26 @@ namespace test
        typedef T const& const_reference;
        typedef T value_type;

-        template <class U> struct rebind { typedef allocator<U> other; };
+        template <class U> struct rebind { typedef allocator2<U> other; };

-        explicit allocator(int t = 0) : tag_(t)
+        explicit allocator2(int t = 0) : tag_(t)
        {
            detail::tracker.allocator_ref();
        }
        
-        template <class Y> allocator(allocator<Y> const& x)
+        template <class Y> allocator2(allocator2<Y> const& x)
            : tag_(x.tag_)
        {
            detail::tracker.allocator_ref();
        }

-        allocator(allocator const& x)
+        allocator2(allocator2 const& x)
            : tag_(x.tag_)
        {
            detail::tracker.allocator_ref();
        }

-        ~allocator()
+        ~allocator2()
        {
            detail::tracker.allocator_unref();
        }
@@ -259,8 +349,8 @@ namespace test
            new(p) T(t);
        }

-#if defined(BOOST_UNORDERED_VARIADIC_MOVE)
-        template<class... Args> void construct(T* p, Args&&... args) {
+#if !defined(BOOST_NO_VARIADIC_TEMPLATES)
+        template<class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
            detail::tracker.track_construct((void*) p, sizeof(T), tag_);
            new(p) T(boost::forward<Args>(args)...);
        }
@@ -275,12 +365,12 @@ namespace test
            return (std::numeric_limits<size_type>::max)();
        }

-        bool operator==(allocator const& x) const
+        bool operator==(allocator2 const& x) const
        {
            return tag_ == x.tag_;
        }

-        bool operator!=(allocator const& x) const
+        bool operator!=(allocator2 const& x) const
        {
            return tag_ != x.tag_;
        }
@@ -294,7 +384,14 @@ namespace test
    };

    template <class T>
-    bool equivalent_impl(allocator<T> const& x, allocator<T> const& y,
+    bool equivalent_impl(allocator1<T> const& x, allocator1<T> const& y,
+        test::derived_type)
+    {
+        return x == y;
+    }
+
+    template <class T>
+    bool equivalent_impl(allocator2<T> const& x, allocator2<T> const& y,
        test::derived_type)
    {
        return x == y;
@@ -15,9 +15,6 @@ project unordered-test/unordered
        <toolset>darwin:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter -Wconversion -Wfloat-equal"
        #<toolset>gcc:<define>_GLIBCXX_DEBUG
        #<toolset>darwin:<define>_GLIBCXX_DEBUG
-        #<toolset>msvc:<warnings-as-errors>on
-        <toolset>gcc:<warnings-as-errors>on
-        <toolset>darwin:<warnings-as-errors>on
    ;

 test-suite unordered
@@ -3,10 +3,10 @@
 // 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/unordered/detail/allocate.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <boost/mpl/assert.hpp>
+#include <boost/static_assert.hpp>
 #include <boost/limits.hpp>

 // Boilerplate
@@ -91,15 +91,15 @@ void test_empty_allocator()
    typedef empty_allocator<int> allocator;
    typedef boost::unordered::detail::allocator_traits<allocator> traits;
 #if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 1
-    BOOST_MPL_ASSERT((boost::is_same<traits::size_type,
-        std::make_unsigned<std::ptrdiff_t>::type>));
+    BOOST_STATIC_ASSERT((boost::is_same<traits::size_type,
+        std::make_unsigned<std::ptrdiff_t>::type>::value));
 #else
-    BOOST_MPL_ASSERT((boost::is_same<traits::size_type, std::size_t>));
+    BOOST_STATIC_ASSERT((boost::is_same<traits::size_type, std::size_t>::value));
 #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_STATIC_ASSERT((boost::is_same<traits::difference_type, std::ptrdiff_t>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<traits::pointer, int*>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<traits::const_pointer, int const*>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<traits::value_type, int>::value));
    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);
@@ -129,15 +129,15 @@ void test_allocator1()
    typedef allocator1<int> allocator;
    typedef boost::unordered::detail::allocator_traits<allocator> traits;
 #if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 1
-    BOOST_MPL_ASSERT((boost::is_same<traits::size_type,
-        std::make_unsigned<std::ptrdiff_t>::type>));
+    BOOST_STATIC_ASSERT((boost::is_same<traits::size_type,
+        std::make_unsigned<std::ptrdiff_t>::type>::value));
 #else
-    BOOST_MPL_ASSERT((boost::is_same<traits::size_type, std::size_t>));
+    BOOST_STATIC_ASSERT((boost::is_same<traits::size_type, std::size_t>::value));
 #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_STATIC_ASSERT((boost::is_same<traits::difference_type, std::ptrdiff_t>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<traits::pointer, int*>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<traits::const_pointer, int const*>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<traits::value_type, int>::value));
    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);
@@ -174,11 +174,11 @@ 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_STATIC_ASSERT((boost::is_same<traits::size_type, std::size_t>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<traits::difference_type, std::ptrdiff_t>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<traits::pointer, int*>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<traits::const_pointer, int const*>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<traits::value_type, int>::value));
    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);
@@ -233,11 +233,11 @@ 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_STATIC_ASSERT((boost::is_same<traits::size_type, unsigned short>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<traits::difference_type, std::ptrdiff_t>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<traits::pointer, ptr<int> >::value));
+    BOOST_STATIC_ASSERT((boost::is_same<traits::const_pointer, ptr<int const> >::value));
+    BOOST_STATIC_ASSERT((boost::is_same<traits::value_type, int>::value));
    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);
@@ -114,18 +114,22 @@ void assign_tests2(T*,
    }
 }

-boost::unordered_set<test::object,
-    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_set;
-boost::unordered_multiset<test::object,
-    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_multiset;
 boost::unordered_map<test::object, test::object,
    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_map;
+    std::allocator<test::object> >* test_map_std_alloc;
+
+boost::unordered_set<test::object,
+    test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_set;
+boost::unordered_multiset<test::object,
+    test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_multiset;
+boost::unordered_map<test::object, test::object,
+    test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_map;
 boost::unordered_multimap<test::object, test::object,
    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_multimap;
+    test::allocator1<test::object> >* test_multimap;

 boost::unordered_set<test::object,
        test::hash, test::equal_to,
@@ -178,6 +182,7 @@ UNORDERED_AUTO_TEST(check_traits)
 }

 UNORDERED_TEST(assign_tests1, (
+        (test_map_std_alloc)
        (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)
@@ -193,7 +198,7 @@ UNORDERED_TEST(assign_tests2, (
    ((default_generator)(generate_collisions))
 )

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)

 UNORDERED_AUTO_TEST(assign_default_initializer_list) {
    std::cerr<<"Initializer List Tests\n";
@@ -208,7 +213,7 @@ UNORDERED_AUTO_TEST(assign_default_initializer_list) {

 #endif

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 UNORDERED_AUTO_TEST(assign_initializer_list)
 {
    std::cerr<<"Initializer List Tests\n";
@@ -13,21 +13,31 @@
 namespace at_tests {

 UNORDERED_AUTO_TEST(at_tests) {
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Create Map" << std::endl;
+
    boost::unordered_map<std::string, int> x;
    typedef boost::unordered_map<std::string, int>::iterator iterator;

+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Add elements" << std::endl;
+
    x["one"] = 1;
    x["two"] = 2;

+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Check existing elements" << std::endl;
+
    BOOST_TEST(x.at("one") == 1);
    BOOST_TEST(x.at("two") == 2);

+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Check missing element" << std::endl;
+
    try {
        x.at("three");
        BOOST_ERROR("Should have thrown.");
    }
    catch(std::out_of_range) {
    }
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Finished" << std::endl;
 }

 }
@@ -68,20 +68,24 @@ void tests(X* = 0, test::random_generator generator = test::default_generator)
    }
 }

-boost::unordered_set<test::object,
-    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_set;
-boost::unordered_multiset<test::object,
-    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_multiset;
-boost::unordered_map<test::object, test::object,
-    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_map;
 boost::unordered_multimap<test::object, test::object,
    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_multimap;
+    std::allocator<test::object> >* test_multimap_std_alloc;

-UNORDERED_TEST(tests, ((test_set)(test_multiset)(test_map)(test_multimap)))
+boost::unordered_set<test::object,
+    test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_set;
+boost::unordered_multiset<test::object,
+    test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_multiset;
+boost::unordered_map<test::object, test::object,
+    test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_map;
+boost::unordered_multimap<test::object, test::object,
+    test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_multimap;
+
+UNORDERED_TEST(tests, ((test_multimap_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap)))

 }

@@ -16,8 +16,7 @@
 #pragma warning(pop)
 #endif

-#include <boost/mpl/assert.hpp>
-#include <boost/mpl/bool.hpp>
+#include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/is_convertible.hpp>
 #include <boost/iterator/iterator_traits.hpp>
@@ -55,42 +54,38 @@ void container_test(X& r, T const&)

    // value_type

-    BOOST_MPL_ASSERT((boost::is_same<T, value_type>));
+    BOOST_STATIC_ASSERT((boost::is_same<T, value_type>::value));
    boost::function_requires<boost::CopyConstructibleConcept<X> >();

    // reference_type / const_reference_type

-    BOOST_MPL_ASSERT((boost::is_same<T&, reference>));
-    BOOST_MPL_ASSERT((boost::is_same<T const&, const_reference>));
+    BOOST_STATIC_ASSERT((boost::is_same<T&, reference>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<T const&, const_reference>::value));

    // iterator

    boost::function_requires<boost::InputIteratorConcept<iterator> >();
-    BOOST_MPL_ASSERT((boost::is_same<T, iterator_value_type>));
-    BOOST_MPL_ASSERT((boost::is_convertible<iterator, const_iterator>));
+    BOOST_STATIC_ASSERT((boost::is_same<T, iterator_value_type>::value));
+    BOOST_STATIC_ASSERT((boost::is_convertible<iterator, const_iterator>::value));

    // const_iterator

    boost::function_requires<boost::InputIteratorConcept<const_iterator> >();
-    BOOST_MPL_ASSERT((boost::is_same<T, const_iterator_value_type>));
+    BOOST_STATIC_ASSERT((boost::is_same<T, const_iterator_value_type>::value));

    // difference_type

-    BOOST_MPL_ASSERT((boost::mpl::bool_<
-                std::numeric_limits<difference_type>::is_signed>));
-    BOOST_MPL_ASSERT((boost::mpl::bool_<
-                std::numeric_limits<difference_type>::is_integer>));
-    BOOST_MPL_ASSERT((boost::is_same<difference_type,
-                iterator_difference_type>));
-    BOOST_MPL_ASSERT((boost::is_same<difference_type,
-                const_iterator_difference_type>));
+    BOOST_STATIC_ASSERT(std::numeric_limits<difference_type>::is_signed);
+    BOOST_STATIC_ASSERT(std::numeric_limits<difference_type>::is_integer);
+    BOOST_STATIC_ASSERT((boost::is_same<difference_type,
+                iterator_difference_type>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<difference_type,
+                const_iterator_difference_type>::value));

    // size_type

-    BOOST_MPL_ASSERT_NOT((boost::mpl::bool_<
-                std::numeric_limits<size_type>::is_signed>));
-    BOOST_MPL_ASSERT((boost::mpl::bool_<
-                std::numeric_limits<size_type>::is_integer>));
+    BOOST_STATIC_ASSERT(!std::numeric_limits<size_type>::is_signed);
+    BOOST_STATIC_ASSERT(std::numeric_limits<size_type>::is_integer);

    // size_type can represent any non-negative value type of difference_type
    // I'm not sure about either of these tests...
@@ -184,7 +179,7 @@ void unordered_set_test(X&, Key const&)
    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, key_type>));
+    BOOST_STATIC_ASSERT((boost::is_same<value_type, key_type>::value));
 }

 template <class X, class Key, class T>
@@ -193,8 +188,8 @@ void unordered_map_test(X& r, Key const& k, T const& v)
    typedef BOOST_DEDUCED_TYPENAME X::value_type value_type;
    typedef BOOST_DEDUCED_TYPENAME X::key_type key_type;

-    BOOST_MPL_ASSERT((
-        boost::is_same<value_type, std::pair<key_type const, T> >));
+    BOOST_STATIC_ASSERT((
+        boost::is_same<value_type, std::pair<key_type const, T> >::value));

    r.insert(std::pair<Key const, T>(k, v));

@@ -313,36 +308,36 @@ void unordered_test(X& x, Key& k, Hash& hf, Pred& eq)
        boost::iterator_reference<const_local_iterator>::type
        const_local_iterator_reference;

-    BOOST_MPL_ASSERT((boost::is_same<Key, key_type>));
+    BOOST_STATIC_ASSERT((boost::is_same<Key, key_type>::value));
    //boost::function_requires<boost::CopyConstructibleConcept<key_type> >();
    //boost::function_requires<boost::AssignableConcept<key_type> >();

-    BOOST_MPL_ASSERT((boost::is_same<Hash, hasher>));
+    BOOST_STATIC_ASSERT((boost::is_same<Hash, hasher>::value));
    test::check_return_type<std::size_t>::equals(hf(k));

-    BOOST_MPL_ASSERT((boost::is_same<Pred, key_equal>));
+    BOOST_STATIC_ASSERT((boost::is_same<Pred, key_equal>::value));
    test::check_return_type<bool>::convertible(eq(k, k));

    boost::function_requires<boost::InputIteratorConcept<local_iterator> >();
-    BOOST_MPL_ASSERT((boost::is_same<local_iterator_category,
-        iterator_category>));
-    BOOST_MPL_ASSERT((boost::is_same<local_iterator_difference,
-        iterator_difference>));
-    BOOST_MPL_ASSERT((boost::is_same<local_iterator_pointer,
-        iterator_pointer>));
-    BOOST_MPL_ASSERT((boost::is_same<local_iterator_reference,
-        iterator_reference>));
+    BOOST_STATIC_ASSERT((boost::is_same<local_iterator_category,
+        iterator_category>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<local_iterator_difference,
+        iterator_difference>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<local_iterator_pointer,
+        iterator_pointer>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<local_iterator_reference,
+        iterator_reference>::value));

    boost::function_requires<
        boost::InputIteratorConcept<const_local_iterator> >();
-    BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_category,
-        const_iterator_category>));
-    BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_difference,
-        const_iterator_difference>));
-    BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_pointer,
-        const_iterator_pointer>));
-    BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_reference,
-        const_iterator_reference>));
+    BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator_category,
+        const_iterator_category>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator_difference,
+        const_iterator_difference>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator_pointer,
+        const_iterator_pointer>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator_reference,
+        const_iterator_reference>::value));

    X(10, hf, eq);
    X a(10, hf, eq);
@@ -318,7 +318,7 @@ void constructor_tests2(T*,
        test::check_equivalent_keys(x);
    }

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
    std::initializer_list<BOOST_DEDUCED_TYPENAME T::value_type> list;
    
    std::cerr<<"Initializer list construct 1\n";
@@ -402,24 +402,28 @@ void map_constructor_test(T* = 0,
    test::check_equivalent_keys(x);
 }

-boost::unordered_set<test::object,
-    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_set;
-boost::unordered_multiset<test::object,
-    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_multiset;
 boost::unordered_map<test::object, test::object,
    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_map;
+    std::allocator<test::object> >* test_map_std_alloc;
+
+boost::unordered_set<test::object,
+    test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_set;
+boost::unordered_multiset<test::object,
+    test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_multiset;
+boost::unordered_map<test::object, test::object,
+    test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_map;
 boost::unordered_multimap<test::object, test::object,
    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_multimap;
+    test::allocator1<test::object> >* test_multimap;

 using test::default_generator;
 using test::generate_collisions;

 UNORDERED_TEST(constructor_tests1,
-    ((test_set)(test_multiset)(test_map)(test_multimap))
+    ((test_map_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap))
    ((default_generator)(generate_collisions))
 )

@@ -429,10 +433,10 @@ UNORDERED_TEST(constructor_tests2,
 )

 UNORDERED_TEST(map_constructor_test,
-    ((test_map)(test_multimap))
+    ((test_map_std_alloc)(test_map)(test_multimap))
 )

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)

 UNORDERED_AUTO_TEST(test_default_initializer_list) {
    std::cerr<<"Initializer List Tests\n";
@@ -443,7 +447,7 @@ UNORDERED_AUTO_TEST(test_default_initializer_list) {

 #endif

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)

 UNORDERED_AUTO_TEST(test_initializer_list) {
    std::cerr<<"Initializer List Tests\n";
@@ -155,16 +155,16 @@ void copy_construct_tests2(T* ptr,

 boost::unordered_set<test::object,
    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_set;
+    test::allocator1<test::object> >* test_set;
 boost::unordered_multiset<test::object,
    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_multiset;
+    test::allocator2<test::object> >* test_multiset;
 boost::unordered_map<test::object, test::object,
    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_map;
+    test::allocator1<test::object> >* test_map;
 boost::unordered_multimap<test::object, test::object,
    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_multimap;
+    test::allocator2<test::object> >* test_multimap;

 boost::unordered_set<test::object,
        test::hash, test::equal_to,
@@ -53,10 +53,10 @@ struct collision2_hash

 typedef boost::unordered_multimap<int, int,
    collision_hash, std::equal_to<int>,
-    test::allocator<std::pair<int const, int> > > collide_map;
+    test::allocator1<std::pair<int const, int> > > collide_map;
 typedef boost::unordered_multimap<int, int,
    collision2_hash, std::equal_to<int>,
-    test::allocator<std::pair<int const, int> > > collide_map2;
+    test::allocator2<std::pair<int const, int> > > collide_map2;
 typedef collide_map::value_type collide_value;
 typedef test::list<collide_value> collide_list;

@@ -196,16 +196,16 @@ void erase_tests1(Container*,

 boost::unordered_set<test::object,
    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_set;
+    test::allocator1<test::object> >* test_set;
 boost::unordered_multiset<test::object,
    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_multiset;
+    test::allocator2<test::object> >* test_multiset;
 boost::unordered_map<test::object, test::object,
    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_map;
+    test::allocator1<test::object> >* test_map;
 boost::unordered_multimap<test::object, test::object,
    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_multimap;
+    test::allocator2<test::object> >* test_multimap;

 using test::default_generator;
 using test::generate_collisions;
@@ -142,16 +142,16 @@ void find_compatible_keys_test(X*,

 boost::unordered_set<test::object,
    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_set;
+    test::allocator2<test::object> >* test_set;
 boost::unordered_multiset<test::object,
    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_multiset;
+    test::allocator1<test::object> >* test_multiset;
 boost::unordered_map<test::object, test::object,
    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_map;
+    test::allocator2<test::object> >* test_map;
 boost::unordered_multimap<test::object, test::object,
    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_multimap;
+    test::allocator1<test::object> >* test_multimap;

 using test::default_generator;
 using test::generate_collisions;
@@ -15,26 +15,25 @@ namespace x
    struct D { boost::unordered_map<D, D> x; };
 }

-namespace test
+namespace incomplete_test
 {
    // Declare, but don't define some types.

    struct value;
    struct hash;
    struct equals;
-    template <class T>
-    struct malloc_allocator;
+    template <class T> struct allocator;

    // Declare some instances
    
    typedef boost::unordered_map<value, value, hash, equals,
-        malloc_allocator<std::pair<value const, value> > > map;
+        allocator<std::pair<value const, value> > > map;
    typedef boost::unordered_multimap<value, value, hash, equals,
-        malloc_allocator<std::pair<value const, value> > > multimap;
+        allocator<std::pair<value const, value> > > multimap;
    typedef boost::unordered_set<value, hash, equals,
-        malloc_allocator<value> > set;
+        allocator<value> > set;
    typedef boost::unordered_multiset<value, hash, equals,
-        malloc_allocator<value> > multiset;
+        allocator<value> > multiset;
    
    // Now define the types which are stored as members, as they are needed for
    // declaring struct members.
@@ -49,12 +48,17 @@ namespace test
        bool operator()(T const&, T const&) const { return true; }
    };

-}
+    // This is a dubious way to implement an allocator, but good enough
+    // for this test.
+    template <typename T>
+    struct allocator : std::allocator<T> {
+        allocator() {}

-#include "../helpers/allocator.hpp"
+        template <typename T2>
+        allocator(const allocator<T2>& other) :
+            std::allocator<T>(other) {}
+    };

-namespace test
-{
    // Declare some members of a structs.
    //
    // Incomplete hash, equals and allocator aren't here supported at the
@@ -62,19 +66,19 @@ namespace test
    
    struct struct1 {
        boost::unordered_map<struct1, struct1, hash, equals,
-            malloc_allocator<std::pair<struct1 const, struct1> > > x;
+            allocator<std::pair<struct1 const, struct1> > > x;
    };
    struct struct2 {
        boost::unordered_multimap<struct2, struct2, hash, equals,
-            malloc_allocator<std::pair<struct2 const, struct2> > > x;
+            allocator<std::pair<struct2 const, struct2> > > x;
    };
    struct struct3 {
        boost::unordered_set<struct3, hash, equals,
-            malloc_allocator<struct3> > x;
+            allocator<struct3> > x;
    };
    struct struct4 {
        boost::unordered_multiset<struct4, hash, equals,
-            malloc_allocator<struct4> > x;
+            allocator<struct4> > x;
    };
    
    // Now define the value type.
@@ -83,15 +87,15 @@ namespace test

    // Create some instances.
    
-    test::map m1;
-    test::multimap m2;
-    test::set s1;
-    test::multiset s2;
+    incomplete_test::map m1;
+    incomplete_test::multimap m2;
+    incomplete_test::set s1;
+    incomplete_test::multiset s2;

-    test::struct1 c1;
-    test::struct2 c2;
-    test::struct3 c3;
-    test::struct4 c4;
+    incomplete_test::struct1 c1;
+    incomplete_test::struct2 c2;
+    incomplete_test::struct3 c3;
+    incomplete_test::struct4 c4;

    // Now declare, but don't define, the operators required for comparing
    // elements.
@@ -113,7 +117,7 @@ namespace test
    
    void use_types()
    {
-        test::value x;
+        incomplete_test::value x;
        m1[x] = x;
        m2.insert(std::make_pair(x, x));
        s1.insert(x);
@@ -145,5 +149,5 @@ int main() {
    // This could just be a compile test, but I like to be able to run these
    // things. It's probably irrational, but I find it reassuring.

-    test::use_types();
+    incomplete_test::use_types();
 }
@@ -410,43 +410,50 @@ void map_insert_range_test2(X*,

 boost::unordered_set<test::object,
    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_set;
-boost::unordered_multiset<test::object,
-    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_multiset;
-boost::unordered_map<test::object, test::object,
-    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_map;
+    std::allocator<test::object> >* test_set_std_alloc;
 boost::unordered_multimap<test::object, test::object,
    test::hash, test::equal_to,
-    test::allocator<test::object> >* test_multimap;
+    std::allocator<test::object> >* test_multimap_std_alloc;
+
+boost::unordered_set<test::object,
+    test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_set;
+boost::unordered_multiset<test::object,
+    test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_multiset;
+boost::unordered_map<test::object, test::object,
+    test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_map;
+boost::unordered_multimap<test::object, test::object,
+    test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_multimap;

 using test::default_generator;
 using test::generate_collisions;

 UNORDERED_TEST(unique_insert_tests1,
-    ((test_set)(test_map))
+    ((test_set_std_alloc)(test_set)(test_map))
    ((default_generator)(generate_collisions))
 )

 UNORDERED_TEST(equivalent_insert_tests1,
-    ((test_multiset)(test_multimap))
+    ((test_multimap_std_alloc)(test_multiset)(test_multimap))
    ((default_generator)(generate_collisions))
 )

 UNORDERED_TEST(insert_tests2,
-    ((test_set)(test_multiset)(test_map)(test_multimap))
+    ((test_multimap_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap))
    ((default_generator)(generate_collisions))
 )

 #if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
 UNORDERED_TEST(unique_emplace_tests1,
-    ((test_set)(test_map))
+    ((test_set_std_alloc)(test_set)(test_map))
    ((default_generator)(generate_collisions))
 )

 UNORDERED_TEST(equivalent_emplace_tests1,
-    ((test_multiset)(test_multimap))
+    ((test_multimap_std_alloc)(test_multiset)(test_multimap))
    ((default_generator)(generate_collisions))
 )
 #endif
@@ -457,16 +464,16 @@ UNORDERED_TEST(map_tests,
 )

 UNORDERED_TEST(map_insert_range_test1,
-    ((test_map)(test_multimap))
+    ((test_multimap_std_alloc)(test_map)(test_multimap))
    ((default_generator)(generate_collisions))
 )

 UNORDERED_TEST(map_insert_range_test2,
-    ((test_map)(test_multimap))
+    ((test_multimap_std_alloc)(test_map)(test_multimap))
    ((default_generator)(generate_collisions))
 )

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)

 UNORDERED_AUTO_TEST(insert_initializer_list_set)
 {
@@ -3,10 +3,10 @@
 // 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/unordered/detail/allocate.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <boost/mpl/assert.hpp>
+#include <boost/static_assert.hpp>
 #include "../objects/test.hpp"

 template <class Tp> 
@@ -41,22 +41,22 @@ void test_simple_allocator()
    typedef boost::unordered::detail::allocator_traits<
        SimpleAllocator<T> > traits;

-    BOOST_MPL_ASSERT((boost::is_same<typename traits::allocator_type, SimpleAllocator<T> >));
+    BOOST_STATIC_ASSERT((boost::is_same<typename traits::allocator_type, SimpleAllocator<T> >::value));

-    BOOST_MPL_ASSERT((boost::is_same<typename traits::value_type, T>));
+    BOOST_STATIC_ASSERT((boost::is_same<typename traits::value_type, T>::value));

-    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_STATIC_ASSERT((boost::is_same<typename traits::pointer, T* >::value));
+    BOOST_STATIC_ASSERT((boost::is_same<typename traits::const_pointer, T const*>::value));
+    //BOOST_STATIC_ASSERT((boost::is_same<typename traits::void_pointer, void* >::value));
+    //BOOST_STATIC_ASSERT((boost::is_same<typename traits::const_void_pointer, void const*>::value));

-    BOOST_MPL_ASSERT((boost::is_same<typename traits::difference_type, std::ptrdiff_t>));
+    BOOST_STATIC_ASSERT((boost::is_same<typename traits::difference_type, std::ptrdiff_t>::value));

 #if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 1
-    BOOST_MPL_ASSERT((boost::is_same<typename traits::size_type,
-        std::make_unsigned<std::ptrdiff_t>::type>));
+    BOOST_STATIC_ASSERT((boost::is_same<typename traits::size_type,
+        std::make_unsigned<std::ptrdiff_t>::type>::value));
 #else
-    BOOST_MPL_ASSERT((boost::is_same<typename traits::size_type, std::size_t>));
+    BOOST_STATIC_ASSERT((boost::is_same<typename traits::size_type, std::size_t>::value));
 #endif

    BOOST_TEST(!traits::propagate_on_container_copy_assignment::value);
@@ -162,12 +162,12 @@ namespace move_tests
 #elif defined(BOOST_HAS_NRVO)
            BOOST_TEST(
                test::global_object_count.constructions - count.constructions <=
-                (test::is_map<T>::value ? 50 : 25));
+                (test::is_set<T>::value ? 25 : 50));
            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));
+                (test::is_set<T>::value ? 50 : 100));
            BOOST_TEST(count.instances == test::global_object_count.instances);
 #endif
            test::check_container(y, v);
@@ -316,18 +316,22 @@ namespace move_tests
        }
    }

-    boost::unordered_set<test::object,
-        test::hash, test::equal_to,
-        test::allocator<test::object> >* test_set;
-    boost::unordered_multiset<test::object,
-        test::hash, test::equal_to,
-        test::allocator<test::object> >* test_multiset;
    boost::unordered_map<test::object, test::object,
        test::hash, test::equal_to,
-        test::allocator<test::object> >* test_map;
+        std::allocator<test::object> >* test_map_std_alloc;
+
+    boost::unordered_set<test::object,
+        test::hash, test::equal_to,
+        test::allocator2<test::object> >* test_set;
+    boost::unordered_multiset<test::object,
+        test::hash, test::equal_to,
+        test::allocator1<test::object> >* test_multiset;
+    boost::unordered_map<test::object, test::object,
+        test::hash, test::equal_to,
+        test::allocator1<test::object> >* test_map;
    boost::unordered_multimap<test::object, test::object,
        test::hash, test::equal_to,
-        test::allocator<test::object> >* test_multimap;
+        test::allocator2<test::object> >* test_multimap;

 boost::unordered_set<test::object,
        test::hash, test::equal_to,
@@ -367,12 +371,14 @@ boost::unordered_multimap<test::object, test::object,
    using test::generate_collisions;

    UNORDERED_TEST(move_construct_tests1, (
+            (test_map_std_alloc)
            (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_map_std_alloc)
            (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)
@@ -148,18 +148,22 @@ void swap_tests2(X* ptr = 0,
    }
 }

-boost::unordered_set<test::object,
-        test::hash, test::equal_to,
-        test::allocator<test::object> >* test_set;
-boost::unordered_multiset<test::object,
-        test::hash, test::equal_to,
-        test::allocator<test::object> >* test_multiset;
 boost::unordered_map<test::object, test::object,
        test::hash, test::equal_to,
-        test::allocator<test::object> >* test_map;
+        std::allocator<test::object> >* test_map_std_alloc;
+
+boost::unordered_set<test::object,
+        test::hash, test::equal_to,
+        test::allocator1<test::object> >* test_set;
+boost::unordered_multiset<test::object,
+        test::hash, test::equal_to,
+        test::allocator2<test::object> >* test_multiset;
+boost::unordered_map<test::object, test::object,
+        test::hash, test::equal_to,
+        test::allocator1<test::object> >* test_map;
 boost::unordered_multimap<test::object, test::object,
        test::hash, test::equal_to,
-        test::allocator<test::object> >* test_multimap;
+        test::allocator2<test::object> >* test_multimap;

 boost::unordered_set<test::object,
        test::hash, test::equal_to,
@@ -209,6 +213,7 @@ UNORDERED_AUTO_TEST(check_traits)
 }

 UNORDERED_TEST(swap_tests1, (
+    (test_map_std_alloc)
    (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)
@@ -11,23 +11,6 @@
 #include <iostream>
 #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
@@ -262,7 +245,8 @@ namespace unnecessary_copy_tests
        // the existing element.
        reset();
        x.emplace();
-#if !defined(BOOST_NO_RVALUE_REFERENCES)
+#if !defined(BOOST_NO_VARIADIC_TEMPLATES) || \
+    !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
@@ -422,7 +406,7 @@ namespace unnecessary_copy_tests
                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)
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE) || defined(BOOST_HAS_TR1_TUPLE)

        reset();
        x.emplace(boost::unordered::piecewise_construct,
Author	SHA1	Message	Date
Marshall Clow	a4076e1297	Release 1.51.0 [SVN r80098]	2012-08-20 22:07:05 +00:00
Daniel James	8683332b2c	Unordered: Merge from trunk - Avoid an incorrect MSVC unused variable warning in the tests. - Remove a `try..catch`. - Adjust SFINAE use to try to supprt g++ 3.4. Fixes #7175. - Fix some use of rvalues. - Extra info in `at_tests`. [SVN r79868]	2012-08-05 08:34:44 +00:00
Daniel James	d77453b7ad	Unordered: Merge allocator fix + improved tests. Fixes #7100 . [SVN r79547]	2012-07-15 23:58:02 +00:00
Daniel James	cf9930fe20	Unordered: Merge updated c++11 config macros. [SVN r79546]	2012-07-15 23:47:12 +00:00
Daniel James	e30a99d2fc	Unordered: Merge some of the older changes from trunk. Code reorganization, simpler tests, better use of Boost.Move. [SVN r79545]	2012-07-15 23:44:41 +00:00