diff options
Diffstat (limited to 'boost/functional')
| -rw-r--r-- | boost/functional/factory.hpp | 51 | ||||
| -rw-r--r-- | boost/functional/forward_adapter.hpp | 2 | ||||
| -rw-r--r-- | boost/functional/hash.hpp | 3 | ||||
| -rw-r--r-- | boost/functional/hash/detail/float_functions.hpp | 336 | ||||
| -rw-r--r-- | boost/functional/hash/detail/hash_float.hpp | 271 | ||||
| -rw-r--r-- | boost/functional/hash/detail/limits.hpp | 62 | ||||
| -rw-r--r-- | boost/functional/hash/extensions.hpp | 316 | ||||
| -rw-r--r-- | boost/functional/hash/hash.hpp | 593 | ||||
| -rw-r--r-- | boost/functional/hash/hash_fwd.hpp | 32 | ||||
| -rw-r--r-- | boost/functional/hash_fwd.hpp | 7 | ||||
| -rw-r--r-- | boost/functional/lightweight_forward_adapter.hpp | 2 |
11 files changed, 52 insertions, 1623 deletions
diff --git a/boost/functional/factory.hpp b/boost/functional/factory.hpp index 67fee71d6c..92f67d9b60 100644 --- a/boost/functional/factory.hpp +++ b/boost/functional/factory.hpp @@ -12,6 +12,7 @@ # include <boost/preprocessor/iteration/iterate.hpp> # include <boost/preprocessor/repetition/enum_params.hpp> # include <boost/preprocessor/repetition/enum_binary_params.hpp> +# include <boost/preprocessor/repetition/enum_trailing_params.hpp> # include <new> # include <boost/pointee.hpp> @@ -74,15 +75,26 @@ namespace boost template< class Pointer, class Allocator, factory_alloc_propagation AP > class factory +#if defined(BOOST_NO_CXX11_ALLOCATOR) : private Allocator::template rebind< typename boost::pointee< typename boost::remove_cv<Pointer>::type >::type >::other +#else + : private std::allocator_traits<Allocator>::template rebind_alloc< + typename boost::pointee< typename boost::remove_cv<Pointer>::type >::type > +#endif { public: typedef typename boost::remove_cv<Pointer>::type result_type; typedef typename boost::pointee<result_type>::type value_type; +#if defined(BOOST_NO_CXX11_ALLOCATOR) typedef typename Allocator::template rebind<value_type>::other allocator_type; +#else + typedef typename std::allocator_traits<Allocator>::template rebind_alloc<value_type> + allocator_type; + typedef std::allocator_traits<allocator_type> allocator_traits; +#endif explicit factory(allocator_type const & a = allocator_type()) : allocator_type(a) @@ -105,9 +117,16 @@ namespace boost void operator()(value_type* ptr) const { - if (!! ptr) ptr->~value_type(); - const_cast<allocator_type*>(static_cast<allocator_type const*>( - this))->deallocate(ptr,1); + if (!! ptr) { +#if defined(BOOST_NO_CXX11_ALLOCATOR) + ptr->~value_type(); + const_cast<allocator_type*>(static_cast<allocator_type const*>( + this))->deallocate(ptr,1); +#else + allocator_traits::destroy(this->get_allocator(), ptr); + allocator_traits::deallocate(this->get_allocator(),ptr,1); +#endif + } } }; @@ -162,14 +181,30 @@ namespace boost # endif inline result_type operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,T,& a)) const { +#if defined(BOOST_NO_CXX11_ALLOCATOR) value_type* memory = this->get_allocator().allocate(1); +#else + value_type* memory = allocator_traits::allocate(this->get_allocator(), 1); +#endif try - { - return make_pointer( - new(memory) value_type(BOOST_PP_ENUM_PARAMS(N,a)), - boost::non_type<factory_alloc_propagation,AP>() ); + { +#if defined(BOOST_NO_CXX11_ALLOCATOR) + new(memory) value_type(BOOST_PP_ENUM_PARAMS(N,a)); +#else + allocator_traits::construct(this->get_allocator(), memory + BOOST_PP_ENUM_TRAILING_PARAMS(N,a)); +#endif } - catch (...) { this->get_allocator().deallocate(memory,1); throw; } + catch (...) { +#if defined(BOOST_NO_CXX11_ALLOCATOR) + this->get_allocator().deallocate(memory,1); +#else + allocator_traits::deallocate(this->get_allocator(), memory, 1); +#endif + throw; + } + + return make_pointer(memory, boost::non_type<factory_alloc_propagation,AP>()); } # endif # undef N diff --git a/boost/functional/forward_adapter.hpp b/boost/functional/forward_adapter.hpp index 6023fc2ae5..0d486a6821 100644 --- a/boost/functional/forward_adapter.hpp +++ b/boost/functional/forward_adapter.hpp @@ -10,7 +10,7 @@ # ifndef BOOST_PP_IS_ITERATING # include <boost/config.hpp> -# include <boost/detail/workaround.hpp> +# include <boost/config/workaround.hpp> # include <boost/preprocessor/iteration/iterate.hpp> # include <boost/preprocessor/repetition/enum_params.hpp> diff --git a/boost/functional/hash.hpp b/boost/functional/hash.hpp index 44983f19b2..327a3ecae7 100644 --- a/boost/functional/hash.hpp +++ b/boost/functional/hash.hpp @@ -3,5 +3,4 @@ // 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/functional/hash/hash.hpp> - +#include <boost/container_hash/hash.hpp> diff --git a/boost/functional/hash/detail/float_functions.hpp b/boost/functional/hash/detail/float_functions.hpp deleted file mode 100644 index f3db52f9cc..0000000000 --- a/boost/functional/hash/detail/float_functions.hpp +++ /dev/null @@ -1,336 +0,0 @@ - -// 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) - -#if !defined(BOOST_FUNCTIONAL_HASH_DETAIL_FLOAT_FUNCTIONS_HPP) -#define BOOST_FUNCTIONAL_HASH_DETAIL_FLOAT_FUNCTIONS_HPP - -#include <boost/config.hpp> -#if defined(BOOST_HAS_PRAGMA_ONCE) -#pragma once -#endif - -#include <boost/config/no_tr1/cmath.hpp> - -// Set BOOST_HASH_CONFORMANT_FLOATS to 1 for libraries known to have -// sufficiently good floating point support to not require any -// workarounds. -// -// When set to 0, the library tries to automatically -// use the best available implementation. This normally works well, but -// breaks when ambiguities are created by odd namespacing of the functions. -// -// Note that if this is set to 0, the library should still take full -// advantage of the platform's floating point support. - -#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION) -# define BOOST_HASH_CONFORMANT_FLOATS 0 -#elif defined(__LIBCOMO__) -# define BOOST_HASH_CONFORMANT_FLOATS 0 -#elif defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER) -// Rogue Wave library: -# define BOOST_HASH_CONFORMANT_FLOATS 0 -#elif defined(_LIBCPP_VERSION) -// libc++ -# define BOOST_HASH_CONFORMANT_FLOATS 1 -#elif defined(__GLIBCPP__) || defined(__GLIBCXX__) -// GNU libstdc++ 3 -# if defined(__GNUC__) && __GNUC__ >= 4 -# define BOOST_HASH_CONFORMANT_FLOATS 1 -# else -# define BOOST_HASH_CONFORMANT_FLOATS 0 -# endif -#elif defined(__STL_CONFIG_H) -// generic SGI STL -# define BOOST_HASH_CONFORMANT_FLOATS 0 -#elif defined(__MSL_CPP__) -// MSL standard lib: -# define BOOST_HASH_CONFORMANT_FLOATS 0 -#elif defined(__IBMCPP__) -// VACPP std lib (probably conformant for much earlier version). -# if __IBMCPP__ >= 1210 -# define BOOST_HASH_CONFORMANT_FLOATS 1 -# else -# define BOOST_HASH_CONFORMANT_FLOATS 0 -# endif -#elif defined(MSIPL_COMPILE_H) -// Modena C++ standard library -# define BOOST_HASH_CONFORMANT_FLOATS 0 -#elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER) -// Dinkumware Library (this has to appear after any possible replacement libraries): -# if _CPPLIB_VER >= 405 -# define BOOST_HASH_CONFORMANT_FLOATS 1 -# else -# define BOOST_HASH_CONFORMANT_FLOATS 0 -# endif -#else -# define BOOST_HASH_CONFORMANT_FLOATS 0 -#endif - -#if BOOST_HASH_CONFORMANT_FLOATS - -// The standard library is known to be compliant, so don't use the -// configuration mechanism. - -namespace boost { - namespace hash_detail { - template <typename Float> - struct call_ldexp { - typedef Float float_type; - inline Float operator()(Float x, int y) const { - return std::ldexp(x, y); - } - }; - - template <typename Float> - struct call_frexp { - typedef Float float_type; - inline Float operator()(Float x, int* y) const { - return std::frexp(x, y); - } - }; - - template <typename Float> - struct select_hash_type - { - typedef Float type; - }; - } -} - -#else // BOOST_HASH_CONFORMANT_FLOATS == 0 - -// The C++ standard requires that the C float functions are overloarded -// for float, double and long double in the std namespace, but some of the older -// library implementations don't support this. On some that don't, the C99 -// float functions (frexpf, frexpl, etc.) are available. -// -// The following tries to automatically detect which are available. - -namespace boost { - namespace hash_detail { - - // Returned by dummy versions of the float functions. - - struct not_found { - // Implicitly convertible to float and long double in order to avoid - // a compile error when the dummy float functions are used. - - inline operator float() const { return 0; } - inline operator long double() const { return 0; } - }; - - // A type for detecting the return type of functions. - - template <typename T> struct is; - template <> struct is<float> { char x[10]; }; - template <> struct is<double> { char x[20]; }; - template <> struct is<long double> { char x[30]; }; - template <> struct is<boost::hash_detail::not_found> { char x[40]; }; - - // Used to convert the return type of a function to a type for sizeof. - - template <typename T> is<T> float_type(T); - - // call_ldexp - // - // This will get specialized for float and long double - - template <typename Float> struct call_ldexp - { - typedef double float_type; - - inline double operator()(double a, int b) const - { - using namespace std; - return ldexp(a, b); - } - }; - - // call_frexp - // - // This will get specialized for float and long double - - template <typename Float> struct call_frexp - { - typedef double float_type; - - inline double operator()(double a, int* b) const - { - using namespace std; - return frexp(a, b); - } - }; - } -} - -// A namespace for dummy functions to detect when the actual function we want -// isn't available. ldexpl, ldexpf etc. might be added tby the macros below. -// -// AFAICT these have to be outside of the boost namespace, as if they're in -// the boost namespace they'll always be preferable to any other function -// (since the arguments are built in types, ADL can't be used). - -namespace boost_hash_detect_float_functions { - template <class Float> boost::hash_detail::not_found ldexp(Float, int); - template <class Float> boost::hash_detail::not_found frexp(Float, int*); -} - -// Macros for generating specializations of call_ldexp and call_frexp. -// -// check_cpp and check_c99 check if the C++ or C99 functions are available. -// -// Then the call_* functions select an appropriate implementation. -// -// I used c99_func in a few places just to get a unique name. -// -// Important: when using 'using namespace' at namespace level, include as -// little as possible in that namespace, as Visual C++ has an odd bug which -// can cause the namespace to be imported at the global level. This seems to -// happen mainly when there's a template in the same namesapce. - -#define BOOST_HASH_CALL_FLOAT_FUNC(cpp_func, c99_func, type1, type2) \ -namespace boost_hash_detect_float_functions { \ - template <class Float> \ - boost::hash_detail::not_found c99_func(Float, type2); \ -} \ - \ -namespace boost { \ - namespace hash_detail { \ - namespace c99_func##_detect { \ - using namespace std; \ - using namespace boost_hash_detect_float_functions; \ - \ - struct check { \ - static type1 x; \ - static type2 y; \ - BOOST_STATIC_CONSTANT(bool, cpp = \ - sizeof(float_type(cpp_func(x,y))) \ - == sizeof(is<type1>)); \ - BOOST_STATIC_CONSTANT(bool, c99 = \ - sizeof(float_type(c99_func(x,y))) \ - == sizeof(is<type1>)); \ - }; \ - } \ - \ - template <bool x> \ - struct call_c99_##c99_func : \ - boost::hash_detail::call_##cpp_func<double> {}; \ - \ - template <> \ - struct call_c99_##c99_func<true> { \ - typedef type1 float_type; \ - \ - template <typename T> \ - inline type1 operator()(type1 a, T b) const \ - { \ - using namespace std; \ - return c99_func(a, b); \ - } \ - }; \ - \ - template <bool x> \ - struct call_cpp_##c99_func : \ - call_c99_##c99_func< \ - ::boost::hash_detail::c99_func##_detect::check::c99 \ - > {}; \ - \ - template <> \ - struct call_cpp_##c99_func<true> { \ - typedef type1 float_type; \ - \ - template <typename T> \ - inline type1 operator()(type1 a, T b) const \ - { \ - using namespace std; \ - return cpp_func(a, b); \ - } \ - }; \ - \ - template <> \ - struct call_##cpp_func<type1> : \ - call_cpp_##c99_func< \ - ::boost::hash_detail::c99_func##_detect::check::cpp \ - > {}; \ - } \ -} - -#define BOOST_HASH_CALL_FLOAT_MACRO(cpp_func, c99_func, type1, type2) \ -namespace boost { \ - namespace hash_detail { \ - \ - template <> \ - struct call_##cpp_func<type1> { \ - typedef type1 float_type; \ - inline type1 operator()(type1 x, type2 y) const { \ - return c99_func(x, y); \ - } \ - }; \ - } \ -} - -#if defined(ldexpf) -BOOST_HASH_CALL_FLOAT_MACRO(ldexp, ldexpf, float, int) -#else -BOOST_HASH_CALL_FLOAT_FUNC(ldexp, ldexpf, float, int) -#endif - -#if defined(ldexpl) -BOOST_HASH_CALL_FLOAT_MACRO(ldexp, ldexpl, long double, int) -#else -BOOST_HASH_CALL_FLOAT_FUNC(ldexp, ldexpl, long double, int) -#endif - -#if defined(frexpf) -BOOST_HASH_CALL_FLOAT_MACRO(frexp, frexpf, float, int*) -#else -BOOST_HASH_CALL_FLOAT_FUNC(frexp, frexpf, float, int*) -#endif - -#if defined(frexpl) -BOOST_HASH_CALL_FLOAT_MACRO(frexp, frexpl, long double, int*) -#else -BOOST_HASH_CALL_FLOAT_FUNC(frexp, frexpl, long double, int*) -#endif - -#undef BOOST_HASH_CALL_FLOAT_MACRO -#undef BOOST_HASH_CALL_FLOAT_FUNC - - -namespace boost -{ - namespace hash_detail - { - template <typename Float1, typename Float2> - struct select_hash_type_impl { - typedef double type; - }; - - template <> - struct select_hash_type_impl<float, float> { - typedef float type; - }; - - template <> - struct select_hash_type_impl<long double, long double> { - typedef long double type; - }; - - - // select_hash_type - // - // If there is support for a particular floating point type, use that - // otherwise use double (there's always support for double). - - template <typename Float> - struct select_hash_type : select_hash_type_impl< - BOOST_DEDUCED_TYPENAME call_ldexp<Float>::float_type, - BOOST_DEDUCED_TYPENAME call_frexp<Float>::float_type - > {}; - } -} - -#endif // BOOST_HASH_CONFORMANT_FLOATS - -#endif diff --git a/boost/functional/hash/detail/hash_float.hpp b/boost/functional/hash/detail/hash_float.hpp deleted file mode 100644 index 1816c57e9a..0000000000 --- a/boost/functional/hash/detail/hash_float.hpp +++ /dev/null @@ -1,271 +0,0 @@ - -// Copyright 2005-2012 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_FUNCTIONAL_HASH_DETAIL_HASH_FLOAT_HEADER) -#define BOOST_FUNCTIONAL_HASH_DETAIL_HASH_FLOAT_HEADER - -#include <boost/config.hpp> -#if defined(BOOST_HAS_PRAGMA_ONCE) -#pragma once -#endif - -#include <boost/functional/hash/detail/float_functions.hpp> -#include <boost/functional/hash/detail/limits.hpp> -#include <boost/utility/enable_if.hpp> -#include <boost/integer/static_log2.hpp> -#include <boost/cstdint.hpp> -#include <boost/assert.hpp> -#include <boost/limits.hpp> -#include <cstring> - -#if defined(BOOST_MSVC) -#pragma warning(push) -#if BOOST_MSVC >= 1400 -#pragma warning(disable:6294) // Ill-defined for-loop: initial condition does - // not satisfy test. Loop body not executed -#endif -#endif - -// Can we use fpclassify? - -// STLport -#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION) -#define BOOST_HASH_USE_FPCLASSIFY 0 - -// GNU libstdc++ 3 -#elif defined(__GLIBCPP__) || defined(__GLIBCXX__) -# if (defined(__USE_ISOC99) || defined(_GLIBCXX_USE_C99_MATH)) && \ - !(defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)) -# define BOOST_HASH_USE_FPCLASSIFY 1 -# else -# define BOOST_HASH_USE_FPCLASSIFY 0 -# endif - -// Everything else -#else -# define BOOST_HASH_USE_FPCLASSIFY 0 -#endif - -namespace boost -{ - namespace hash_detail - { - inline void hash_float_combine(std::size_t& seed, std::size_t value) - { - seed ^= value + (seed<<6) + (seed>>2); - } - - //////////////////////////////////////////////////////////////////////// - // Binary hash function - // - // Only used for floats with known iec559 floats, and certain values in - // numeric_limits - - inline std::size_t hash_binary(char* ptr, std::size_t length) - { - std::size_t seed = 0; - - if (length >= sizeof(std::size_t)) { - std::memcpy(&seed, ptr, sizeof(std::size_t)); - length -= sizeof(std::size_t); - ptr += sizeof(std::size_t); - - while(length >= sizeof(std::size_t)) { - std::size_t buffer = 0; - std::memcpy(&buffer, ptr, sizeof(std::size_t)); - hash_float_combine(seed, buffer); - length -= sizeof(std::size_t); - ptr += sizeof(std::size_t); - } - } - - if (length > 0) { - std::size_t buffer = 0; - std::memcpy(&buffer, ptr, length); - hash_float_combine(seed, buffer); - } - - return seed; - } - - template <typename Float, unsigned digits, unsigned max_exponent> - struct enable_binary_hash - { - BOOST_STATIC_CONSTANT(bool, value = - std::numeric_limits<Float>::is_iec559 && - std::numeric_limits<Float>::digits == digits && - std::numeric_limits<Float>::radix == 2 && - std::numeric_limits<Float>::max_exponent == max_exponent); - }; - - template <typename Float> - inline std::size_t float_hash_impl(Float v, - BOOST_DEDUCED_TYPENAME boost::enable_if_c< - enable_binary_hash<Float, 24, 128>::value, - std::size_t>::type) - { - return hash_binary((char*) &v, 4); - } - - - template <typename Float> - inline std::size_t float_hash_impl(Float v, - BOOST_DEDUCED_TYPENAME boost::enable_if_c< - enable_binary_hash<Float, 53, 1024>::value, - std::size_t>::type) - { - return hash_binary((char*) &v, 8); - } - - template <typename Float> - inline std::size_t float_hash_impl(Float v, - BOOST_DEDUCED_TYPENAME boost::enable_if_c< - enable_binary_hash<Float, 64, 16384>::value, - std::size_t>::type) - { - return hash_binary((char*) &v, 10); - } - - template <typename Float> - inline std::size_t float_hash_impl(Float v, - BOOST_DEDUCED_TYPENAME boost::enable_if_c< - enable_binary_hash<Float, 113, 16384>::value, - std::size_t>::type) - { - return hash_binary((char*) &v, 16); - } - - //////////////////////////////////////////////////////////////////////// - // Portable hash function - // - // Used as a fallback when the binary hash function isn't supported. - - template <class T> - inline std::size_t float_hash_impl2(T v) - { - boost::hash_detail::call_frexp<T> frexp; - boost::hash_detail::call_ldexp<T> ldexp; - - int exp = 0; - - v = frexp(v, &exp); - - // A postive value is easier to hash, so combine the - // sign with the exponent and use the absolute value. - if(v < 0) { - v = -v; - exp += limits<T>::max_exponent - - limits<T>::min_exponent; - } - - v = ldexp(v, limits<std::size_t>::digits); - std::size_t seed = static_cast<std::size_t>(v); - v -= static_cast<T>(seed); - - // ceiling(digits(T) * log2(radix(T))/ digits(size_t)) - 1; - std::size_t const length - = (limits<T>::digits * - boost::static_log2<limits<T>::radix>::value - + limits<std::size_t>::digits - 1) - / limits<std::size_t>::digits; - - for(std::size_t i = 0; i != length; ++i) - { - v = ldexp(v, limits<std::size_t>::digits); - std::size_t part = static_cast<std::size_t>(v); - v -= static_cast<T>(part); - hash_float_combine(seed, part); - } - - hash_float_combine(seed, static_cast<std::size_t>(exp)); - - return seed; - } - -#if !defined(BOOST_HASH_DETAIL_TEST_WITHOUT_GENERIC) - template <class T> - inline std::size_t float_hash_impl(T v, ...) - { - typedef BOOST_DEDUCED_TYPENAME select_hash_type<T>::type type; - return float_hash_impl2(static_cast<type>(v)); - } -#endif - } -} - -#if BOOST_HASH_USE_FPCLASSIFY - -#include <boost/config/no_tr1/cmath.hpp> - -namespace boost -{ - namespace hash_detail - { - template <class T> - inline std::size_t float_hash_value(T v) - { -#if defined(fpclassify) - switch (fpclassify(v)) -#elif BOOST_HASH_CONFORMANT_FLOATS - switch (std::fpclassify(v)) -#else - using namespace std; - switch (fpclassify(v)) -#endif - { - case FP_ZERO: - return 0; - case FP_INFINITE: - return (std::size_t)(v > 0 ? -1 : -2); - case FP_NAN: - return (std::size_t)(-3); - case FP_NORMAL: - case FP_SUBNORMAL: - return float_hash_impl(v, 0); - default: - BOOST_ASSERT(0); - return 0; - } - } - } -} - -#else // !BOOST_HASH_USE_FPCLASSIFY - -namespace boost -{ - namespace hash_detail - { - template <class T> - inline bool is_zero(T v) - { -#if !defined(__GNUC__) && !defined(__clang__) - return v == 0; -#else - // GCC's '-Wfloat-equal' will complain about comparing - // v to 0, but because it disables warnings for system - // headers it won't complain if you use std::equal_to to - // compare with 0. Resulting in this silliness: - return std::equal_to<T>()(v, 0); -#endif - } - - template <class T> - inline std::size_t float_hash_value(T v) - { - return boost::hash_detail::is_zero(v) ? 0 : float_hash_impl(v, 0); - } - } -} - -#endif // BOOST_HASH_USE_FPCLASSIFY - -#undef BOOST_HASH_USE_FPCLASSIFY - -#if defined(BOOST_MSVC) -#pragma warning(pop) -#endif - -#endif diff --git a/boost/functional/hash/detail/limits.hpp b/boost/functional/hash/detail/limits.hpp deleted file mode 100644 index 4a971a6ac2..0000000000 --- a/boost/functional/hash/detail/limits.hpp +++ /dev/null @@ -1,62 +0,0 @@ - -// 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) -// -// On some platforms std::limits gives incorrect values for long double. -// This tries to work around them. - -#if !defined(BOOST_FUNCTIONAL_HASH_DETAIL_LIMITS_HEADER) -#define BOOST_FUNCTIONAL_HASH_DETAIL_LIMITS_HEADER - -#include <boost/config.hpp> -#if defined(BOOST_HAS_PRAGMA_ONCE) -#pragma once -#endif - -#include <boost/limits.hpp> - -// On OpenBSD, numeric_limits is not reliable for long doubles, but -// the macros defined in <float.h> are and support long double when STLport -// doesn't. - -#if defined(__OpenBSD__) || defined(_STLP_NO_LONG_DOUBLE) -#include <float.h> -#endif - -namespace boost -{ - namespace hash_detail - { - template <class T> - struct limits : std::numeric_limits<T> {}; - -#if defined(__OpenBSD__) || defined(_STLP_NO_LONG_DOUBLE) - template <> - struct limits<long double> - : std::numeric_limits<long double> - { - static long double epsilon() { - return LDBL_EPSILON; - } - - static long double (max)() { - return LDBL_MAX; - } - - static long double (min)() { - return LDBL_MIN; - } - - BOOST_STATIC_CONSTANT(int, digits = LDBL_MANT_DIG); - BOOST_STATIC_CONSTANT(int, max_exponent = LDBL_MAX_EXP); - BOOST_STATIC_CONSTANT(int, min_exponent = LDBL_MIN_EXP); -#if defined(_STLP_NO_LONG_DOUBLE) - BOOST_STATIC_CONSTANT(int, radix = FLT_RADIX); -#endif - }; -#endif // __OpenBSD__ - } -} - -#endif diff --git a/boost/functional/hash/extensions.hpp b/boost/functional/hash/extensions.hpp index cb3c85623b..ab14211d74 100644 --- a/boost/functional/hash/extensions.hpp +++ b/boost/functional/hash/extensions.hpp @@ -1,318 +1,6 @@ -// Copyright 2005-2009 Daniel James. +// Copyright 2017 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) -// Based on Peter Dimov's proposal -// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf -// issue 6.18. - -// This implements the extensions to the standard. -// It's undocumented, so you shouldn't use it.... - -#if !defined(BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP) -#define BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP - -#include <boost/config.hpp> -#if defined(BOOST_HAS_PRAGMA_ONCE) -#pragma once -#endif - -#include <boost/functional/hash/hash.hpp> -#include <boost/detail/container_fwd.hpp> -#include <boost/utility/enable_if.hpp> -#include <boost/static_assert.hpp> -#include <boost/preprocessor/repetition/repeat_from_to.hpp> -#include <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(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) -#include <boost/type_traits/is_array.hpp> -#endif - -namespace boost -{ - template <class A, class B> - std::size_t hash_value(std::pair<A, B> const&); - template <class T, class A> - std::size_t hash_value(std::vector<T, A> const&); - template <class T, class A> - std::size_t hash_value(std::list<T, A> const& v); - template <class T, class A> - std::size_t hash_value(std::deque<T, A> const& v); - template <class K, class C, class A> - std::size_t hash_value(std::set<K, C, A> const& v); - template <class K, class C, class A> - std::size_t hash_value(std::multiset<K, C, A> const& v); - template <class K, class T, class C, class A> - std::size_t hash_value(std::map<K, T, C, A> const& v); - template <class K, class T, class C, class A> - std::size_t hash_value(std::multimap<K, T, C, A> const& v); - - template <class T> - std::size_t hash_value(std::complex<T> const&); - - template <class A, class B> - std::size_t hash_value(std::pair<A, B> const& v) - { - std::size_t seed = 0; - boost::hash_combine(seed, v.first); - 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 boost::hash_range(v.begin(), v.end()); - } - - template <class T, class A> - std::size_t hash_value(std::list<T, A> const& v) - { - return boost::hash_range(v.begin(), v.end()); - } - - template <class T, class A> - std::size_t hash_value(std::deque<T, A> const& v) - { - return 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 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 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 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 boost::hash_range(v.begin(), v.end()); - } - - template <class T> - std::size_t hash_value(std::complex<T> const& v) - { - boost::hash<T> hasher; - std::size_t seed = hasher(v.imag()); - seed ^= hasher(v.real()) + (seed<<6) + (seed>>2); - 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 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 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 boost::enable_if_c<(I < std::tuple_size<T>::value), - void>::type - hash_combine_tuple(std::size_t& seed, T const& v) - { - boost::hash_combine(seed, std::get<I>(v)); - 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; - 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 boost::hash_detail::hash_tuple(v); - } -#else - - inline std::size_t hash_value(std::tuple<> const& v) - { - return 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 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 boost::hash_value(x.get()); - } - - template <typename T, typename Deleter> - inline std::size_t hash_value(std::unique_ptr<T, Deleter> const& x) { - return boost::hash_value(x.get()); - } -#endif - - // - // call_hash_impl - // - - // On compilers without function template ordering, this deals with arrays. - -#if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) - namespace hash_detail - { - template <bool IsArray> - struct call_hash_impl - { - template <class T> - struct inner - { - static std::size_t call(T const& v) - { - using namespace boost; - return hash_value(v); - } - }; - }; - - template <> - struct call_hash_impl<true> - { - template <class Array> - struct inner - { - static std::size_t call(Array const& v) - { - const int size = sizeof(v) / sizeof(*v); - return boost::hash_range(v, v + size); - } - }; - }; - - template <class T> - struct call_hash - : public call_hash_impl<boost::is_array<T>::value> - ::BOOST_NESTED_TEMPLATE inner<T> - { - }; - } -#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING - - // - // boost::hash - // - - -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - - template <class T> struct hash - : boost::hash_detail::hash_base<T> - { -#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) - std::size_t operator()(T const& val) const - { - return hash_value(val); - } -#else - std::size_t operator()(T const& val) const - { - return hash_detail::call_hash<T>::call(val); - } -#endif - }; - -#if BOOST_WORKAROUND(__DMC__, <= 0x848) - template <class T, unsigned int n> struct hash<T[n]> - : boost::hash_detail::hash_base<T[n]> - { - std::size_t operator()(const T* val) const - { - return boost::hash_range(val, val+n); - } - }; -#endif - -#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - - // On compilers without partial specialization, boost::hash<T> - // has already been declared to deal with pointers, so just - // need to supply the non-pointer version of hash_impl. - - namespace hash_detail - { - template <bool IsPointer> - struct hash_impl; - - template <> - struct hash_impl<false> - { - template <class T> - struct inner - : boost::hash_detail::hash_base<T> - { -#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) - std::size_t operator()(T const& val) const - { - return hash_value(val); - } -#else - std::size_t operator()(T const& val) const - { - return hash_detail::call_hash<T>::call(val); - } -#endif - }; - }; - } -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -} - -#endif +#include <boost/container_hash/extensions.hpp> diff --git a/boost/functional/hash/hash.hpp b/boost/functional/hash/hash.hpp index b461f5f0d7..327a3ecae7 100644 --- a/boost/functional/hash/hash.hpp +++ b/boost/functional/hash/hash.hpp @@ -1,595 +1,6 @@ -// Copyright 2005-2014 Daniel James. +// 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) -// Based on Peter Dimov's proposal -// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf -// issue 6.18. -// -// This also contains public domain code from MurmurHash. From the -// MurmurHash header: - -// MurmurHash3 was written by Austin Appleby, and is placed in the public -// domain. The author hereby disclaims copyright to this source code. - -#if !defined(BOOST_FUNCTIONAL_HASH_HASH_HPP) -#define BOOST_FUNCTIONAL_HASH_HASH_HPP - -#include <boost/functional/hash/hash_fwd.hpp> -#include <functional> -#include <boost/functional/hash/detail/hash_float.hpp> -#include <string> -#include <boost/limits.hpp> -#include <boost/type_traits/is_enum.hpp> -#include <boost/type_traits/is_integral.hpp> -#include <boost/utility/enable_if.hpp> -#include <boost/cstdint.hpp> - -#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) -#include <boost/type_traits/is_pointer.hpp> -#endif - -#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX) -#include <typeindex> -#endif - -#if defined(BOOST_MSVC) -#pragma warning(push) - -#if BOOST_MSVC >= 1400 -#pragma warning(disable:6295) // Ill-defined for-loop : 'unsigned int' values - // are always of range '0' to '4294967295'. - // Loop executes infinitely. -#endif - -#endif - -#if BOOST_WORKAROUND(__GNUC__, < 3) \ - && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) -#define BOOST_HASH_CHAR_TRAITS string_char_traits -#else -#define BOOST_HASH_CHAR_TRAITS char_traits -#endif - -#if defined(_MSC_VER) -# define BOOST_FUNCTIONAL_HASH_ROTL32(x, r) _rotl(x,r) -#else -# define BOOST_FUNCTIONAL_HASH_ROTL32(x, r) (x << r) | (x >> (32 - r)) -#endif - -namespace boost -{ - namespace hash_detail - { -#if defined(_HAS_AUTO_PTR_ETC) && !_HAS_AUTO_PTR_ETC - template <typename T> - struct hash_base - { - typedef T argument_type; - typedef std::size_t result_type; - }; -#else - template <typename T> - struct hash_base : std::unary_function<T, std::size_t> {}; -#endif - - struct enable_hash_value { typedef std::size_t type; }; - - template <typename T> struct basic_numbers {}; - template <typename T> struct long_numbers; - template <typename T> struct ulong_numbers; - template <typename T> struct float_numbers {}; - - template <> struct basic_numbers<bool> : - boost::hash_detail::enable_hash_value {}; - template <> struct basic_numbers<char> : - boost::hash_detail::enable_hash_value {}; - template <> struct basic_numbers<unsigned char> : - boost::hash_detail::enable_hash_value {}; - template <> struct basic_numbers<signed char> : - boost::hash_detail::enable_hash_value {}; - template <> struct basic_numbers<short> : - boost::hash_detail::enable_hash_value {}; - template <> struct basic_numbers<unsigned short> : - boost::hash_detail::enable_hash_value {}; - template <> struct basic_numbers<int> : - boost::hash_detail::enable_hash_value {}; - template <> struct basic_numbers<unsigned int> : - boost::hash_detail::enable_hash_value {}; - template <> struct basic_numbers<long> : - boost::hash_detail::enable_hash_value {}; - template <> struct basic_numbers<unsigned long> : - boost::hash_detail::enable_hash_value {}; - -#if !defined(BOOST_NO_INTRINSIC_WCHAR_T) - template <> struct basic_numbers<wchar_t> : - boost::hash_detail::enable_hash_value {}; -#endif - -#if !defined(BOOST_NO_CXX11_CHAR16_T) - template <> struct basic_numbers<char16_t> : - boost::hash_detail::enable_hash_value {}; -#endif - -#if !defined(BOOST_NO_CXX11_CHAR32_T) - template <> struct basic_numbers<char32_t> : - boost::hash_detail::enable_hash_value {}; -#endif - - // long_numbers is defined like this to allow for separate - // specialization for long_long and int128_type, in case - // they conflict. - template <typename T> struct long_numbers2 {}; - template <typename T> struct ulong_numbers2 {}; - template <typename T> struct long_numbers : long_numbers2<T> {}; - template <typename T> struct ulong_numbers : ulong_numbers2<T> {}; - -#if !defined(BOOST_NO_LONG_LONG) - template <> struct long_numbers<boost::long_long_type> : - boost::hash_detail::enable_hash_value {}; - template <> struct ulong_numbers<boost::ulong_long_type> : - boost::hash_detail::enable_hash_value {}; -#endif - -#if defined(BOOST_HAS_INT128) - template <> struct long_numbers2<boost::int128_type> : - boost::hash_detail::enable_hash_value {}; - template <> struct ulong_numbers2<boost::uint128_type> : - boost::hash_detail::enable_hash_value {}; -#endif - - template <> struct float_numbers<float> : - boost::hash_detail::enable_hash_value {}; - template <> struct float_numbers<double> : - boost::hash_detail::enable_hash_value {}; - template <> struct float_numbers<long double> : - boost::hash_detail::enable_hash_value {}; - } - - template <typename T> - typename boost::hash_detail::basic_numbers<T>::type hash_value(T); - template <typename T> - typename boost::hash_detail::long_numbers<T>::type hash_value(T); - template <typename T> - typename boost::hash_detail::ulong_numbers<T>::type hash_value(T); - - template <typename T> - typename boost::enable_if<boost::is_enum<T>, std::size_t>::type - hash_value(T); - -#if !BOOST_WORKAROUND(__DMC__, <= 0x848) - template <class T> std::size_t hash_value(T* const&); -#else - template <class T> std::size_t hash_value(T*); -#endif - -#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) - template< class T, unsigned N > - std::size_t hash_value(const T (&x)[N]); - - template< class T, unsigned N > - std::size_t hash_value(T (&x)[N]); -#endif - - template <class Ch, class A> - std::size_t hash_value( - std::basic_string<Ch, std::BOOST_HASH_CHAR_TRAITS<Ch>, A> const&); - - template <typename T> - typename boost::hash_detail::float_numbers<T>::type hash_value(T); - -#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX) - std::size_t hash_value(std::type_index); -#endif - - // Implementation - - namespace hash_detail - { - template <class T> - inline std::size_t hash_value_signed(T val) - { - const unsigned int size_t_bits = std::numeric_limits<std::size_t>::digits; - // ceiling(std::numeric_limits<T>::digits / size_t_bits) - 1 - const int length = (std::numeric_limits<T>::digits - 1) - / static_cast<int>(size_t_bits); - - std::size_t seed = 0; - T positive = val < 0 ? -1 - val : val; - - // Hopefully, this loop can be unrolled. - for(unsigned int i = length * size_t_bits; i > 0; i -= size_t_bits) - { - seed ^= (std::size_t) (positive >> i) + (seed<<6) + (seed>>2); - } - seed ^= (std::size_t) val + (seed<<6) + (seed>>2); - - return seed; - } - - template <class T> - inline std::size_t hash_value_unsigned(T val) - { - const unsigned int size_t_bits = std::numeric_limits<std::size_t>::digits; - // ceiling(std::numeric_limits<T>::digits / size_t_bits) - 1 - const int length = (std::numeric_limits<T>::digits - 1) - / static_cast<int>(size_t_bits); - - std::size_t seed = 0; - - // Hopefully, this loop can be unrolled. - for(unsigned int i = length * size_t_bits; i > 0; i -= size_t_bits) - { - seed ^= (std::size_t) (val >> i) + (seed<<6) + (seed>>2); - } - seed ^= (std::size_t) val + (seed<<6) + (seed>>2); - - return seed; - } - - template <typename SizeT> - inline void hash_combine_impl(SizeT& seed, SizeT value) - { - seed ^= value + 0x9e3779b9 + (seed<<6) + (seed>>2); - } - - inline void hash_combine_impl(boost::uint32_t& h1, - boost::uint32_t k1) - { - const uint32_t c1 = 0xcc9e2d51; - const uint32_t c2 = 0x1b873593; - - k1 *= c1; - k1 = BOOST_FUNCTIONAL_HASH_ROTL32(k1,15); - k1 *= c2; - - h1 ^= k1; - h1 = BOOST_FUNCTIONAL_HASH_ROTL32(h1,13); - h1 = h1*5+0xe6546b64; - } - - -// Don't define 64-bit hash combine on platforms without 64 bit integers, -// and also not for 32-bit gcc as it warns about the 64-bit constant. -#if !defined(BOOST_NO_INT64_T) && \ - !(defined(__GNUC__) && ULONG_MAX == 0xffffffff) - - inline void hash_combine_impl(boost::uint64_t& h, - boost::uint64_t k) - { - const boost::uint64_t m = UINT64_C(0xc6a4a7935bd1e995); - const int r = 47; - - k *= m; - k ^= k >> r; - k *= m; - - h ^= k; - h *= m; - - // Completely arbitrary number, to prevent 0's - // from hashing to 0. - h += 0xe6546b64; - } - -#endif // BOOST_NO_INT64_T - } - - template <typename T> - typename boost::hash_detail::basic_numbers<T>::type hash_value(T v) - { - return static_cast<std::size_t>(v); - } - - template <typename T> - typename boost::hash_detail::long_numbers<T>::type hash_value(T v) - { - return hash_detail::hash_value_signed(v); - } - - template <typename T> - typename boost::hash_detail::ulong_numbers<T>::type hash_value(T v) - { - return hash_detail::hash_value_unsigned(v); - } - - template <typename T> - typename boost::enable_if<boost::is_enum<T>, std::size_t>::type - hash_value(T v) - { - return static_cast<std::size_t>(v); - } - - // Implementation by Alberto Barbati and Dave Harris. -#if !BOOST_WORKAROUND(__DMC__, <= 0x848) - template <class T> std::size_t hash_value(T* const& v) -#else - template <class T> std::size_t hash_value(T* v) -#endif - { -#if defined(__VMS) && __INITIAL_POINTER_SIZE == 64 - // for some reason ptrdiff_t on OpenVMS compiler with - // 64 bit is not 64 bit !!! - std::size_t x = static_cast<std::size_t>( - reinterpret_cast<long long int>(v)); -#else - std::size_t x = static_cast<std::size_t>( - reinterpret_cast<std::ptrdiff_t>(v)); -#endif - return x + (x >> 3); - } - -#if defined(BOOST_MSVC) -#pragma warning(push) -#if BOOST_MSVC <= 1400 -#pragma warning(disable:4267) // 'argument' : conversion from 'size_t' to - // 'unsigned int', possible loss of data - // A misguided attempt to detect 64-bit - // incompatability. -#endif -#endif - - template <class T> - inline void hash_combine(std::size_t& seed, T const& v) - { - boost::hash<T> hasher; - return boost::hash_detail::hash_combine_impl(seed, hasher(v)); - } - -#if defined(BOOST_MSVC) -#pragma warning(pop) -#endif - - template <class It> - inline std::size_t hash_range(It first, It last) - { - std::size_t seed = 0; - - for(; first != last; ++first) - { - hash_combine(seed, *first); - } - - return seed; - } - - template <class It> - inline void hash_range(std::size_t& seed, It first, It last) - { - for(; first != last; ++first) - { - hash_combine(seed, *first); - } - } - -#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551)) - template <class T> - inline std::size_t hash_range(T* first, T* last) - { - std::size_t seed = 0; - - for(; first != last; ++first) - { - boost::hash<T> hasher; - seed ^= hasher(*first) + 0x9e3779b9 + (seed<<6) + (seed>>2); - } - - return seed; - } - - template <class T> - inline void hash_range(std::size_t& seed, T* first, T* last) - { - for(; first != last; ++first) - { - boost::hash<T> hasher; - seed ^= hasher(*first) + 0x9e3779b9 + (seed<<6) + (seed>>2); - } - } -#endif - -#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) - template< class T, unsigned N > - inline std::size_t hash_value(const T (&x)[N]) - { - return hash_range(x, x + N); - } - - template< class T, unsigned N > - inline std::size_t hash_value(T (&x)[N]) - { - return hash_range(x, x + N); - } -#endif - - template <class Ch, class A> - inline std::size_t hash_value( - std::basic_string<Ch, std::BOOST_HASH_CHAR_TRAITS<Ch>, A> const& v) - { - return hash_range(v.begin(), v.end()); - } - - template <typename T> - typename boost::hash_detail::float_numbers<T>::type hash_value(T v) - { - return boost::hash_detail::float_hash_value(v); - } - -#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX) - inline std::size_t hash_value(std::type_index v) - { - return v.hash_code(); - } -#endif - - // - // boost::hash - // - - // Define the specializations required by the standard. The general purpose - // boost::hash is defined later in extensions.hpp if - // BOOST_HASH_NO_EXTENSIONS is not defined. - - // BOOST_HASH_SPECIALIZE - define a specialization for a type which is - // passed by copy. - // - // BOOST_HASH_SPECIALIZE_REF - define a specialization for a type which is - // passed by const reference. - // - // These are undefined later. - -#define BOOST_HASH_SPECIALIZE(type) \ - template <> struct hash<type> \ - : public boost::hash_detail::hash_base<type> \ - { \ - std::size_t operator()(type v) const \ - { \ - return boost::hash_value(v); \ - } \ - }; - -#define BOOST_HASH_SPECIALIZE_REF(type) \ - template <> struct hash<type> \ - : public boost::hash_detail::hash_base<type> \ - { \ - std::size_t operator()(type const& v) const \ - { \ - return boost::hash_value(v); \ - } \ - }; - - BOOST_HASH_SPECIALIZE(bool) - BOOST_HASH_SPECIALIZE(char) - BOOST_HASH_SPECIALIZE(signed char) - BOOST_HASH_SPECIALIZE(unsigned char) -#if !defined(BOOST_NO_INTRINSIC_WCHAR_T) - BOOST_HASH_SPECIALIZE(wchar_t) -#endif -#if !defined(BOOST_NO_CXX11_CHAR16_T) - BOOST_HASH_SPECIALIZE(char16_t) -#endif -#if !defined(BOOST_NO_CXX11_CHAR32_T) - BOOST_HASH_SPECIALIZE(char32_t) -#endif - BOOST_HASH_SPECIALIZE(short) - BOOST_HASH_SPECIALIZE(unsigned short) - BOOST_HASH_SPECIALIZE(int) - BOOST_HASH_SPECIALIZE(unsigned int) - BOOST_HASH_SPECIALIZE(long) - BOOST_HASH_SPECIALIZE(unsigned long) - - BOOST_HASH_SPECIALIZE(float) - BOOST_HASH_SPECIALIZE(double) - BOOST_HASH_SPECIALIZE(long double) - - BOOST_HASH_SPECIALIZE_REF(std::string) -#if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_INTRINSIC_WCHAR_T) - BOOST_HASH_SPECIALIZE_REF(std::wstring) -#endif -#if !defined(BOOST_NO_CXX11_CHAR16_T) - BOOST_HASH_SPECIALIZE_REF(std::basic_string<char16_t>) -#endif -#if !defined(BOOST_NO_CXX11_CHAR32_T) - BOOST_HASH_SPECIALIZE_REF(std::basic_string<char32_t>) -#endif - -#if !defined(BOOST_NO_LONG_LONG) - BOOST_HASH_SPECIALIZE(boost::long_long_type) - BOOST_HASH_SPECIALIZE(boost::ulong_long_type) -#endif - -#if defined(BOOST_HAS_INT128) - BOOST_HASH_SPECIALIZE(boost::int128_type) - BOOST_HASH_SPECIALIZE(boost::uint128_type) -#endif - -#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX) - BOOST_HASH_SPECIALIZE(std::type_index) -#endif - -#undef BOOST_HASH_SPECIALIZE -#undef BOOST_HASH_SPECIALIZE_REF - -// Specializing boost::hash for pointers. - -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - - template <class T> - struct hash<T*> - : public boost::hash_detail::hash_base<T*> - { - std::size_t operator()(T* v) const - { -#if !BOOST_WORKAROUND(__SUNPRO_CC, <= 0x590) - return boost::hash_value(v); -#else - std::size_t x = static_cast<std::size_t>( - reinterpret_cast<std::ptrdiff_t>(v)); - - return x + (x >> 3); -#endif - } - }; - -#else - - // For compilers without partial specialization, we define a - // boost::hash for all remaining types. But hash_impl is only defined - // for pointers in 'extensions.hpp' - so when BOOST_HASH_NO_EXTENSIONS - // is defined there will still be a compile error for types not supported - // in the standard. - - namespace hash_detail - { - template <bool IsPointer> - struct hash_impl; - - template <> - struct hash_impl<true> - { - template <class T> - struct inner - : public boost::hash_detail::hash_base<T> - { - std::size_t operator()(T val) const - { -#if !BOOST_WORKAROUND(__SUNPRO_CC, <= 590) - return boost::hash_value(val); -#else - std::size_t x = static_cast<std::size_t>( - reinterpret_cast<std::ptrdiff_t>(val)); - - return x + (x >> 3); -#endif - } - }; - }; - } - - template <class T> struct hash - : public boost::hash_detail::hash_impl<boost::is_pointer<T>::value> - ::BOOST_NESTED_TEMPLATE inner<T> - { - }; - -#endif -} - -#undef BOOST_HASH_CHAR_TRAITS -#undef BOOST_FUNCTIONAL_HASH_ROTL32 - -#if defined(BOOST_MSVC) -#pragma warning(pop) -#endif - -#endif // BOOST_FUNCTIONAL_HASH_HASH_HPP - -// Include this outside of the include guards in case the file is included -// twice - once with BOOST_HASH_NO_EXTENSIONS defined, and then with it -// undefined. - -#if !defined(BOOST_HASH_NO_EXTENSIONS) \ - && !defined(BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP) -#include <boost/functional/hash/extensions.hpp> -#endif +#include <boost/container_hash/hash.hpp> diff --git a/boost/functional/hash/hash_fwd.hpp b/boost/functional/hash/hash_fwd.hpp index 01fe012ed6..62bc23c73b 100644 --- a/boost/functional/hash/hash_fwd.hpp +++ b/boost/functional/hash/hash_fwd.hpp @@ -3,34 +3,4 @@ // 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) -// Based on Peter Dimov's proposal -// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf -// issue 6.18. - -#if !defined(BOOST_FUNCTIONAL_HASH_FWD_HPP) -#define BOOST_FUNCTIONAL_HASH_FWD_HPP - -#include <boost/config.hpp> -#if defined(BOOST_HAS_PRAGMA_ONCE) -#pragma once -#endif - -#include <cstddef> -#include <boost/detail/workaround.hpp> - -namespace boost -{ - template <class T> struct hash; - - template <class T> void hash_combine(std::size_t& seed, T const& v); - - template <class It> std::size_t hash_range(It, It); - template <class It> void hash_range(std::size_t&, It, It); - -#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551)) - template <class T> inline std::size_t hash_range(T*, T*); - template <class T> inline void hash_range(std::size_t&, T*, T*); -#endif -} - -#endif +#include <boost/container_hash/hash_fwd.hpp> diff --git a/boost/functional/hash_fwd.hpp b/boost/functional/hash_fwd.hpp index eea9073884..62bc23c73b 100644 --- a/boost/functional/hash_fwd.hpp +++ b/boost/functional/hash_fwd.hpp @@ -3,9 +3,4 @@ // 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/config.hpp> -#if defined(BOOST_HAS_PRAGMA_ONCE) -#pragma once -#endif - -#include <boost/functional/hash/hash_fwd.hpp> +#include <boost/container_hash/hash_fwd.hpp> diff --git a/boost/functional/lightweight_forward_adapter.hpp b/boost/functional/lightweight_forward_adapter.hpp index 2706d299dd..4c0d86416c 100644 --- a/boost/functional/lightweight_forward_adapter.hpp +++ b/boost/functional/lightweight_forward_adapter.hpp @@ -10,7 +10,7 @@ # ifndef BOOST_PP_IS_ITERATING # include <boost/config.hpp> -# include <boost/detail/workaround.hpp> +# include <boost/config/workaround.hpp> # include <boost/preprocessor/cat.hpp> # include <boost/preprocessor/iteration/iterate.hpp> |