passenger 5.1.4 → 5.1.5

data/src/cxx_supportlib/vendor-modified/boost/smart_ptr/detail/sp_if_array.hpp

@@ -1,34 +0,0 @@
-/*
- * Copyright (c) 2012-2014 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#ifndef BOOST_SMART_PTR_DETAIL_SP_IF_ARRAY_HPP
-#define BOOST_SMART_PTR_DETAIL_SP_IF_ARRAY_HPP
-
-#include <boost/smart_ptr/shared_ptr.hpp>
-
-namespace boost {
-    namespace detail {
-        template<class T>
-        struct sp_if_array;
-
-        template<class T>
-        struct sp_if_array<T[]> {
-            typedef boost::shared_ptr<T[]> type;
-        };
-
-        template<class T>
-        struct sp_if_size_array;
-
-        template<class T, std::size_t N>
-        struct sp_if_size_array<T[N]> {
-            typedef boost::shared_ptr<T[N]> type;
-        };
-    }
-}
-
-#endif

data/src/cxx_supportlib/vendor-modified/boost/unordered/detail/allocate.hpp

@@ -1,1128 +0,0 @@
-
-// 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)
-
-//  See http://www.boost.org/libs/unordered for documentation
-
-#ifndef BOOST_UNORDERED_ALLOCATE_HPP
-#define BOOST_UNORDERED_ALLOCATE_HPP
-
-#include <boost/config.hpp>
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#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/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_CXX11_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_CXX11_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
-
-}}}
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// Pick which version of allocator_traits to use
-//
-// 0 = Own partial implementation
-// 1 = std::allocator_traits
-// 2 = boost::container::allocator_traits
-
-#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 0
-#   elif defined(BOOST_MSVC)
-#       if BOOST_MSVC < 1400
-            // Use container's allocator_traits for older versions of Visual
-            // C++ as I don't test with them.
-#           define BOOST_UNORDERED_USE_ALLOCATOR_TRAITS 2
-#       endif
-#   endif
-#endif
-
-#if !defined(BOOST_UNORDERED_USE_ALLOCATOR_TRAITS)
-#   define BOOST_UNORDERED_USE_ALLOCATOR_TRAITS 0
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// Some utilities for implementing allocator_traits, but useful elsewhere so
-// they're always defined.
-
-#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
-#  include <type_traits>
-#endif
-
-namespace boost { namespace unordered { namespace detail {
-
-    ////////////////////////////////////////////////////////////////////////////
-    // Integral_constrant, true_type, false_type
-    //
-    // Uses the standard versions if available.
-
-#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
-
-    using std::integral_constant;
-    using std::true_type;
-    using std::false_type;
-
-#else
-
-    template <typename T, T Value>
-    struct integral_constant { enum { value = Value }; };
-
-    typedef boost::unordered::detail::integral_constant<bool, true> true_type;
-    typedef boost::unordered::detail::integral_constant<bool, false> false_type;
-
-#endif
-
-    ////////////////////////////////////////////////////////////////////////////
-    // Explicitly call a destructor
-
-#if defined(BOOST_MSVC)
-#pragma warning(push)
-#pragma warning(disable:4100) // unreferenced formal parameter
-#endif
-
-    namespace func {
-        template <class T>
-        inline void destroy(T* x) {
-            x->~T();
-        }
-    }
-
-#if defined(BOOST_MSVC)
-#pragma warning(pop)
-#endif
-
-    ////////////////////////////////////////////////////////////////////////////
-    // Expression test mechanism
-    //
-    // When SFINAE expressions are available, define
-    // BOOST_UNORDERED_HAS_FUNCTION which can check if a function call is
-    // supported by a class, otherwise define BOOST_UNORDERED_HAS_MEMBER which
-    // can detect if a class has the specified member, but not that it has the
-    // correct type, this is good enough for a passable impression of
-    // allocator_traits.
-
-#if !defined(BOOST_NO_SFINAE_EXPR)
-
-    template <typename T, unsigned int> struct expr_test;
-    template <typename T> struct expr_test<T, sizeof(char)> : T {};
-
-#   define BOOST_UNORDERED_CHECK_EXPRESSION(count, result, expression)      \
-        template <typename U>                                               \
-        static typename boost::unordered::detail::expr_test<                \
-            BOOST_PP_CAT(choice, result),                                   \
-            sizeof(for_expr_test((                                          \
-                (expression),                                               \
-            0)))>::type test(                                               \
-            BOOST_PP_CAT(choice, count))
-
-#   define BOOST_UNORDERED_DEFAULT_EXPRESSION(count, result)                \
-        template <typename U>                                               \
-        static BOOST_PP_CAT(choice, result)::type test(                     \
-            BOOST_PP_CAT(choice, count))
-
-#   define BOOST_UNORDERED_HAS_FUNCTION(name, thing, args, _)               \
-    struct BOOST_PP_CAT(has_, name)                                         \
-    {                                                                       \
-        template <typename U> static char for_expr_test(U const&);          \
-        BOOST_UNORDERED_CHECK_EXPRESSION(1, 1,                              \
-            boost::unordered::detail::make< thing >().name args);           \
-        BOOST_UNORDERED_DEFAULT_EXPRESSION(2, 2);                           \
-                                                                            \
-        enum { value = sizeof(test<T>(choose())) == sizeof(choice1::type) };\
-    }
-
-#else
-
-    template <typename T> struct identity { typedef T type; };
-
-#   define BOOST_UNORDERED_CHECK_MEMBER(count, result, name, member)        \
-                                                                            \
-    typedef typename boost::unordered::detail::identity<member>::type       \
-        BOOST_PP_CAT(check, count);                                         \
-                                                                            \
-    template <BOOST_PP_CAT(check, count) e>                                 \
-    struct BOOST_PP_CAT(test, count) {                                      \
-        typedef BOOST_PP_CAT(choice, result) type;                          \
-    };                                                                      \
-                                                                            \
-    template <class U> static typename                                      \
-        BOOST_PP_CAT(test, count)<&U::name>::type                           \
-        test(BOOST_PP_CAT(choice, count))
-
-#   define BOOST_UNORDERED_DEFAULT_MEMBER(count, result)                    \
-    template <class U> static BOOST_PP_CAT(choice, result)::type            \
-        test(BOOST_PP_CAT(choice, count))
-
-#   define BOOST_UNORDERED_HAS_MEMBER(name)                                 \
-    struct BOOST_PP_CAT(has_, name)                                         \
-    {                                                                       \
-        struct impl {                                                       \
-            struct base_mixin { int name; };                                \
-            struct base : public T, public base_mixin {};                   \
-                                                                            \
-            BOOST_UNORDERED_CHECK_MEMBER(1, 1, name, int base_mixin::*);    \
-            BOOST_UNORDERED_DEFAULT_MEMBER(2, 2);                           \
-                                                                            \
-            enum { value = sizeof(choice2::type) ==                         \
-                sizeof(test<base>(choose()))                                \
-            };                                                              \
-        };                                                                  \
-                                                                            \
-        enum { value = impl::value };                                       \
-    }
-
-#endif
-
-}}}
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// Allocator traits
-//
-// First our implementation, then later light wrappers around the alternatives
-
-#if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 0
-
-#   include <boost/limits.hpp>
-#   include <boost/utility/enable_if.hpp>
-#   include <boost/pointer_to_other.hpp>
-#   if defined(BOOST_NO_SFINAE_EXPR)
-#       include <boost/type_traits/is_same.hpp>
-#   endif
-
-#   if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && \
-        !defined(BOOST_NO_SFINAE_EXPR)
-#       define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 1
-#   else
-#       define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 0
-#   endif
-
-namespace boost { namespace unordered { namespace detail {
-
-    // TODO: Does this match std::allocator_traits<Alloc>::rebind_alloc<T>?
-    template <typename Alloc, typename T>
-    struct rebind_wrap
-    {
-        typedef typename Alloc::BOOST_NESTED_TEMPLATE rebind<T>::other type;
-    };
-
-#   if defined(BOOST_MSVC) && BOOST_MSVC <= 1400
-
-#       define BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(tname)                    \
-    template <typename Tp, typename Default>                                \
-    struct default_type_ ## tname {                                         \
-                                                                            \
-        template <typename X>                                               \
-        static choice1::type test(choice1, typename X::tname* = 0);         \
-                                                                            \
-        template <typename X>                                               \
-        static choice2::type test(choice2, void* = 0);                      \
-                                                                            \
-        struct DefaultWrap { typedef Default tname; };                      \
-                                                                            \
-        enum { value = (1 == sizeof(test<Tp>(choose()))) };                 \
-                                                                            \
-        typedef typename boost::detail::if_true<value>::                    \
-            BOOST_NESTED_TEMPLATE then<Tp, DefaultWrap>                     \
-            ::type::tname type;                                             \
-    }
-
-#   else
-
-    template <typename T, typename T2>
-    struct sfinae : T2 {};
-
-#       define BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(tname)                    \
-    template <typename Tp, typename Default>                                \
-    struct default_type_ ## tname {                                         \
-                                                                            \
-        template <typename X>                                               \
-        static typename boost::unordered::detail::sfinae<                   \
-                typename X::tname, choice1>::type                           \
-            test(choice1);                                                  \
-                                                                            \
-        template <typename X>                                               \
-        static choice2::type test(choice2);                                 \
-                                                                            \
-        struct DefaultWrap { typedef Default tname; };                      \
-                                                                            \
-        enum { value = (1 == sizeof(test<Tp>(choose()))) };                 \
-                                                                            \
-        typedef typename boost::detail::if_true<value>::                    \
-            BOOST_NESTED_TEMPLATE then<Tp, DefaultWrap>                     \
-            ::type::tname type;                                             \
-    }
-
-#   endif
-
-#   define BOOST_UNORDERED_DEFAULT_TYPE(T,tname, arg)                   \
-    typename default_type_ ## tname<T, arg>::type
-
-    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(pointer);
-    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(const_pointer);
-    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(void_pointer);
-    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(const_void_pointer);
-    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(difference_type);
-    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(size_type);
-    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_copy_assignment);
-    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_move_assignment);
-    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_swap);
-
-#   if !defined(BOOST_NO_SFINAE_EXPR)
-
-    template <typename T>
-    BOOST_UNORDERED_HAS_FUNCTION(
-        select_on_container_copy_construction, U const, (), 0
-    );
-
-    template <typename T>
-    BOOST_UNORDERED_HAS_FUNCTION(
-        max_size, U const, (), 0
-    );
-
-#       if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-
-    template <typename T, typename ValueType, typename... Args>
-    BOOST_UNORDERED_HAS_FUNCTION(
-    construct, U, (
-        boost::unordered::detail::make<ValueType*>(),
-        boost::unordered::detail::make<Args const>()...), 2
-    );
-
-#       else
-
-    template <typename T, typename ValueType>
-    BOOST_UNORDERED_HAS_FUNCTION(
-    construct, U, (
-        boost::unordered::detail::make<ValueType*>(),
-        boost::unordered::detail::make<ValueType const>()), 2
-    );
-
-#       endif
-
-    template <typename T, typename ValueType>
-    BOOST_UNORDERED_HAS_FUNCTION(
-        destroy, U, (boost::unordered::detail::make<ValueType*>()), 1
-    );
-
-#   else
-
-    template <typename T>
-    BOOST_UNORDERED_HAS_MEMBER(select_on_container_copy_construction);
-
-    template <typename T>
-    BOOST_UNORDERED_HAS_MEMBER(max_size);
-
-    template <typename T, typename ValueType>
-    BOOST_UNORDERED_HAS_MEMBER(construct);
-
-    template <typename T, typename ValueType>
-    BOOST_UNORDERED_HAS_MEMBER(destroy);
-
-#   endif
-
-    namespace func
-    {
-
-    template <typename Alloc>
-    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, void*
-        >::type = 0)
-    {
-        return rhs.select_on_container_copy_construction();
-    }
-
-    template <typename Alloc>
-    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, void*
-        >::type = 0)
-    {
-        return rhs;
-    }
-
-    template <typename SizeType, typename Alloc>
-    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 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)();
-    }
-
-    } // namespace func.
-
-    template <typename Alloc>
-    struct allocator_traits
-    {
-        typedef Alloc allocator_type;
-        typedef typename Alloc::value_type value_type;
-
-        typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, pointer, value_type*)
-            pointer;
-
-        template <typename T>
-        struct pointer_to_other : boost::pointer_to_other<pointer, T> {};
-
-        typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, const_pointer,
-            typename pointer_to_other<const value_type>::type)
-            const_pointer;
-
-        //typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, void_pointer,
-        //    typename pointer_to_other<void>::type)
-        //    void_pointer;
-        //
-        //typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, const_void_pointer,
-        //    typename pointer_to_other<const void>::type)
-        //    const_void_pointer;
-
-        typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, difference_type,
-            std::ptrdiff_t) difference_type;
-
-        typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, size_type, std::size_t)
-            size_type;
-
-        // TODO: rebind_alloc and rebind_traits
-
-        static pointer allocate(Alloc& a, size_type n)
-            { return a.allocate(n); }
-
-        // I never use this, so I'll just comment it out for now.
-        //
-        //static pointer allocate(Alloc& a, size_type n,
-        //        const_void_pointer hint)
-        //    { return DEFAULT_FUNC(allocate, pointer)(a, n, hint); }
-
-        static void deallocate(Alloc& a, pointer p, size_type n)
-            { a.deallocate(p, n); }
-
-    public:
-
-#   if BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT
-
-        template <typename T, typename... Args>
-        static typename boost::enable_if_c<
-                boost::unordered::detail::has_construct<Alloc, T, Args...>
-                ::value>::type
-            construct(Alloc& a, T* p, BOOST_FWD_REF(Args)... x)
-        {
-            a.construct(p, boost::forward<Args>(x)...);
-        }
-
-        template <typename T, typename... Args>
-        static typename boost::disable_if_c<
-                boost::unordered::detail::has_construct<Alloc, T, Args...>
-                ::value>::type
-            construct(Alloc&, T* p, BOOST_FWD_REF(Args)... x)
-        {
-            new ((void*) p) T(boost::forward<Args>(x)...);
-        }
-
-        template <typename T>
-        static typename boost::enable_if_c<
-                boost::unordered::detail::has_destroy<Alloc, T>::value>::type
-            destroy(Alloc& a, T* p)
-        {
-            a.destroy(p);
-        }
-
-        template <typename T>
-        static typename boost::disable_if_c<
-                boost::unordered::detail::has_destroy<Alloc, T>::value>::type
-            destroy(Alloc&, T* p)
-        {
-            boost::unordered::detail::func::destroy(p);
-        }
-
-#   elif !defined(BOOST_NO_SFINAE_EXPR)
-
-        template <typename T>
-        static typename boost::enable_if_c<
-                boost::unordered::detail::has_construct<Alloc, T>::value>::type
-            construct(Alloc& a, T* p, T const& x)
-        {
-            a.construct(p, x);
-        }
-
-        template <typename T>
-        static typename boost::disable_if_c<
-                boost::unordered::detail::has_construct<Alloc, T>::value>::type
-            construct(Alloc&, T* p, T const& x)
-        {
-            new ((void*) p) T(x);
-        }
-
-        template <typename T>
-        static typename boost::enable_if_c<
-                boost::unordered::detail::has_destroy<Alloc, T>::value>::type
-            destroy(Alloc& a, T* p)
-        {
-            a.destroy(p);
-        }
-
-        template <typename T>
-        static typename boost::disable_if_c<
-                boost::unordered::detail::has_destroy<Alloc, T>::value>::type
-            destroy(Alloc&, T* p)
-        {
-            boost::unordered::detail::func::destroy(p);
-        }
-
-#   else
-
-        // If we don't have SFINAE expressions, only call construct for the
-        // copy constructor for the allocator's value_type - as that's
-        // the only construct method that old fashioned allocators support.
-
-        template <typename T>
-        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 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,
-                void*>::type = 0)
-        {
-            new ((void*) p) T(x);
-        }
-
-        template <typename T>
-        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,
-                void*>::type = 0)
-        {
-            a.destroy(p);
-        }
-
-        template <typename T>
-        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,
-                void*>::type = 0)
-        {
-            boost::unordered::detail::func::destroy(p);
-        }
-
-#   endif
-
-        static size_type max_size(const Alloc& a)
-        {
-            return boost::unordered::detail::func::
-                call_max_size<size_type>(a);
-        }
-
-        // Allocator propagation on construction
-
-        static Alloc select_on_container_copy_construction(Alloc const& rhs)
-        {
-            return boost::unordered::detail::func::
-                call_select_on_container_copy_construction(rhs);
-        }
-
-        // Allocator propagation on assignment and swap.
-        // Return true if lhs is modified.
-        typedef BOOST_UNORDERED_DEFAULT_TYPE(
-            Alloc, propagate_on_container_copy_assignment, false_type)
-            propagate_on_container_copy_assignment;
-        typedef BOOST_UNORDERED_DEFAULT_TYPE(
-            Alloc,propagate_on_container_move_assignment, false_type)
-            propagate_on_container_move_assignment;
-        typedef BOOST_UNORDERED_DEFAULT_TYPE(
-            Alloc,propagate_on_container_swap,false_type)
-            propagate_on_container_swap;
-    };
-}}}
-
-#   undef BOOST_UNORDERED_DEFAULT_TYPE_TMPLT
-#   undef BOOST_UNORDERED_DEFAULT_TYPE
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// std::allocator_traits
-
-#elif BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 1
-
-#   include <memory>
-
-#   define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 1
-
-namespace boost { namespace unordered { namespace detail {
-
-    template <typename Alloc>
-    struct allocator_traits : std::allocator_traits<Alloc> {};
-
-    template <typename Alloc, typename T>
-    struct rebind_wrap
-    {
-        typedef typename std::allocator_traits<Alloc>::
-            template rebind_alloc<T> type;
-    };
-}}}
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// boost::container::allocator_traits
-
-#elif BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 2
-
-#   include <boost/container/allocator_traits.hpp>
-
-#   define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 0
-
-namespace boost { namespace unordered { namespace detail {
-
-    template <typename Alloc>
-    struct allocator_traits :
-        boost::container::allocator_traits<Alloc> {};
-
-    template <typename Alloc, typename T>
-    struct rebind_wrap :
-        boost::container::allocator_traits<Alloc>::
-            template portable_rebind_alloc<T>
-    {};
-
-}}}
-
-#else
-
-#error "Invalid BOOST_UNORDERED_USE_ALLOCATOR_TRAITS value."
-
-#endif
-
-
-namespace boost { namespace unordered { namespace detail { namespace func {
-
-    ////////////////////////////////////////////////////////////////////////////
-    // call_construct
-
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-
-#   if BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT
-
-    template <typename Alloc, typename T, typename... Args>
-    inline void call_construct(Alloc& alloc, T* address,
-        BOOST_FWD_REF(Args)... args)
-    {
-        boost::unordered::detail::allocator_traits<Alloc>::construct(alloc,
-            address, boost::forward<Args>(args)...);
-    }
-
-    template <typename Alloc, typename T>
-    inline void destroy_value_impl(Alloc& alloc, T* x) {
-        boost::unordered::detail::allocator_traits<Alloc>::destroy(alloc, x);
-    }
-
-
-#   else
-
-    template <typename Alloc, typename T, typename... Args>
-    inline void call_construct(Alloc&, T* address,
-        BOOST_FWD_REF(Args)... args)
-    {
-        new((void*) address) T(boost::forward<Args>(args)...);
-    }
-
-    template <typename Alloc, typename T>
-    inline void destroy_value_impl(Alloc&, T* x) {
-        boost::unordered::detail::func::destroy(x);
-    }
-
-
-#   endif
-
-#else
-
-    template <typename Alloc, typename T>
-    inline void destroy_value_impl(Alloc&, T* x) {
-        boost::unordered::detail::func::destroy(x);
-    }
-
-#endif
-
-    ////////////////////////////////////////////////////////////////////////////
-    // Construct from tuple
-    //
-    // Used for piecewise construction.
-
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-
-#   define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(n, namespace_)              \
-    template<typename Alloc, typename T>                                    \
-    void construct_from_tuple(Alloc& alloc, T* ptr, namespace_ tuple<>)     \
-    {                                                                       \
-        boost::unordered::detail::func::call_construct(alloc, ptr);         \
-    }                                                                       \
-                                                                            \
-    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 Alloc, typename T,                                    \
-        BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                           \
-    void construct_from_tuple(Alloc& alloc, T* ptr,                         \
-            namespace_ tuple<BOOST_PP_ENUM_PARAMS_Z(z, n, A)> const& x)     \
-    {                                                                       \
-        boost::unordered::detail::func::call_construct(alloc, ptr,          \
-            BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_GET_TUPLE_ARG, namespace_) \
-        );                                                                  \
-    }
-
-#   define BOOST_UNORDERED_GET_TUPLE_ARG(z, n, namespace_)                  \
-    namespace_ get<n>(x)
-
-#elif !defined(__SUNPRO_CC)
-
-#   define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(n, namespace_)              \
-    template<typename Alloc, typename T>                                    \
-    void construct_from_tuple(Alloc&, 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 Alloc, typename T,                                    \
-        BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                           \
-    void construct_from_tuple(Alloc&, 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 Alloc, typename T>                                    \
-    void construct_from_tuple_impl(                                         \
-            boost::unordered::detail::func::length<0>, Alloc&, 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 Alloc, typename T,                                    \
-        BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                           \
-    void construct_from_tuple_impl(                                         \
-            boost::unordered::detail::func::length<n>, Alloc&, 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 Alloc, typename T, typename Tuple>
-    void construct_from_tuple(Alloc& alloc, T* ptr, Tuple const& x)
-    {
-        construct_from_tuple_impl(
-            boost::unordered::detail::func::length<
-                boost::tuples::length<Tuple>::value>(),
-            alloc, ptr, x);
-    }
-
-#endif
-
-    ////////////////////////////////////////////////////////////////////////////
-    // Trait to check for piecewise construction.
-
-    template <typename A0>
-    struct use_piecewise {
-        static choice1::type test(choice1,
-            boost::unordered::piecewise_construct_t);
-
-        static choice2::type test(choice2, ...);
-
-        enum { value = sizeof(choice1::type) ==
-            sizeof(test(choose(), boost::unordered::detail::make<A0>())) };
-    };
-
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-
-    ////////////////////////////////////////////////////////////////////////////
-    // Construct from variadic parameters
-
-    // For the standard pair constructor.
-
-    template <typename Alloc, typename T, typename... Args>
-    inline void construct_value_impl(Alloc& alloc, T* address,
-        BOOST_FWD_REF(Args)... args)
-    {
-        boost::unordered::detail::func::call_construct(alloc,
-            address, boost::forward<Args>(args)...);
-    }
-
-    // Special case for piece_construct
-    //
-    // TODO: When possible, it might be better to use std::pair's
-    // constructor for std::piece_construct with std::tuple.
-
-    template <typename Alloc, typename A, typename B,
-        typename A0, typename A1, typename A2>
-    inline typename enable_if<use_piecewise<A0>, void>::type
-        construct_value_impl(Alloc& alloc, std::pair<A, B>* address,
-            BOOST_FWD_REF(A0), BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
-    {
-        boost::unordered::detail::func::construct_from_tuple(alloc,
-            boost::addressof(address->first), boost::forward<A1>(a1));
-        boost::unordered::detail::func::construct_from_tuple(alloc,
-            boost::addressof(address->second), boost::forward<A2>(a2));
-    }
-
-#else // BOOST_NO_CXX11_VARIADIC_TEMPLATES
-
-////////////////////////////////////////////////////////////////////////////////
-// Construct from emplace_args
-
-    // Explicitly write out first three overloads for the sake of sane
-    // error messages.
-
-    template <typename Alloc, typename T, typename A0>
-    inline void construct_value_impl(Alloc&, T* address,
-            emplace_args1<A0> const& args)
-    {
-        new((void*) address) T(boost::forward<A0>(args.a0));
-    }
-
-    template <typename Alloc, typename T, typename A0, typename A1>
-    inline void construct_value_impl(Alloc&, T* address,
-            emplace_args2<A0, A1> const& args)
-    {
-        new((void*) address) T(
-            boost::forward<A0>(args.a0),
-            boost::forward<A1>(args.a1)
-        );
-    }
-
-    template <typename Alloc, typename T, typename A0, typename A1, typename A2>
-    inline void construct_value_impl(Alloc&, 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)
-        );
-    }
-
-    // Use a macro for the rest.
-
-#define BOOST_UNORDERED_CONSTRUCT_IMPL(z, num_params, _)                    \
-    template <                                                              \
-        typename Alloc, typename T,                                         \
-        BOOST_PP_ENUM_PARAMS_Z(z, num_params, typename A)                   \
-    >                                                                       \
-    inline void construct_value_impl(Alloc&, 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));                                                   \
-    }
-
-    BOOST_PP_REPEAT_FROM_TO(4, BOOST_UNORDERED_EMPLACE_LIMIT,
-        BOOST_UNORDERED_CONSTRUCT_IMPL, _)
-
-#undef BOOST_UNORDERED_CONSTRUCT_IMPL
-
-    // Construct with piece_construct
-
-    template <typename Alloc, typename A, typename B,
-        typename A0, typename A1, typename A2>
-    inline void construct_value_impl(Alloc& alloc, std::pair<A, B>* address,
-            boost::unordered::detail::emplace_args3<A0, A1, A2> const& args,
-            typename enable_if<use_piecewise<A0>, void*>::type = 0)
-    {
-        boost::unordered::detail::func::construct_from_tuple(alloc,
-            boost::addressof(address->first), args.a1);
-        boost::unordered::detail::func::construct_from_tuple(alloc,
-            boost::addressof(address->second), args.a2);
-    }
-
-#endif // BOOST_NO_CXX11_VARIADIC_TEMPLATES
-
-}}}}
-
-namespace boost { namespace unordered { namespace detail {
-
-    ////////////////////////////////////////////////////////////////////////////
-    //
-    // array_constructor
-    //
-    // Allocate and construct an array in an exception safe manner, and
-    // clean up if an exception is thrown before the container takes charge
-    // of it.
-
-    template <typename Allocator>
-    struct array_constructor
-    {
-        typedef boost::unordered::detail::allocator_traits<Allocator> traits;
-        typedef typename traits::pointer pointer;
-
-        Allocator& alloc_;
-        pointer ptr_;
-        pointer constructed_;
-        std::size_t length_;
-
-        array_constructor(Allocator& a)
-            : alloc_(a), ptr_(), constructed_(), length_(0)
-        {
-            constructed_ = pointer();
-            ptr_ = pointer();
-        }
-
-        ~array_constructor() {
-            if (ptr_) {
-                for(pointer p = ptr_; p != constructed_; ++p) {
-                    boost::unordered::detail::func::destroy(
-                            boost::addressof(*p));
-                }
-
-                traits::deallocate(alloc_, ptr_, length_);
-            }
-        }
-
-        template <typename V>
-        void construct(V const& v, std::size_t l)
-        {
-            BOOST_ASSERT(!ptr_);
-            length_ = l;
-            ptr_ = traits::allocate(alloc_, length_);
-            pointer end = ptr_ + static_cast<std::ptrdiff_t>(length_);
-            for(constructed_ = ptr_; constructed_ != end; ++constructed_) {
-                new ((void*) boost::addressof(*constructed_)) V(v);
-            }
-        }
-
-        pointer get() const
-        {
-            return ptr_;
-        }
-
-        pointer release()
-        {
-            pointer p(ptr_);
-            ptr_ = pointer();
-            return p;
-        }
-
-    private:
-
-        array_constructor(array_constructor const&);
-        array_constructor& operator=(array_constructor const&);
-    };
-}}}
-
-#if defined(BOOST_MSVC)
-#pragma warning(pop)
-#endif
-
-#endif