feedc0de/boost_container_hash
1
0
Fork 0
forked from boostorg/container_hash
Code Pull Requests Activity

Merge branch 'develop'

Browse Source
This commit is contained in:
Daniel James
2018-01-01 16:02:14 +00:00
parent dfa8fa5d91 6ca88a8146
commit 8d784ed76d
66 changed files with 1146 additions and 1068 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
doc/Jamfile.v2
View File

@@ -15,5 +15,11 @@ boostbook standalone : hash :
<xsl:param>generate.section.toc.level=2 <xsl:param>generate.section.toc.level=2
<xsl:param>toc.section.depth=1 <xsl:param>toc.section.depth=1
<xsl:param>toc.max.depth=1 <xsl:param>toc.max.depth=1
<format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/functional/hash/doc/html <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/container_hash/hash/doc/html
; ;
###############################################################################
alias boostdoc : hash ;
explicit boostdoc ;
alias boostrelease ;
explicit boostrelease ;

14
doc/changes.qbk
View File

@@ -19,8 +19,8 @@
* Use declarations for standard classes, so that the library * Use declarations for standard classes, so that the library
doesn't need to include all of their headers doesn't need to include all of their headers
* Deprecated the `<boost/functional/hash/*.hpp>` headers. Now a single header, * Deprecated the `<boost/container_hash/hash/*.hpp>` headers. Now a single header,
<[headerref boost/functional/hash.hpp]> is used. <[headerref boost/container_hash/hash.hpp]> is used.
* Add support for the `BOOST_HASH_NO_EXTENSIONS` macro, which * Add support for the `BOOST_HASH_NO_EXTENSIONS` macro, which
disables the extensions to TR1. disables the extensions to TR1.
@@ -71,10 +71,10 @@
* Changed the warnings in the deprecated headers from 1.34.0 to errors. These * Changed the warnings in the deprecated headers from 1.34.0 to errors. These
will be removed in a future version of Boost. will be removed in a future version of Boost.
* Moved detail headers out of `boost/functional/detail`, since they are part of * Moved detail headers out of `boost/container_hash/detail`, since they are part of
functional/hash, not functional. `boost/functional/detail/container_fwd.hpp` container_hash/hash, not container_hash. `boost/container_hash/detail/container_fwd.hpp`
has been moved to `boost/detail/container_fwd.hpp` as it's used outside of has been moved to `boost/detail/container_fwd.hpp` as it's used outside of
this library, the others have been moved to `boost/functional/hash/detail`. this library, the others have been moved to `boost/container_hash/hash/detail`.
[h2 Boost 1.39.0] [h2 Boost 1.39.0]
@@ -132,7 +132,7 @@
* [@http://svn.boost.org/trac/boost/ticket/6806 Ticket 6806]: * [@http://svn.boost.org/trac/boost/ticket/6806 Ticket 6806]:
Support `std::array` and `std::tuple` when available. Support `std::array` and `std::tuple` when available.
* Add deprecation warning to the long deprecated * Add deprecation warning to the long deprecated
`boost/functional/detail/container_fwd.hpp`. `boost/container_hash/detail/container_fwd.hpp`.
[h2 Boost 1.51.0] [h2 Boost 1.51.0]
@@ -177,7 +177,7 @@
[h2 Boost 1.58.0] [h2 Boost 1.58.0]
* Fixed strict aliasing violation * Fixed strict aliasing violation
([@https://github.com/boostorg/functional/pull/3 GitHub #3]). ([@https://github.com/boostorg/container_hash/pull/3 GitHub #3]).
[h2 Boost 1.63.0] [h2 Boost 1.63.0]

2
doc/disable.qbk
View File

@@ -10,7 +10,7 @@ to turn them of in order to check that your code will work with other
implementations of TR1. To do this define the macro `BOOST_HASH_NO_EXTENSIONS`. implementations of TR1. To do this define the macro `BOOST_HASH_NO_EXTENSIONS`.
When this macro is defined, only the specialisations detailed When this macro is defined, only the specialisations detailed
in TR1 will be declared. But, if you later undefine the macro and include in TR1 will be declared. But, if you later undefine the macro and include
<[headerref boost/functional/hash.hpp]> then the non-specialised form will be defined <[headerref boost/container_hash/hash.hpp]> then the non-specialised form will be defined
- activating the extensions. - activating the extensions.
It is strongly recommended that you never undefine the macro - and only define It is strongly recommended that you never undefine the macro - and only define

4
doc/hash.qbk
View File

@@ -1,4 +1,4 @@
[library Boost.Functional/Hash [library Boost.ContainerHash
[quickbook 1.5] [quickbook 1.5]
[authors [James, Daniel]] [authors [James, Daniel]]
[copyright 2005 2006 2007 2008 Daniel James] [copyright 2005 2006 2007 2008 Daniel James]
@@ -6,7 +6,7 @@
defined types] defined types]
[category higher-order] [category higher-order]
[id hash] [id hash]
[dirname functional/hash] [dirname container_hash]
[license [license
Distributed under the Boost Software License, Version 1.0. Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at (See accompanying file LICENSE_1_0.txt or copy at

2
doc/portability.qbk
View File

@@ -88,6 +88,6 @@ boost namespace:
} }
Full code for this example is at Full code for this example is at
[@boost:/libs/functional/hash/examples/portable.cpp /libs/functional/hash/examples/portable.cpp]. [@boost:/libs/container_hash/hash/examples/portable.cpp /libs/container_hash/hash/examples/portable.cpp].
[endsect] [endsect]

8
doc/ref.xml
View File

@@ -13,7 +13,7 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
<ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1837.pdf">Library Extension Technical Report Issues List</ulink> (page 63). <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1837.pdf">Library Extension Technical Report Issues List</ulink> (page 63).
</para> </para>
</section> </section>
<header name="boost/functional/hash.hpp"> <header name="boost/container_hash/hash.hpp">
<para> <para>
Defines <code><classname>boost::hash</classname></code>, Defines <code><classname>boost::hash</classname></code>,
and helper functions. and helper functions.
@@ -57,7 +57,7 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
</para> </para>
<para> <para>
Forward declared in Forward declared in
<code>&lt;boost/functional/hash_fwd.hpp&gt;</code> <code>&lt;boost/container_hash/hash_fwd.hpp&gt;</code>
</para> </para>
<para> <para>
This hash function is not intended for general use, and isn't This hash function is not intended for general use, and isn't
@@ -542,7 +542,7 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
<para>This is an extension to TR1</para> <para>This is an extension to TR1</para>
<para> <para>
Forward declared in Forward declared in
<code>&lt;boost/functional/hash_fwd.hpp&gt;</code> <code>&lt;boost/container_hash/hash_fwd.hpp&gt;</code>
</para> </para>
<para> <para>
This hash function is not intended for general use, and isn't This hash function is not intended for general use, and isn't
@@ -615,7 +615,7 @@ for(; first != last; ++first)
<para>This is an extension to TR1</para> <para>This is an extension to TR1</para>
<para> <para>
Forward declared in Forward declared in
<code>&lt;boost/functional/hash_fwd.hpp&gt;</code> <code>&lt;boost/container_hash/hash_fwd.hpp&gt;</code>
</para> </para>
<para> <para>
This hash function is not intended for general use, and isn't This hash function is not intended for general use, and isn't

14
doc/tutorial.qbk
View File

@@ -27,7 +27,7 @@ associative containers and you wish to use
To use [classref boost::hash] directly, create an instance and call it as a function: To use [classref boost::hash] directly, create an instance and call it as a function:
#include <``[headerref boost/functional/hash.hpp]``> #include <``[headerref boost/container_hash/hash.hpp]``>
int main() int main()
{ {
@@ -110,9 +110,9 @@ And you can now use [classref boost::hash] with book:
assert(books.find(dandelion) == books.end()); assert(books.find(dandelion) == books.end());
The full example can be found in: The full example can be found in:
[@boost:/libs/functional/hash/examples/books.hpp /libs/functional/hash/examples/books.hpp] [@boost:/libs/container_hash/hash/examples/books.hpp /libs/container_hash/hash/examples/books.hpp]
and and
[@boost:/libs/functional/hash/examples/books.cpp /libs/functional/hash/examples/books.cpp]. [@boost:/libs/container_hash/hash/examples/books.cpp /libs/container_hash/hash/examples/books.cpp].
[tip [tip
When writing a hash function, first look at how the equality function works. When writing a hash function, first look at how the equality function works.
@@ -170,7 +170,7 @@ of point, it can be repeatedly called for any number of elements. It calls
[funcref boost::hash_value hash_value] on the supplied element, and combines it with the seed. [funcref boost::hash_value hash_value] on the supplied element, and combines it with the seed.
Full code for this example is at Full code for this example is at
[@boost:/libs/functional/hash/examples/point.cpp /libs/functional/hash/examples/point.cpp]. [@boost:/libs/container_hash/hash/examples/point.cpp /libs/container_hash/hash/examples/point.cpp].
[note [note
When using [funcref boost::hash_combine] the order of the When using [funcref boost::hash_combine] the order of the
@@ -200,13 +200,13 @@ To calculate the hash of an iterator range you can use [funcref boost::hash_rang
Note that when writing template classes, you might not want to include the main Note that when writing template classes, you might not want to include the main
hash header as it's quite an expensive include that brings in a lot of other hash header as it's quite an expensive include that brings in a lot of other
headers, so instead you can include the `<boost/functional/hash_fwd.hpp>` headers, so instead you can include the `<boost/container_hash/hash_fwd.hpp>`
header which forward declares [classref boost::hash], header which forward declares [classref boost::hash],
[funcref boost::hash_range] and [funcref boost::hash_combine]. You'll need to [funcref boost::hash_range] and [funcref boost::hash_combine]. You'll need to
include the main header before instantiating [classref boost::hash]. When using include the main header before instantiating [classref boost::hash]. When using
a container that uses [classref boost::hash] it should do that for you, so your a container that uses [classref boost::hash] it should do that for you, so your
type will work fine with the boost hash containers. There's an example of this type will work fine with the boost hash containers. There's an example of this
in [@boost:/libs/functional/hash/examples/template.hpp template.hpp] and in [@boost:/libs/container_hash/hash/examples/template.hpp template.hpp] and
[@boost:/libs/functional/hash/examples/template.cpp template.cpp]. [@boost:/libs/container_hash/hash/examples/template.cpp template.cpp].
[endsect] [endsect]

2
examples/books.cpp
View File

@@ -4,7 +4,7 @@
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include "./books.hpp" #include "./books.hpp"
#include <boost/functional/hash.hpp> #include <boost/container_hash/hash.hpp>
#include <cassert> #include <cassert>
// If std::unordered_set was available: // If std::unordered_set was available:

2
examples/point.cpp
View File

@@ -8,7 +8,7 @@
#undef NDEBUG #undef NDEBUG
#endif #endif
#include <boost/functional/hash.hpp> #include <boost/container_hash/hash.hpp>
#include <cassert> #include <cassert>
// This example illustrates how to use boost::hash_combine to generate a hash // This example illustrates how to use boost::hash_combine to generate a hash

2
examples/portable.cpp
View File

@@ -8,7 +8,7 @@
#undef NDEBUG #undef NDEBUG
#endif #endif
#include <boost/functional/hash.hpp> #include <boost/container_hash/hash.hpp>
#include <cassert> #include <cassert>
// This example illustrates how to customise boost::hash portably, so that // This example illustrates how to customise boost::hash portably, so that

2
examples/template.hpp
View File

@@ -6,7 +6,7 @@
// This is an example of how to write a hash function for a template // This is an example of how to write a hash function for a template
// class. // class.
#include <boost/functional/hash_fwd.hpp> #include <boost/container_hash/hash_fwd.hpp>
template <typename A, typename B> template <typename A, typename B>
class my_pair class my_pair

7
include/boost/container_hash/hash.hpp Normal file
View File

@@ -0,0 +1,7 @@
// 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 <boost/container_hash/hash/hash.hpp>

0
include/boost/functional/hash/detail/float_functions.hpp → include/boost/container_hash/hash/detail/float_functions.hpp
View File

6
include/boost/functional/hash/detail/hash_float.hpp → include/boost/container_hash/hash/detail/hash_float.hpp
View File

@@ -11,9 +11,9 @@
#pragma once #pragma once
#endif #endif
#include <boost/functional/hash/detail/float_functions.hpp> #include <boost/container_hash/hash/detail/float_functions.hpp>
#include <boost/functional/hash/detail/limits.hpp> #include <boost/container_hash/hash/detail/limits.hpp>
#include <boost/utility/enable_if.hpp> #include <boost/core/enable_if.hpp>
#include <boost/integer/static_log2.hpp> #include <boost/integer/static_log2.hpp>
#include <boost/cstdint.hpp> #include <boost/cstdint.hpp>
#include <boost/assert.hpp> #include <boost/assert.hpp>

0
include/boost/functional/hash/detail/limits.hpp → include/boost/container_hash/hash/detail/limits.hpp
View File

363
include/boost/container_hash/hash/extensions.hpp Normal file
View File

@@ -0,0 +1,363 @@
// 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 <boost/config.hpp>
#if defined(BOOST_HAS_PRAGMA_ONCE)
#pragma once
#endif
#include <boost/container_hash/hash/hash.hpp>
#include <boost/detail/container_fwd.hpp>
#include <boost/core/enable_if.hpp>
#include <boost/static_assert.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);
}
template<typename A0>
inline std::size_t hash_value(std::tuple<A0> const& v)
{
return boost::hash_detail::hash_tuple(v);
}
template<typename A0, typename A1>
inline std::size_t hash_value(std::tuple<A0, A1> const& v)
{
return boost::hash_detail::hash_tuple(v);
}
template<typename A0, typename A1, typename A2>
inline std::size_t hash_value(std::tuple<A0, A1, A2> const& v)
{
return boost::hash_detail::hash_tuple(v);
}
template<typename A0, typename A1, typename A2, typename A3>
inline std::size_t hash_value(std::tuple<A0, A1, A2, A3> const& v)
{
return boost::hash_detail::hash_tuple(v);
}
template<typename A0, typename A1, typename A2, typename A3, typename A4>
inline std::size_t hash_value(std::tuple<A0, A1, A2, A3, A4> const& v)
{
return boost::hash_detail::hash_tuple(v);
}
template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
inline std::size_t hash_value(std::tuple<A0, A1, A2, A3, A4, A5> const& v)
{
return boost::hash_detail::hash_tuple(v);
}
template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
inline std::size_t hash_value(std::tuple<A0, A1, A2, A3, A4, A5, A6> const& v)
{
return boost::hash_detail::hash_tuple(v);
}
template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
inline std::size_t hash_value(std::tuple<A0, A1, A2, A3, A4, A5, A6, A7> const& v)
{
return boost::hash_detail::hash_tuple(v);
}
template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
inline std::size_t hash_value(std::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8> const& v)
{
return boost::hash_detail::hash_tuple(v);
}
template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
inline std::size_t hash_value(std::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> const& v)
{
return boost::hash_detail::hash_tuple(v);
}
#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

595
include/boost/container_hash/hash/hash.hpp Normal file
View File

@@ -0,0 +1,595 @@
// Copyright 2005-2014 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/container_hash/hash/hash_fwd.hpp>
#include <functional>
#include <boost/container_hash/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/core/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/container_hash/hash/extensions.hpp>
#endif

36
include/boost/container_hash/hash/hash_fwd.hpp Normal file
View File

@@ -0,0 +1,36 @@
// 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
#include <boost/config/workaround.hpp>
#include <cstddef>
#if defined(BOOST_HAS_PRAGMA_ONCE)
#pragma once
#endif
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

11
include/boost/container_hash/hash_fwd.hpp Normal file
View File

@@ -0,0 +1,11 @@
// 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 <boost/config.hpp>
#if defined(BOOST_HAS_PRAGMA_ONCE)
#pragma once
#endif
#include <boost/container_hash/hash/hash_fwd.hpp>

3
include/boost/functional/hash.hpp
View File

@@ -3,5 +3,4 @@
// Distributed under the Boost Software License, Version 1.0. (See accompanying // 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) // 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/hash.hpp>

316
include/boost/functional/hash/extensions.hpp
View File

@@ -1,318 +1,6 @@
// Copyright 2005-2009 Daniel James. // Copyright 2017 Daniel James.
// Distributed under the Boost Software License, Version 1.0. (See accompanying // 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) // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// Based on Peter Dimov's proposal #include <boost/container_hash/hash/extensions.hpp>
// 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

593
include/boost/functional/hash/hash.hpp
View File

@@ -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 // 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) // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// Based on Peter Dimov's proposal #include <boost/container_hash/hash/hash.hpp>
// 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

32
include/boost/functional/hash/hash_fwd.hpp
View File

@@ -3,34 +3,4 @@
// Distributed under the Boost Software License, Version 1.0. (See accompanying // 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) // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// Based on Peter Dimov's proposal #include <boost/container_hash/hash/hash_fwd.hpp>
// 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

7
include/boost/functional/hash_fwd.hpp
View File

@@ -3,9 +3,4 @@
// Distributed under the Boost Software License, Version 1.0. (See accompanying // 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) // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/config.hpp> #include <boost/container_hash/hash/hash_fwd.hpp>
#if defined(BOOST_HAS_PRAGMA_ONCE)
#pragma once
#endif
#include <boost/functional/hash/hash_fwd.hpp>

4
meta/explicit-failures-markup.xml
View File

@@ -1,7 +1,7 @@
<?xml version="1.0" encoding="utf-8"?> <?xml version="1.0" encoding="utf-8"?>
<explicit-failures-markup> <explicit-failures-markup>
<!-- functional/hash --> <!-- container_hash -->
<library name="functional/hash"> <library name="container_hash">
<mark-expected-failures> <mark-expected-failures>
<test name="hash_value_array_test"/> <test name="hash_value_array_test"/>
<toolset name="msvc-6.5*"/> <toolset name="msvc-6.5*"/>

6
meta/libraries.json
View File

@@ -2,14 +2,14 @@
{ {
"key": "functional/hash", "key": "functional/hash",
"boost-version": "1.33.0", "boost-version": "1.33.0",
"name": "Functional/Hash", "name": "Container Hash",
"authors": [ "authors": [
"Daniel James" "Daniel James"
], ],
"maintainers": [ "maintainers": [
"Daniel James <dnljms -at- gmail.com>" "Daniel James <dnljms -at- gmail.com>"
], ],
"description": "A TR1 hash function object that can be extended to hash user defined types.", "description": "An STL-compatible hash function object that can be extended to hash user defined types.",
"std": [ "std": [
"tr1" "tr1"
], ],
@@ -17,4 +17,4 @@
"Function-objects" "Function-objects"
] ]
} }
] ]

8
test/Jamfile.v2
View File

@@ -18,7 +18,7 @@ project hash-tests
#<toolset>darwin:<warnings-as-errors>on #<toolset>darwin:<warnings-as-errors>on
; ;
test-suite functional/hash test-suite container_hash/hash
: :
[ compile check_float_funcs.cpp ] [ compile check_float_funcs.cpp ]
[ run hash_fwd_test_1.cpp ] [ run hash_fwd_test_1.cpp ]
@@ -56,7 +56,7 @@ test-suite functional/hash
[ run hash_no_ext_macro_2.cpp ] [ run hash_no_ext_macro_2.cpp ]
; ;
test-suite functional/hash_no_ext test-suite container_hash/hash_no_ext
: :
[ run hash_number_test.cpp : : : <define>BOOST_HASH_NO_EXTENSIONS : no_ext_number_test ] [ run hash_number_test.cpp : : : <define>BOOST_HASH_NO_EXTENSIONS : no_ext_number_test ]
[ run hash_pointer_test.cpp : : : <define>BOOST_HASH_NO_EXTENSIONS : no_ext_pointer_test ] [ run hash_pointer_test.cpp : : : <define>BOOST_HASH_NO_EXTENSIONS : no_ext_pointer_test ]
@@ -69,7 +69,7 @@ test-suite functional/hash_no_ext
# Tests to see if the floating point hash is using the binary hash. # Tests to see if the floating point hash is using the binary hash.
# Not run normally because on some platforms these should fail. # Not run normally because on some platforms these should fail.
test-suite functional/hash_no_generic_float test-suite container_hash/hash_no_generic_float
: :
[ run hash_float_test.cpp [ run hash_float_test.cpp
: : : <define>BOOST_HASH_DETAIL_TEST_WITHOUT_GENERIC : : : <define>BOOST_HASH_DETAIL_TEST_WITHOUT_GENERIC
@@ -78,6 +78,6 @@ test-suite functional/hash_no_generic_float
: : : <define>BOOST_HASH_DETAIL_TEST_WITHOUT_GENERIC : : : <define>BOOST_HASH_DETAIL_TEST_WITHOUT_GENERIC
: hash_long_double_test_no_generic ] : hash_long_double_test_no_generic ]
; ;
explicit functional/hash_no_generic_float ; explicit container_hash/hash_no_generic_float ;
build-project ../examples ; build-project ../examples ;

4
test/config.hpp
View File

@@ -18,4 +18,8 @@
// before doing anything else. // before doing anything else.
#pragma warning(disable:4201) // nonstandard extension used : #pragma warning(disable:4201) // nonstandard extension used :
// nameless struct/union // nameless struct/union
#endif #endif
#define HASH_TEST_CAT(x, y) HASH_TEST_CAT2(x, y)
#define HASH_TEST_CAT2(x, y) x##y

6
test/extensions_hpp_test.cpp
View File

@@ -3,14 +3,14 @@
// Distributed under the Boost Software License, Version 1.0. (See accompanying // 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) // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// Check that boost/functional/hash/extensions.hpp works okay. // Check that boost/container_hash/hash/extensions.hpp works okay.
// //
// It probably should be in boost/functional/hash/detail, but since it isn't it // It probably should be in boost/container_hash/hash/detail, but since it isn't it
// should work. // should work.
#include "./config.hpp" #include "./config.hpp"
#include <boost/functional/hash/extensions.hpp> #include <boost/container_hash/hash/extensions.hpp>
int main() { int main() {
int x[2] = { 2, 3 }; int x[2] = { 2, 3 };

4
test/hash_built_in_array_test.cpp
View File

@@ -9,11 +9,11 @@
# ifdef BOOST_HASH_TEST_STD_INCLUDES # ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
# else # else
# include <boost/functional/hash.hpp> # include <boost/container_hash/hash.hpp>
# endif # endif
#endif #endif
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#ifdef BOOST_HASH_TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS

4
test/hash_complex_test.cpp
View File

@@ -14,10 +14,10 @@ int main() {}
#ifdef BOOST_HASH_TEST_STD_INCLUDES #ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
#else #else
# include <boost/functional/hash.hpp> # include <boost/container_hash/hash.hpp>
#endif #endif
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#if defined(BOOST_MSVC) #if defined(BOOST_MSVC)
#pragma warning(disable:4244) // conversion from 'unsigned long' to #pragma warning(disable:4244) // conversion from 'unsigned long' to

4
test/hash_custom_test.cpp
View File

@@ -45,11 +45,11 @@ namespace boost
# ifdef BOOST_HASH_TEST_STD_INCLUDES # ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
# else # else
# include <boost/functional/hash.hpp> # include <boost/container_hash/hash.hpp>
# endif # endif
#endif #endif
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#ifdef BOOST_HASH_TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS

4
test/hash_deque_test.cpp
View File

@@ -9,11 +9,11 @@
# ifdef BOOST_HASH_TEST_STD_INCLUDES # ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
# else # else
# include <boost/functional/hash.hpp> # include <boost/container_hash/hash.hpp>
# endif # endif
#endif #endif
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#ifdef BOOST_HASH_TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS

4
test/hash_enum_test.cpp
View File

@@ -8,10 +8,10 @@
#ifdef BOOST_HASH_TEST_STD_INCLUDES #ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
#else #else
# include <boost/functional/hash.hpp> # include <boost/container_hash/hash.hpp>
#endif #endif
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#include "./compile_time.hpp" #include "./compile_time.hpp"
namespace test { namespace test {

10
test/hash_float_test.hpp
View File

@@ -8,15 +8,15 @@
#ifdef BOOST_HASH_TEST_STD_INCLUDES #ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
#else #else
# include <boost/functional/hash.hpp> # include <boost/container_hash/hash.hpp>
#endif #endif
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#include <cmath> #include <cmath>
#include <boost/functional/hash/detail/limits.hpp> #include <boost/container_hash/hash/detail/limits.hpp>
#include <boost/functional/hash/detail/float_functions.hpp> #include <boost/container_hash/hash/detail/float_functions.hpp>
#include <boost/detail/workaround.hpp> #include <boost/config/workaround.hpp>
#include <iostream> #include <iostream>

4
test/hash_friend_test.cpp
View File

@@ -48,11 +48,11 @@ namespace boost
# ifdef BOOST_HASH_TEST_STD_INCLUDES # ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
# else # else
# include <boost/functional/hash.hpp> # include <boost/container_hash/hash.hpp>
# endif # endif
#endif #endif
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#ifdef BOOST_HASH_TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS

4
test/hash_function_pointer_test.cpp
View File

@@ -8,10 +8,10 @@
#ifdef BOOST_HASH_TEST_STD_INCLUDES #ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
#else #else
# include <boost/functional/hash.hpp> # include <boost/container_hash/hash.hpp>
#endif #endif
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#include "./compile_time.hpp" #include "./compile_time.hpp"
void void_func1() { static int x = 1; ++x; } void void_func1() { static int x = 1; ++x; }

2
test/hash_fwd_test.hpp
View File

@@ -6,7 +6,7 @@
#include "./config.hpp" #include "./config.hpp"
#if defined(BOOST_HASH_TEST_EXTENSIONS) && !defined(BOOST_HASH_TEST_STD_INCLUDES) #if defined(BOOST_HASH_TEST_EXTENSIONS) && !defined(BOOST_HASH_TEST_STD_INCLUDES)
#include <boost/functional/hash_fwd.hpp> #include <boost/container_hash/hash_fwd.hpp>
#include <boost/config.hpp> #include <boost/config.hpp>
#include <cstddef> #include <cstddef>

4
test/hash_fwd_test_1.cpp
View File

@@ -9,11 +9,11 @@
#include "./hash_fwd_test.hpp" #include "./hash_fwd_test.hpp"
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#if defined(BOOST_HASH_TEST_EXTENSIONS) && !defined(BOOST_HASH_TEST_STD_INCLUDES) #if defined(BOOST_HASH_TEST_EXTENSIONS) && !defined(BOOST_HASH_TEST_STD_INCLUDES)
#include <boost/functional/hash.hpp> #include <boost/container_hash/hash.hpp>
#include <string> #include <string>
void fwd_test1() void fwd_test1()

2
test/hash_fwd_test_2.cpp
View File

@@ -15,7 +15,7 @@ int main() {}
#else #else
#include "./hash_fwd_test.hpp" #include "./hash_fwd_test.hpp"
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
template <class T> void unused(T const&) {} template <class T> void unused(T const&) {}

4
test/hash_global_namespace_test.cpp
View File

@@ -46,11 +46,11 @@ namespace boost
# ifdef BOOST_HASH_TEST_STD_INCLUDES # ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
# else # else
# include <boost/functional/hash.hpp> # include <boost/container_hash/hash.hpp>
# endif # endif
#endif #endif
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#ifdef BOOST_HASH_TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS

4
test/hash_list_test.cpp
View File

@@ -9,11 +9,11 @@
# ifdef BOOST_HASH_TEST_STD_INCLUDES # ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
# else # else
# include <boost/functional/hash.hpp> # include <boost/container_hash/hash.hpp>
# endif # endif
#endif #endif
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#ifdef BOOST_HASH_TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS

4
test/hash_map_test.cpp
View File

@@ -9,11 +9,11 @@
# ifdef BOOST_HASH_TEST_STD_INCLUDES # ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
# else # else
# include <boost/functional/hash.hpp> # include <boost/container_hash/hash.hpp>
# endif # endif
#endif #endif
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#include <map> #include <map>

6
test/hash_map_test.hpp
View File

@@ -7,15 +7,13 @@
#error "CONTAINER_TYPE not defined" #error "CONTAINER_TYPE not defined"
#else #else
#include <boost/preprocessor/cat.hpp>
#if defined(BOOST_MSVC) #if defined(BOOST_MSVC)
#pragma warning(push) #pragma warning(push)
#pragma warning(disable:4244) // conversion from 'int' to 'float' #pragma warning(disable:4244) // conversion from 'int' to 'float'
#pragma warning(disable:4245) // signed/unsigned mismatch #pragma warning(disable:4245) // signed/unsigned mismatch
#endif #endif
namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests) namespace HASH_TEST_CAT(CONTAINER_TYPE, _tests)
{ {
template <class T> template <class T>
void integer_tests(T* = 0) void integer_tests(T* = 0)
@@ -59,7 +57,7 @@ namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
} }
} }
void BOOST_PP_CAT(CONTAINER_TYPE, _hash_integer_tests()) void HASH_TEST_CAT(CONTAINER_TYPE, _hash_integer_tests())
{ {
integer_tests((CONTAINER_TYPE<char, unsigned char>*) 0); integer_tests((CONTAINER_TYPE<char, unsigned char>*) 0);
integer_tests((CONTAINER_TYPE<int, float>*) 0); integer_tests((CONTAINER_TYPE<int, float>*) 0);

2
test/hash_no_ext_fail_test.cpp
View File

@@ -14,7 +14,7 @@
#ifdef BOOST_HASH_TEST_STD_INCLUDES #ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
#else #else
# include <boost/functional/hash.hpp> # include <boost/container_hash/hash.hpp>
#endif #endif
template <class T> void ignore(T const&) {} template <class T> void ignore(T const&) {}

6
test/hash_no_ext_macro_1.cpp
View File

@@ -11,14 +11,14 @@
# if defined(BOOST_HASH_NO_EXTENSIONS) # if defined(BOOST_HASH_NO_EXTENSIONS)
# undef BOOST_HASH_NO_EXTENSIONS # undef BOOST_HASH_NO_EXTENSIONS
# endif # endif
# include <boost/functional/hash.hpp> # include <boost/container_hash/hash.hpp>
// Include header with BOOST_HASH_NO_EXTENSIONS defined // Include header with BOOST_HASH_NO_EXTENSIONS defined
# define BOOST_HASH_NO_EXTENSIONS # define BOOST_HASH_NO_EXTENSIONS
# include <boost/functional/hash.hpp> # include <boost/container_hash/hash.hpp>
#endif #endif
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#include <deque> #include <deque>
int main() int main()

6
test/hash_no_ext_macro_2.cpp
View File

@@ -11,14 +11,14 @@
# if !defined(BOOST_HASH_NO_EXTENSIONS) # if !defined(BOOST_HASH_NO_EXTENSIONS)
# define BOOST_HASH_NO_EXTENSIONS # define BOOST_HASH_NO_EXTENSIONS
# endif # endif
# include <boost/functional/hash.hpp> # include <boost/container_hash/hash.hpp>
// Include header without BOOST_HASH_NO_EXTENSIONS defined // Include header without BOOST_HASH_NO_EXTENSIONS defined
# undef BOOST_HASH_NO_EXTENSIONS # undef BOOST_HASH_NO_EXTENSIONS
# include <boost/functional/hash.hpp> # include <boost/container_hash/hash.hpp>
#endif #endif
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#include <map> #include <map>
int main() int main()

11
test/hash_number_test.cpp
View File

@@ -8,15 +8,14 @@
#ifdef BOOST_HASH_TEST_STD_INCLUDES #ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
#else #else
# include <boost/functional/hash.hpp> # include <boost/container_hash/hash.hpp>
#endif #endif
#include <iostream> #include <iostream>
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#include <boost/preprocessor/cat.hpp> #include <boost/container_hash/hash/detail/limits.hpp>
#include <boost/functional/hash/detail/limits.hpp> #include <boost/core/enable_if.hpp>
#include <boost/utility/enable_if.hpp>
#include "./compile_time.hpp" #include "./compile_time.hpp"
@@ -140,7 +139,7 @@ void bool_test()
{ {
BOOST_HASH_TEST_NAMESPACE::hash<bool> x1; BOOST_HASH_TEST_NAMESPACE::hash<bool> x1;
BOOST_HASH_TEST_NAMESPACE::hash<bool> x2; BOOST_HASH_TEST_NAMESPACE::hash<bool> x2;
BOOST_TEST(x1(true) == x2(true)); BOOST_TEST(x1(true) == x2(true));
BOOST_TEST(x1(false) == x2(false)); BOOST_TEST(x1(false) == x2(false));
BOOST_TEST(x1(true) != x2(false)); BOOST_TEST(x1(true) != x2(false));

4
test/hash_pointer_test.cpp
View File

@@ -8,10 +8,10 @@
#ifdef BOOST_HASH_TEST_STD_INCLUDES #ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
#else #else
# include <boost/functional/hash.hpp> # include <boost/container_hash/hash.hpp>
#endif #endif
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#include <boost/limits.hpp> #include <boost/limits.hpp>
#include "./compile_time.hpp" #include "./compile_time.hpp"

4
test/hash_range_test.cpp
View File

@@ -14,10 +14,10 @@ int main() {}
#ifdef BOOST_HASH_TEST_STD_INCLUDES #ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
#else #else
# include <boost/functional/hash.hpp> # include <boost/container_hash/hash.hpp>
#endif #endif
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#include <boost/limits.hpp> #include <boost/limits.hpp>
#include <vector> #include <vector>

6
test/hash_sequence_test.hpp
View File

@@ -7,14 +7,12 @@
#error "CONTAINER_TYPE not defined" #error "CONTAINER_TYPE not defined"
#else #else
#include <boost/preprocessor/cat.hpp>
#if defined(BOOST_MSVC) #if defined(BOOST_MSVC)
#pragma warning(push) #pragma warning(push)
#pragma warning(disable:4245) // signed/unsigned mismatch #pragma warning(disable:4245) // signed/unsigned mismatch
#endif #endif
namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests) namespace HASH_TEST_CAT(CONTAINER_TYPE, _tests)
{ {
template <class T> template <class T>
void integer_tests(T* = 0) void integer_tests(T* = 0)
@@ -61,7 +59,7 @@ namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
} }
} }
void BOOST_PP_CAT(CONTAINER_TYPE, _hash_integer_tests()) void HASH_TEST_CAT(CONTAINER_TYPE, _hash_integer_tests())
{ {
integer_tests((CONTAINER_TYPE<char>*) 0); integer_tests((CONTAINER_TYPE<char>*) 0);
integer_tests((CONTAINER_TYPE<int>*) 0); integer_tests((CONTAINER_TYPE<int>*) 0);

4
test/hash_set_test.cpp
View File

@@ -9,11 +9,11 @@
# ifdef BOOST_HASH_TEST_STD_INCLUDES # ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
# else # else
# include <boost/functional/hash.hpp> # include <boost/container_hash/hash.hpp>
# endif # endif
#endif #endif
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#ifdef BOOST_HASH_TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS

6
test/hash_set_test.hpp
View File

@@ -7,14 +7,12 @@
#error "CONTAINER_TYPE not defined" #error "CONTAINER_TYPE not defined"
#else #else
#include <boost/preprocessor/cat.hpp>
#if defined(BOOST_MSVC) #if defined(BOOST_MSVC)
#pragma warning(push) #pragma warning(push)
#pragma warning(disable:4245) // signed/unsigned mismatch #pragma warning(disable:4245) // signed/unsigned mismatch
#endif #endif
namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests) namespace HASH_TEST_CAT(CONTAINER_TYPE, _tests)
{ {
template <class T> template <class T>
void integer_tests(T* = 0) void integer_tests(T* = 0)
@@ -64,7 +62,7 @@ namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
} }
} }
void BOOST_PP_CAT(CONTAINER_TYPE, _hash_integer_tests()) void HASH_TEST_CAT(CONTAINER_TYPE, _hash_integer_tests())
{ {
integer_tests((CONTAINER_TYPE<char>*) 0); integer_tests((CONTAINER_TYPE<char>*) 0);
integer_tests((CONTAINER_TYPE<int>*) 0); integer_tests((CONTAINER_TYPE<int>*) 0);

4
test/hash_std_array_test.cpp
View File

@@ -9,12 +9,12 @@
# ifdef BOOST_HASH_TEST_STD_INCLUDES # ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
# else # else
# include <boost/functional/hash.hpp> # include <boost/container_hash/hash.hpp>
# endif # endif
#endif #endif
#include <boost/config.hpp> #include <boost/config.hpp>
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#if defined(BOOST_HASH_TEST_EXTENSIONS) && !defined(BOOST_NO_CXX11_HDR_ARRAY) #if defined(BOOST_HASH_TEST_EXTENSIONS) && !defined(BOOST_NO_CXX11_HDR_ARRAY)
#define TEST_ARRAY #define TEST_ARRAY

4
test/hash_std_smart_ptr_test.cpp
View File

@@ -8,10 +8,10 @@
#ifdef BOOST_HASH_TEST_STD_INCLUDES #ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
#else #else
# include <boost/functional/hash.hpp> # include <boost/container_hash/hash.hpp>
#endif #endif
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#include "./compile_time.hpp" #include "./compile_time.hpp"
#if defined(BOOST_HASH_TEST_EXTENSIONS) && !defined(BOOST_NO_CXX11_SMART_PTR) #if defined(BOOST_HASH_TEST_EXTENSIONS) && !defined(BOOST_NO_CXX11_SMART_PTR)

4
test/hash_std_tuple_test.cpp
View File

@@ -9,12 +9,12 @@
# ifdef BOOST_HASH_TEST_STD_INCLUDES # ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
# else # else
# include <boost/functional/hash.hpp> # include <boost/container_hash/hash.hpp>
# endif # endif
#endif #endif
#include <boost/config.hpp> #include <boost/config.hpp>
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#if defined(BOOST_HASH_TEST_EXTENSIONS) && !defined(BOOST_NO_CXX11_HDR_TUPLE) #if defined(BOOST_HASH_TEST_EXTENSIONS) && !defined(BOOST_NO_CXX11_HDR_TUPLE)
#define TEST_TUPLE #define TEST_TUPLE

4
test/hash_string_test.cpp
View File

@@ -8,10 +8,10 @@
#ifdef BOOST_HASH_TEST_STD_INCLUDES #ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
#else #else
# include <boost/functional/hash.hpp> # include <boost/container_hash/hash.hpp>
#endif #endif
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#include <string> #include <string>
#include "./compile_time.hpp" #include "./compile_time.hpp"

4
test/hash_type_index_test.cpp
View File

@@ -8,10 +8,10 @@
#ifdef BOOST_HASH_TEST_STD_INCLUDES #ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
#else #else
# include <boost/functional/hash.hpp> # include <boost/container_hash/hash.hpp>
#endif #endif
#include <boost/config.hpp> #include <boost/config.hpp>
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX) #if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX)

4
test/hash_value_array_test.cpp
View File

@@ -12,11 +12,11 @@
# ifdef BOOST_HASH_TEST_STD_INCLUDES # ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
# else # else
# include <boost/functional/hash.hpp> # include <boost/container_hash/hash.hpp>
# endif # endif
#endif #endif
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#ifdef BOOST_HASH_TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS

4
test/hash_vector_test.cpp
View File

@@ -9,11 +9,11 @@
# ifdef BOOST_HASH_TEST_STD_INCLUDES # ifdef BOOST_HASH_TEST_STD_INCLUDES
# include <functional> # include <functional>
# else # else
# include <boost/functional/hash.hpp> # include <boost/container_hash/hash.hpp>
# endif # endif
#endif #endif
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#ifdef BOOST_HASH_TEST_EXTENSIONS #ifdef BOOST_HASH_TEST_EXTENSIONS

2
test/implicit_test.cpp
View File

@@ -3,7 +3,7 @@
// Distributed under the Boost Software License, Version 1.0. (See accompanying // 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) // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/functional/hash.hpp> #include <boost/container_hash/hash.hpp>
namespace test namespace test
{ {

4
test/link_ext_test.cpp
View File

@@ -6,8 +6,8 @@
#include "./config.hpp" #include "./config.hpp"
#define BOOST_HASH_TEST_NAMESPACE boost #define BOOST_HASH_TEST_NAMESPACE boost
#include <boost/functional/hash.hpp> #include <boost/container_hash/hash.hpp>
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#include <vector> #include <vector>
int f(std::size_t hash1, int* x1) { int f(std::size_t hash1, int* x1) {

4
test/link_no_ext_test.cpp
View File

@@ -7,8 +7,8 @@
#define BOOST_HASH_TEST_NAMESPACE boost #define BOOST_HASH_TEST_NAMESPACE boost
#define BOOST_HASH_NO_EXTENSIONS #define BOOST_HASH_NO_EXTENSIONS
#include <boost/functional/hash.hpp> #include <boost/container_hash/hash.hpp>
#include <boost/detail/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
extern int f(std::size_t, int*); extern int f(std::size_t, int*);

2
test/link_test.cpp
View File

@@ -5,7 +5,7 @@
#include "./config.hpp" #include "./config.hpp"
#include <boost/functional/hash.hpp> #include <boost/container_hash/hash.hpp>
extern int f(); extern int f();
int main() { return f(); } int main() { return f(); }

2
test/link_test_2.cpp
View File

@@ -5,6 +5,6 @@
#include "./config.hpp" #include "./config.hpp"
#include <boost/functional/hash.hpp> #include <boost/container_hash/hash.hpp>
int f() { return 0; } int f() { return 0; }

2
test/namespace_fail_test.cpp
View File

@@ -9,7 +9,7 @@
#include "./config.hpp" #include "./config.hpp"
#include <list> #include <list>
#include <boost/functional/hash.hpp> #include <boost/container_hash/hash.hpp>
typedef list<int> foo; typedef list<int> foo;