Imported existing code

libraries/include/boost/unordered/detail/allocator_helpers.hpp

@@ -0,0 +1,237 @@
+
+// Copyright 2005-2009 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_UNORDERED_DETAIL_ALLOCATOR_UTILITIES_HPP_INCLUDED
+#define BOOST_UNORDERED_DETAIL_ALLOCATOR_UTILITIES_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#if (defined(BOOST_NO_STD_ALLOCATOR) || defined(BOOST_DINKUMWARE_STDLIB)) \
+    && !defined(__BORLANDC__)
+#  define BOOST_UNORDERED_USE_ALLOCATOR_UTILITIES
+#endif
+
+#if defined(BOOST_UNORDERED_USE_ALLOCATOR_UTILITIES)
+#  include <boost/detail/allocator_utilities.hpp>
+#endif
+
+#include <boost/mpl/aux_/config/eti.hpp>
+
+namespace boost {
+    namespace unordered_detail {
+
+#if defined(BOOST_UNORDERED_USE_ALLOCATOR_UTILITIES)
+        template <class Alloc, class T>
+        struct rebind_wrap : ::boost::detail::allocator::rebind_to<Alloc, T> {};
+#else
+        template <class Alloc, class T>
+        struct rebind_wrap
+        {
+            typedef BOOST_DEDUCED_TYPENAME
+                Alloc::BOOST_NESTED_TEMPLATE rebind<T>::other
+                type;
+        };
+#endif
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+        template <class T>
+        inline void reset(T& x) { x  = T(); }
+
+        template <class Ptr>
+        inline Ptr null_ptr() { return Ptr(); }
+#else
+        template <class T>
+        inline void reset_impl(T& x, ...) { x  = T(); }
+        template <class T>
+        inline void reset_impl(T*& x, int) { x  = 0; }
+        template <class T>
+        inline void reset(T& x) { reset_impl(x); }
+
+        template <class Ptr>
+        inline Ptr null_ptr() { Ptr x; reset(x); return x; }
+#endif
+
+        // Work around for Microsoft's ETI bug.
+        
+        template <class Allocator> struct allocator_value_type
+        {
+            typedef BOOST_DEDUCED_TYPENAME Allocator::value_type type;
+        };
+
+        template <class Allocator> struct allocator_pointer
+        {
+            typedef BOOST_DEDUCED_TYPENAME Allocator::pointer type;
+        };
+        
+        template <class Allocator> struct allocator_const_pointer
+        {
+            typedef BOOST_DEDUCED_TYPENAME Allocator::const_pointer type;
+        };
+        
+        template <class Allocator> struct allocator_reference
+        {
+            typedef BOOST_DEDUCED_TYPENAME Allocator::reference type;
+        };
+        
+        template <class Allocator> struct allocator_const_reference
+        {
+            typedef BOOST_DEDUCED_TYPENAME Allocator::const_reference type;
+        };
+        
+#if defined(BOOST_MPL_CFG_MSVC_ETI_BUG)
+
+        template <>
+        struct allocator_value_type<int>
+        {
+            typedef int type;
+        };
+
+        template <>
+        struct allocator_pointer<int>
+        {
+            typedef int type;
+        };
+
+        template <>
+        struct allocator_const_pointer<int>
+        {
+            typedef int type;
+        };
+
+        template <>
+        struct allocator_reference<int>
+        {
+            typedef int type;
+        };
+
+        template <>
+        struct allocator_const_reference<int>
+        {
+            typedef int type;
+        };
+
+#endif
+
+        template <class Allocator>
+        struct allocator_constructor
+        {
+            typedef BOOST_DEDUCED_TYPENAME allocator_value_type<Allocator>::type value_type;
+            typedef BOOST_DEDUCED_TYPENAME allocator_pointer<Allocator>::type pointer;
+
+            Allocator& alloc_;
+            pointer ptr_;
+            bool constructed_;
+
+            allocator_constructor(Allocator& a)
+                : alloc_(a), ptr_(), constructed_(false)
+            {
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+                    unordered_detail::reset(ptr_);
+#endif
+            }
+
+            ~allocator_constructor() {
+                if(ptr_) {
+                    if(constructed_) alloc_.destroy(ptr_);
+                    alloc_.deallocate(ptr_, 1);
+                }
+            }
+
+            template <class V>
+            void construct(V const& v) {
+                BOOST_ASSERT(!ptr_ && !constructed_);
+                ptr_ = alloc_.allocate(1);
+                alloc_.construct(ptr_, value_type(v));
+                constructed_  = true;
+            }
+
+            void construct(value_type const& v) {
+                BOOST_ASSERT(!ptr_ && !constructed_);
+                ptr_ = alloc_.allocate(1);
+                alloc_.construct(ptr_, v);
+                constructed_  = true;
+            }
+
+            pointer get() const
+            {
+                return ptr_;
+            }
+
+            // no throw
+            pointer release()
+            {
+                pointer p = ptr_;
+                constructed_ = false;
+                unordered_detail::reset(ptr_);
+                return p;
+            }
+        };
+
+        template <class Allocator>
+        struct allocator_array_constructor
+        {
+            typedef BOOST_DEDUCED_TYPENAME allocator_pointer<Allocator>::type pointer;
+
+            Allocator& alloc_;
+            pointer ptr_;
+            pointer constructed_;
+            std::size_t length_;
+
+            allocator_array_constructor(Allocator& a)
+                : alloc_(a), ptr_(), constructed_(), length_(0)
+            {
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+                unordered_detail::reset(constructed_);
+                unordered_detail::reset(ptr_);
+#endif
+            }
+
+            ~allocator_array_constructor() {
+                if (ptr_) {
+                    for(pointer p = ptr_; p != constructed_; ++p)
+                        alloc_.destroy(p);
+
+                    alloc_.deallocate(ptr_, length_);
+                }
+            }
+
+            template <class V>
+            void construct(V const& v, std::size_t l)
+            {
+                BOOST_ASSERT(!ptr_);
+                length_ = l;
+                ptr_ = alloc_.allocate(length_);
+                pointer end = ptr_ + static_cast<std::ptrdiff_t>(length_);
+                for(constructed_ = ptr_; constructed_ != end; ++constructed_)
+                    alloc_.construct(constructed_, v);
+            }
+
+            pointer get() const
+            {
+                return ptr_;
+            }
+
+            pointer release()
+            {
+                pointer p(ptr_);
+                unordered_detail::reset(ptr_);
+                return p;
+            }
+        private:
+            allocator_array_constructor(allocator_array_constructor const&);
+            allocator_array_constructor& operator=(allocator_array_constructor const&);
+        };
+    }
+}
+
+#if defined(BOOST_UNORDERED_USE_ALLOCATOR_UTILITIES)
+#  undef BOOST_UNORDERED_USE_ALLOCATOR_UTILITIES
+#endif
+
+#endif

libraries/include/boost/unordered/detail/config.hpp

@@ -0,0 +1,22 @@
+
+// Copyright 2008-2009 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_UNORDERED_DETAIL_CONFIG_HEADER)
+#define BOOST_UNORDERED_DETAIL_CONFIG_HEADER
+
+#include <boost/config.hpp>
+
+#if defined(BOOST_NO_SFINAE)
+#  define BOOST_UNORDERED_NO_HAS_MOVE_ASSIGN
+#elif defined(__GNUC__) && \
+    (__GNUC__ < 3 || __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
+#  define BOOST_UNORDERED_NO_HAS_MOVE_ASSIGN
+#elif BOOST_WORKAROUND(BOOST_INTEL, < 900) || \
+    BOOST_WORKAROUND(__EDG_VERSION__, < 304) || \
+    BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0593))
+#  define BOOST_UNORDERED_NO_HAS_MOVE_ASSIGN
+#endif
+
+#endif

libraries/include/boost/unordered/detail/hash_table.hpp

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

libraries/include/boost/unordered/detail/move.hpp

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