diff options
Diffstat (limited to 'libcutl/cutl/details/boost/functional')
7 files changed, 0 insertions, 1630 deletions
diff --git a/libcutl/cutl/details/boost/functional/hash.hpp b/libcutl/cutl/details/boost/functional/hash.hpp deleted file mode 100644 index 2a265ef..0000000 --- a/libcutl/cutl/details/boost/functional/hash.hpp +++ /dev/null @@ -1,7 +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) - -#include <cutl/details/boost/functional/hash/hash.hpp> - diff --git a/libcutl/cutl/details/boost/functional/hash/detail/float_functions.hpp b/libcutl/cutl/details/boost/functional/hash/detail/float_functions.hpp deleted file mode 100644 index 1d5a02b..0000000 --- a/libcutl/cutl/details/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 <cutl/details/boost/config.hpp> -#include <cutl/details/boost/config/no_tr1/cmath.hpp> - -#if defined(_MSC_VER) && (_MSC_VER >= 1020) -# pragma once -#endif - -// 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 cutl_details_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 cutl_details_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<cutl_details_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 cutl_details_boost_hash_detect_float_functions { - template <class Float> cutl_details_boost::hash_detail::not_found ldexp(Float, int); - template <class Float> cutl_details_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 cutl_details_boost_hash_detect_float_functions { \ - template <class Float> \ - cutl_details_boost::hash_detail::not_found c99_func(Float, type2); \ -} \ - \ -namespace cutl_details_boost { \ - namespace hash_detail { \ - namespace c99_func##_detect { \ - using namespace std; \ - using namespace cutl_details_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 : \ - cutl_details_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< \ - ::cutl_details_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< \ - ::cutl_details_boost::hash_detail::c99_func##_detect::check::cpp \ - > {}; \ - } \ -} - -#define BOOST_HASH_CALL_FLOAT_MACRO(cpp_func, c99_func, type1, type2) \ -namespace cutl_details_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 cutl_details_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/libcutl/cutl/details/boost/functional/hash/detail/hash_float.hpp b/libcutl/cutl/details/boost/functional/hash/detail/hash_float.hpp deleted file mode 100644 index aaa49d9..0000000 --- a/libcutl/cutl/details/boost/functional/hash/detail/hash_float.hpp +++ /dev/null @@ -1,277 +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 - -#if defined(_MSC_VER) && (_MSC_VER >= 1020) -# pragma once -#endif - -#include <cutl/details/boost/config.hpp> -#include <cutl/details/boost/functional/hash/detail/float_functions.hpp> -#include <cutl/details/boost/functional/hash/detail/limits.hpp> -#include <cutl/details/boost/utility/enable_if.hpp> -#include <cutl/details/boost/integer/static_log2.hpp> -#include <cutl/details/boost/cstdint.hpp> -#include <cutl/details/boost/assert.hpp> -#include <cutl/details/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 cutl_details_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)) { - seed = *(std::size_t*) ptr; - 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> - inline std::size_t float_hash_impl(Float v, - BOOST_DEDUCED_TYPENAME cutl_details_boost::enable_if_c< - std::numeric_limits<Float>::is_iec559 && - std::numeric_limits<Float>::digits == 24 && - std::numeric_limits<Float>::radix == 2 && - std::numeric_limits<Float>::max_exponent == 128, - int>::type - ) - { - return hash_binary((char*) &v, 4); - } - - - template <typename Float> - inline std::size_t float_hash_impl(Float v, - BOOST_DEDUCED_TYPENAME cutl_details_boost::enable_if_c< - std::numeric_limits<Float>::is_iec559 && - std::numeric_limits<Float>::digits == 53 && - std::numeric_limits<Float>::radix == 2 && - std::numeric_limits<Float>::max_exponent == 1024, - int>::type - ) - { - return hash_binary((char*) &v, 8); - } - - template <typename Float> - inline std::size_t float_hash_impl(Float v, - BOOST_DEDUCED_TYPENAME cutl_details_boost::enable_if_c< - std::numeric_limits<Float>::is_iec559 && - std::numeric_limits<Float>::digits == 64 && - std::numeric_limits<Float>::radix == 2 && - std::numeric_limits<Float>::max_exponent == 16384, - int>::type - ) - { - return hash_binary((char*) &v, 10); - } - - template <typename Float> - inline std::size_t float_hash_impl(Float v, - BOOST_DEDUCED_TYPENAME cutl_details_boost::enable_if_c< - std::numeric_limits<Float>::is_iec559 && - std::numeric_limits<Float>::digits == 113 && - std::numeric_limits<Float>::radix == 2 && - std::numeric_limits<Float>::max_exponent == 16384, - int>::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) - { - cutl_details_boost::hash_detail::call_frexp<T> frexp; - cutl_details_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 * - cutl_details_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, 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 <cutl/details/boost/config/no_tr1/cmath.hpp> - -namespace cutl_details_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 cutl_details_boost -{ - namespace hash_detail - { - template <class T> - inline bool is_zero(T v) - { -#if !defined(__GNUC__) - 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 cutl_details_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/libcutl/cutl/details/boost/functional/hash/detail/limits.hpp b/libcutl/cutl/details/boost/functional/hash/detail/limits.hpp deleted file mode 100644 index de9abbe..0000000 --- a/libcutl/cutl/details/boost/functional/hash/detail/limits.hpp +++ /dev/null @@ -1,61 +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 - -#if defined(_MSC_VER) && (_MSC_VER >= 1020) -# pragma once -#endif - -#include <cutl/details/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 cutl_details_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/libcutl/cutl/details/boost/functional/hash/extensions.hpp b/libcutl/cutl/details/boost/functional/hash/extensions.hpp deleted file mode 100644 index 91771b4..0000000 --- a/libcutl/cutl/details/boost/functional/hash/extensions.hpp +++ /dev/null @@ -1,379 +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) - -// 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 <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 -#endif - -#if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) -#include <cutl/details/boost/type_traits/is_array.hpp> -#endif - -#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) -#include <cutl/details/boost/type_traits/is_const.hpp> -#endif - -namespace cutl_details_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; - 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 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 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 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 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 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 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 cutl_details_boost::hash_range(v.begin(), v.end()); - } - - template <class T> - std::size_t hash_value(std::complex<T> const& v) - { - cutl_details_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 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 - // - - // 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 cutl_details_boost; - return hash_value(v); - } - }; - }; - - template <> - struct call_hash_impl<true> - { - template <class Array> - struct inner - { -#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) - static std::size_t call(Array const& v) -#else - static std::size_t call(Array& v) -#endif - { - const int size = sizeof(v) / sizeof(*v); - return cutl_details_boost::hash_range(v, v + size); - } - }; - }; - - template <class T> - struct call_hash - : public call_hash_impl<cutl_details_boost::is_array<T>::value> - ::BOOST_NESTED_TEMPLATE inner<T> - { - }; - } -#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING - - // - // cutl_details_boost::hash - // - - -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - - template <class T> struct hash - : std::unary_function<T, std::size_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]> - : std::unary_function<T[n], std::size_t> - { - std::size_t operator()(const T* val) const - { - return cutl_details_boost::hash_range(val, val+n); - } - }; -#endif - -#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - - // On compilers without partial specialization, cutl_details_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; - -#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) - - template <> - struct hash_impl<false> - { - template <class T> - struct inner - : std::unary_function<T, std::size_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 - }; - }; - -#else // Visual C++ 6.5 - - // Visual C++ 6.5 has problems with nested member functions and - // applying const to const types in templates. So we get this: - - template <bool IsConst> - struct hash_impl_msvc - { - template <class T> - struct inner - : public std::unary_function<T, std::size_t> - { - std::size_t operator()(T const& val) const - { - return hash_detail::call_hash<T const>::call(val); - } - - std::size_t operator()(T& val) const - { - return hash_detail::call_hash<T>::call(val); - } - }; - }; - - template <> - struct hash_impl_msvc<true> - { - template <class T> - struct inner - : public std::unary_function<T, std::size_t> - { - std::size_t operator()(T& val) const - { - return hash_detail::call_hash<T>::call(val); - } - }; - }; - - template <class T> - struct hash_impl_msvc2 - : public hash_impl_msvc<cutl_details_boost::is_const<T>::value> - ::BOOST_NESTED_TEMPLATE inner<T> {}; - - template <> - struct hash_impl<false> - { - template <class T> - struct inner : public hash_impl_msvc2<T> {}; - }; - -#endif // Visual C++ 6.5 - } -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -} - -#endif diff --git a/libcutl/cutl/details/boost/functional/hash/hash.hpp b/libcutl/cutl/details/boost/functional/hash/hash.hpp deleted file mode 100644 index cb4a869..0000000 --- a/libcutl/cutl/details/boost/functional/hash/hash.hpp +++ /dev/null @@ -1,530 +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) - -// 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_HASH_HPP) -#define BOOST_FUNCTIONAL_HASH_HASH_HPP - -#include <cutl/details/boost/functional/hash/hash_fwd.hpp> -#include <functional> -#include <cutl/details/boost/functional/hash/detail/hash_float.hpp> -#include <string> -#include <cutl/details/boost/limits.hpp> -#include <cutl/details/boost/type_traits/is_enum.hpp> -#include <cutl/details/boost/type_traits/is_integral.hpp> -#include <cutl/details/boost/utility/enable_if.hpp> - -#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) -#include <cutl/details/boost/type_traits/is_pointer.hpp> -#endif - -#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX) -#include <typeindex> -#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 - -namespace cutl_details_boost -{ - namespace hash_detail - { - 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> : - cutl_details_boost::hash_detail::enable_hash_value {}; - template <> struct basic_numbers<char> : - cutl_details_boost::hash_detail::enable_hash_value {}; - template <> struct basic_numbers<unsigned char> : - cutl_details_boost::hash_detail::enable_hash_value {}; - template <> struct basic_numbers<signed char> : - cutl_details_boost::hash_detail::enable_hash_value {}; - template <> struct basic_numbers<short> : - cutl_details_boost::hash_detail::enable_hash_value {}; - template <> struct basic_numbers<unsigned short> : - cutl_details_boost::hash_detail::enable_hash_value {}; - template <> struct basic_numbers<int> : - cutl_details_boost::hash_detail::enable_hash_value {}; - template <> struct basic_numbers<unsigned int> : - cutl_details_boost::hash_detail::enable_hash_value {}; - template <> struct basic_numbers<long> : - cutl_details_boost::hash_detail::enable_hash_value {}; - template <> struct basic_numbers<unsigned long> : - cutl_details_boost::hash_detail::enable_hash_value {}; - -#if !defined(BOOST_NO_INTRINSIC_WCHAR_T) - template <> struct basic_numbers<wchar_t> : - cutl_details_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<cutl_details_boost::long_long_type> : - cutl_details_boost::hash_detail::enable_hash_value {}; - template <> struct ulong_numbers<cutl_details_boost::ulong_long_type> : - cutl_details_boost::hash_detail::enable_hash_value {}; -#endif - -#if defined(BOOST_HAS_INT128) - template <> struct long_numbers2<cutl_details_boost::int128_type> : - cutl_details_boost::hash_detail::enable_hash_value {}; - template <> struct ulong_numbers2<cutl_details_boost::uint128_type> : - cutl_details_boost::hash_detail::enable_hash_value {}; -#endif - - template <> struct float_numbers<float> : - cutl_details_boost::hash_detail::enable_hash_value {}; - template <> struct float_numbers<double> : - cutl_details_boost::hash_detail::enable_hash_value {}; - template <> struct float_numbers<long double> : - cutl_details_boost::hash_detail::enable_hash_value {}; - } - - template <typename T> - typename cutl_details_boost::hash_detail::basic_numbers<T>::type hash_value(T); - template <typename T> - typename cutl_details_boost::hash_detail::long_numbers<T>::type hash_value(T); - template <typename T> - typename cutl_details_boost::hash_detail::ulong_numbers<T>::type hash_value(T); - - template <typename T> - typename cutl_details_boost::enable_if<cutl_details_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 cutl_details_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 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) - / 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 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) - / 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 T> - typename cutl_details_boost::hash_detail::basic_numbers<T>::type hash_value(T v) - { - return static_cast<std::size_t>(v); - } - - template <typename T> - typename cutl_details_boost::hash_detail::long_numbers<T>::type hash_value(T v) - { - return hash_detail::hash_value_signed(v); - } - - template <typename T> - typename cutl_details_boost::hash_detail::ulong_numbers<T>::type hash_value(T v) - { - return hash_detail::hash_value_unsigned(v); - } - - template <typename T> - typename cutl_details_boost::enable_if<cutl_details_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 - -#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) - template <class T> - inline void hash_combine(std::size_t& seed, T& v) -#else - template <class T> - inline void hash_combine(std::size_t& seed, T const& v) -#endif - { - cutl_details_boost::hash<T> hasher; - seed ^= hasher(v) + 0x9e3779b9 + (seed<<6) + (seed>>2); - } - -#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) - { - cutl_details_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) - { - cutl_details_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 cutl_details_boost::hash_detail::float_numbers<T>::type hash_value(T v) - { - return cutl_details_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 - - // - // cutl_details_boost::hash - // - - // Define the specializations required by the standard. The general purpose - // cutl_details_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 copy. - // - // These are undefined later. - -#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) -#define BOOST_HASH_SPECIALIZE(type) \ - template <> struct hash<type> \ - : public std::unary_function<type, std::size_t> \ - { \ - std::size_t operator()(type v) const \ - { \ - return cutl_details_boost::hash_value(v); \ - } \ - }; - -#define BOOST_HASH_SPECIALIZE_REF(type) \ - template <> struct hash<type> \ - : public std::unary_function<type, std::size_t> \ - { \ - std::size_t operator()(type const& v) const \ - { \ - return cutl_details_boost::hash_value(v); \ - } \ - }; -#else -#define BOOST_HASH_SPECIALIZE(type) \ - template <> struct hash<type> \ - : public std::unary_function<type, std::size_t> \ - { \ - std::size_t operator()(type v) const \ - { \ - return cutl_details_boost::hash_value(v); \ - } \ - }; \ - \ - template <> struct hash<const type> \ - : public std::unary_function<const type, std::size_t> \ - { \ - std::size_t operator()(const type v) const \ - { \ - return cutl_details_boost::hash_value(v); \ - } \ - }; - -#define BOOST_HASH_SPECIALIZE_REF(type) \ - template <> struct hash<type> \ - : public std::unary_function<type, std::size_t> \ - { \ - std::size_t operator()(type const& v) const \ - { \ - return cutl_details_boost::hash_value(v); \ - } \ - }; \ - \ - template <> struct hash<const type> \ - : public std::unary_function<const type, std::size_t> \ - { \ - std::size_t operator()(type const& v) const \ - { \ - return cutl_details_boost::hash_value(v); \ - } \ - }; -#endif - - 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 - 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) - BOOST_HASH_SPECIALIZE_REF(std::wstring) -#endif - -#if !defined(BOOST_NO_LONG_LONG) - BOOST_HASH_SPECIALIZE(cutl_details_boost::long_long_type) - BOOST_HASH_SPECIALIZE(cutl_details_boost::ulong_long_type) -#endif - -#if defined(BOOST_HAS_INT128) - BOOST_HASH_SPECIALIZE(cutl_details_boost::int128_type) - BOOST_HASH_SPECIALIZE(cutl_details_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 cutl_details_boost::hash for pointers. - -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - - template <class T> - struct hash<T*> - : public std::unary_function<T*, std::size_t> - { - std::size_t operator()(T* v) const - { -#if !BOOST_WORKAROUND(__SUNPRO_CC, <= 0x590) - return cutl_details_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 - // cutl_details_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 std::unary_function<T, std::size_t> - { - std::size_t operator()(T val) const - { -#if !BOOST_WORKAROUND(__SUNPRO_CC, <= 590) - return cutl_details_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 cutl_details_boost::hash_detail::hash_impl<cutl_details_boost::is_pointer<T>::value> - ::BOOST_NESTED_TEMPLATE inner<T> - { - }; - -#endif -} - -#undef BOOST_HASH_CHAR_TRAITS - -#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 <cutl/details/boost/functional/hash/extensions.hpp> -#endif diff --git a/libcutl/cutl/details/boost/functional/hash/hash_fwd.hpp b/libcutl/cutl/details/boost/functional/hash/hash_fwd.hpp deleted file mode 100644 index b56a4f9..0000000 --- a/libcutl/cutl/details/boost/functional/hash/hash_fwd.hpp +++ /dev/null @@ -1,40 +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) - -// 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 - -#if defined(_MSC_VER) && (_MSC_VER >= 1020) -# pragma once -#endif - -#include <cutl/details/boost/config.hpp> -#include <cstddef> -#include <cutl/details/boost/detail/workaround.hpp> - -namespace cutl_details_boost -{ - template <class T> struct hash; - -#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) - template <class T> void hash_combine(std::size_t& seed, T& v); -#else - template <class T> void hash_combine(std::size_t& seed, T const& v); -#endif - - 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 |