From ed6115361006240e3c7b02295599e4534cc55a13 Mon Sep 17 00:00:00 2001
From: Boris Kolpackov <boris@codesynthesis.com>
Date: Sat, 19 Oct 2013 08:57:20 +0200
Subject: Update internal Boost subset to 1.54.0

---
 cutl/details/boost/functional/hash/extensions.hpp | 111 ++++++++++++++++++++--
 1 file changed, 102 insertions(+), 9 deletions(-)

(limited to 'cutl/details/boost/functional/hash/extensions.hpp')

diff --git a/cutl/details/boost/functional/hash/extensions.hpp b/cutl/details/boost/functional/hash/extensions.hpp
index 2a3ae39..91771b4 100644
--- a/cutl/details/boost/functional/hash/extensions.hpp
+++ b/cutl/details/boost/functional/hash/extensions.hpp
@@ -15,6 +15,22 @@
 
 #include <cutl/details/boost/functional/hash/hash.hpp>
 #include <cutl/details/boost/detail/container_fwd.hpp>
+#include <cutl/details/boost/utility/enable_if.hpp>
+#include <cutl/details/boost/static_assert.hpp>
+#include <cutl/details/boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <cutl/details/boost/preprocessor/repetition/enum_params.hpp>
+
+#if !defined(BOOST_NO_CXX11_HDR_ARRAY)
+#   include <array>
+#endif
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE)
+#   include <tuple>
+#endif
+
+#if !defined(BOOST_NO_CXX11_HDR_MEMORY)
+#   include <memory>
+#endif
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
@@ -54,51 +70,51 @@ namespace cutl_details_boost
     std::size_t hash_value(std::pair<A, B> const& v)
     {
         std::size_t seed = 0;
-        hash_combine(seed, v.first);
-        hash_combine(seed, v.second);
+        cutl_details_boost::hash_combine(seed, v.first);
+        cutl_details_boost::hash_combine(seed, v.second);
         return seed;
     }
 
     template <class T, class A>
     std::size_t hash_value(std::vector<T, A> const& v)
     {
-        return hash_range(v.begin(), v.end());
+        return cutl_details_boost::hash_range(v.begin(), v.end());
     }
 
     template <class T, class A>
     std::size_t hash_value(std::list<T, A> const& v)
     {
-        return hash_range(v.begin(), v.end());
+        return cutl_details_boost::hash_range(v.begin(), v.end());
     }
 
     template <class T, class A>
     std::size_t hash_value(std::deque<T, A> const& v)
     {
-        return hash_range(v.begin(), v.end());
+        return cutl_details_boost::hash_range(v.begin(), v.end());
     }
 
     template <class K, class C, class A>
     std::size_t hash_value(std::set<K, C, A> const& v)
     {
-        return hash_range(v.begin(), v.end());
+        return cutl_details_boost::hash_range(v.begin(), v.end());
     }
 
     template <class K, class C, class A>
     std::size_t hash_value(std::multiset<K, C, A> const& v)
     {
-        return hash_range(v.begin(), v.end());
+        return cutl_details_boost::hash_range(v.begin(), v.end());
     }
 
     template <class K, class T, class C, class A>
     std::size_t hash_value(std::map<K, T, C, A> const& v)
     {
-        return hash_range(v.begin(), v.end());
+        return cutl_details_boost::hash_range(v.begin(), v.end());
     }
 
     template <class K, class T, class C, class A>
     std::size_t hash_value(std::multimap<K, T, C, A> const& v)
     {
-        return hash_range(v.begin(), v.end());
+        return cutl_details_boost::hash_range(v.begin(), v.end());
     }
 
     template <class T>
@@ -110,6 +126,83 @@ namespace cutl_details_boost
         return seed;
     }
 
+#if !defined(BOOST_NO_CXX11_HDR_ARRAY)
+    template <class T, std::size_t N>
+    std::size_t hash_value(std::array<T, N> const& v)
+    {
+        return cutl_details_boost::hash_range(v.begin(), v.end());
+    }
+#endif
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE)
+    namespace hash_detail {
+        template <std::size_t I, typename T>
+        inline typename cutl_details_boost::enable_if_c<(I == std::tuple_size<T>::value),
+                void>::type
+            hash_combine_tuple(std::size_t&, T const&)
+        {
+        }
+
+        template <std::size_t I, typename T>
+        inline typename cutl_details_boost::enable_if_c<(I < std::tuple_size<T>::value),
+                void>::type
+            hash_combine_tuple(std::size_t& seed, T const& v)
+        {
+            cutl_details_boost::hash_combine(seed, std::get<I>(v));
+            cutl_details_boost::hash_detail::hash_combine_tuple<I + 1>(seed, v);
+        }
+
+        template <typename T>
+        inline std::size_t hash_tuple(T const& v)
+        {
+            std::size_t seed = 0;
+            cutl_details_boost::hash_detail::hash_combine_tuple<0>(seed, v);
+            return seed;
+        }
+    }
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    template <typename... T>
+    inline std::size_t hash_value(std::tuple<T...> const& v)
+    {
+        return cutl_details_boost::hash_detail::hash_tuple(v);
+    }
+#else
+
+    inline std::size_t hash_value(std::tuple<> const& v)
+    {
+        return cutl_details_boost::hash_detail::hash_tuple(v);
+    }
+
+#   define BOOST_HASH_TUPLE_F(z, n, _)                                      \
+    template<                                                               \
+        BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)                            \
+    >                                                                       \
+    inline std::size_t hash_value(std::tuple<                               \
+        BOOST_PP_ENUM_PARAMS_Z(z, n, A)                                     \
+    > const& v)                                                             \
+    {                                                                       \
+        return cutl_details_boost::hash_detail::hash_tuple(v);                           \
+    }
+
+    BOOST_PP_REPEAT_FROM_TO(1, 11, BOOST_HASH_TUPLE_F, _)
+#   undef BOOST_HASH_TUPLE_F
+#endif
+
+#endif
+
+#if !defined(BOOST_NO_CXX11_SMART_PTR)
+    template <typename T>
+    inline std::size_t hash_value(std::shared_ptr<T> const& x) {
+        return cutl_details_boost::hash_value(x.get());
+    }
+
+    template <typename T, typename Deleter>
+    inline std::size_t hash_value(std::unique_ptr<T, Deleter> const& x) {
+        return cutl_details_boost::hash_value(x.get());
+    }
+#endif
+
     //
     // call_hash_impl
     //
-- 
cgit v1.1