Add hash_multimap_test

include/boost/container_hash/hash.hpp

@@ -17,9 +17,9 @@
 #define BOOST_FUNCTIONAL_HASH_HASH_HPP
 
 #include <boost/container_hash/hash_fwd.hpp>
-#include <boost/container_hash/detail/is_range.hpp>
-#include <boost/container_hash/detail/is_contiguous_range.hpp>
-#include <boost/container_hash/detail/is_unordered_range.hpp>
+#include <boost/container_hash/is_range.hpp>
+#include <boost/container_hash/is_contiguous_range.hpp>
+#include <boost/container_hash/is_unordered_range.hpp>
 #include <boost/container_hash/detail/hash_tuple.hpp>
 #include <boost/type_traits/is_enum.hpp>
 #include <boost/type_traits/is_integral.hpp>
@@ -393,7 +393,7 @@ namespace boost
     // ranges (list, set, deque...)
 
     template <typename T>
-    typename boost::enable_if_<hash_detail::is_range<T>::value && !hash_detail::is_contiguous_range<T>::value && !hash_detail::is_unordered_range<T>::value, std::size_t>::type
+    typename boost::enable_if_<container_hash::is_range<T>::value && !container_hash::is_contiguous_range<T>::value && !container_hash::is_unordered_range<T>::value, std::size_t>::type
         hash_value( T const& v )
     {
         return boost::hash_range( v.begin(), v.end() );
@@ -402,7 +402,7 @@ namespace boost
     // contiguous ranges (string, vector, array)
 
     template <typename T>
-    typename boost::enable_if_<hash_detail::is_contiguous_range<T>::value, std::size_t>::type
+    typename boost::enable_if_<container_hash::is_contiguous_range<T>::value, std::size_t>::type
         hash_value( T const& v )
     {
         return boost::hash_range( v.data(), v.data() + v.size() );
@@ -411,7 +411,7 @@ namespace boost
     // unordered ranges (unordered_set, unordered_map)
 
     template <typename T>
-    typename boost::enable_if_<hash_detail::is_unordered_range<T>::value, std::size_t>::type
+    typename boost::enable_if_<container_hash::is_unordered_range<T>::value, std::size_t>::type
         hash_value( T const& v )
     {
         return boost::hash_unordered_range( v.begin(), v.end() );
@@ -422,7 +422,7 @@ namespace boost
     // resolve ambiguity with unconstrained stdext::hash_value in <xhash> :-/
 
     template<template<class...> class L, class... T>
-    typename boost::enable_if_<hash_detail::is_range<L<T...>>::value && !hash_detail::is_contiguous_range<L<T...>>::value && !hash_detail::is_unordered_range<L<T...>>::value, std::size_t>::type
+    typename boost::enable_if_<container_hash::is_range<L<T...>>::value && !container_hash::is_contiguous_range<L<T...>>::value && !container_hash::is_unordered_range<L<T...>>::value, std::size_t>::type
         hash_value( L<T...> const& v )
     {
         return boost::hash_range( v.begin(), v.end() );
@@ -431,14 +431,14 @@ namespace boost
     // contiguous ranges (string, vector, array)
 
     template<template<class...> class L, class... T>
-    typename boost::enable_if_<hash_detail::is_contiguous_range<L<T...>>::value, std::size_t>::type
+    typename boost::enable_if_<container_hash::is_contiguous_range<L<T...>>::value, std::size_t>::type
         hash_value( L<T...> const& v )
     {
         return boost::hash_range( v.data(), v.data() + v.size() );
     }
 
     template<template<class, std::size_t> class L, class T, std::size_t N>
-    typename boost::enable_if_<hash_detail::is_contiguous_range<L<T, N>>::value, std::size_t>::type
+    typename boost::enable_if_<container_hash::is_contiguous_range<L<T, N>>::value, std::size_t>::type
         hash_value( L<T, N> const& v )
     {
         return boost::hash_range( v.data(), v.data() + v.size() );
@@ -447,7 +447,7 @@ namespace boost
     // unordered ranges (unordered_set, unordered_map)
 
     template<template<class...> class L, class... T>
-    typename boost::enable_if_<hash_detail::is_unordered_range<L<T...>>::value, std::size_t>::type
+    typename boost::enable_if_<container_hash::is_unordered_range<L<T...>>::value, std::size_t>::type
         hash_value( L<T...> const& v )
     {
         return boost::hash_unordered_range( v.begin(), v.end() );

include/boost/container_hash/hash_fwd.hpp

@@ -10,15 +10,26 @@
 
 namespace boost
 {
-    template <class T> struct hash;
 
-    template <class T> void hash_combine(std::size_t& seed, T const& v);
+namespace container_hash
+{
 
-    template <class It> std::size_t hash_range(It, It);
-    template <class It> void hash_range(std::size_t&, It, It);
+template<class T> struct is_range;
+template<class T> struct is_contiguous_range;
+template<class T> struct is_unordered_range;
 
-    template <class It> std::size_t hash_unordered_range(It, It);
-    template <class It> void hash_unordered_range(std::size_t&, It, It);
-}
+} // namespace container_hash
+
+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 );
+
+template<class It> std::size_t hash_unordered_range( It, It );
+template<class It> void hash_unordered_range( std::size_t&, It, It );
+
+} // namespace boost
 
 #endif // #ifndef BOOST_FUNCTIONAL_HASH_FWD_HPP

include/boost/container_hash/is_contiguous_range.hpp

@@ -2,8 +2,8 @@
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 
-#ifndef BOOST_HASH_DETAIL_IS_CONTIGUOUS_RANGE_HPP_INCLUDED
-#define BOOST_HASH_DETAIL_IS_CONTIGUOUS_RANGE_HPP_INCLUDED
+#ifndef BOOST_HASH_IS_CONTIGUOUS_RANGE_HPP_INCLUDED
+#define BOOST_HASH_IS_CONTIGUOUS_RANGE_HPP_INCLUDED
 
 #include <boost/type_traits/integral_constant.hpp>
 #include <boost/config.hpp>
@@ -28,11 +28,16 @@ template<class It, class T, class S>
 template<class T> decltype( is_contiguous_range_check( declval<T const&>().begin(), declval<T const&>().end(), declval<T const&>().data(), declval<T const&>().data() + declval<T const&>().size(), declval<T const&>().size() ) ) is_contiguous_range_( int );
 template<class T> false_type is_contiguous_range_( ... );
 
+} // namespace hash_detail
+
+namespace container_hash
+{
+
 template<class T> struct is_contiguous_range: decltype( hash_detail::is_contiguous_range_<T>( 0 ) )
 {
 };
 
-} // namespace hash_detail
+} // namespace container_hash
 } // namespace boost
 
 #else // !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR)
@@ -46,7 +51,7 @@ template<class T> struct is_contiguous_range: decltype( hash_detail::is_contiguo
 
 namespace boost
 {
-namespace hash_detail
+namespace container_hash
 {
 
 template<class T> struct is_contiguous_range: false_type
@@ -73,9 +78,9 @@ template<class T, std::size_t N> struct is_contiguous_range< std::array<T, N> co
 
 #endif
 
-} // namespace hash_detail
+} // namespace container_hash
 } // namespace boost
 
 #endif // !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR)
 
-#endif // #ifndef BOOST_HASH_DETAIL_IS_CONTIGUOUS_RANGE_HPP_INCLUDED
+#endif // #ifndef BOOST_HASH_IS_CONTIGUOUS_RANGE_HPP_INCLUDED

include/boost/container_hash/is_range.hpp

@@ -2,8 +2,8 @@
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 
-#ifndef BOOST_HASH_DETAIL_IS_RANGE_HPP_INCLUDED
-#define BOOST_HASH_DETAIL_IS_RANGE_HPP_INCLUDED
+#ifndef BOOST_HASH_IS_RANGE_HPP_INCLUDED
+#define BOOST_HASH_IS_RANGE_HPP_INCLUDED
 
 #include <boost/type_traits/integral_constant.hpp>
 #include <boost/type_traits/is_integral.hpp>
@@ -16,11 +16,11 @@
 
 namespace boost
 {
+#if !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR) && !BOOST_WORKAROUND(BOOST_GCC, < 40700)
+
 namespace hash_detail
 {
 
-#if !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR) && !BOOST_WORKAROUND(BOOST_GCC, < 40700)
-
 template<class T, class It>
     integral_constant< bool, !is_same<typename remove_cv<T>::type, typename std::iterator_traits<It>::value_type>::value >
         is_range_check( It first, It last );
@@ -28,12 +28,22 @@ template<class T, class It>
 template<class T> decltype( is_range_check<T>( declval<T const&>().begin(), declval<T const&>().end() ) ) is_range_( int );
 template<class T> false_type is_range_( ... );
 
-template<class T> struct is_range: decltype( is_range_<T>( 0 ) )
+} // namespace hash_detail
+
+namespace container_hash
+{
+
+template<class T> struct is_range: decltype( hash_detail::is_range_<T>( 0 ) )
 {
 };
 
+} // namespace container_hash
+
 #else
 
+namespace hash_detail
+{
+
 template<class T, class E = true_type> struct is_range_: false_type
 {
 };
@@ -45,13 +55,19 @@ template<class T> struct is_range_< T, integral_constant< bool,
 {
 };
 
-template<class T> struct is_range: is_range_<T>
+} // namespace hash_detail
+
+namespace container_hash
+{
+
+template<class T> struct is_range: hash_detail::is_range_<T>
 {
 };
 
+} // namespace container_hash
+
 #endif // !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR)
 
-} // namespace hash_detail
 } // namespace boost
 
-#endif // #ifndef BOOST_HASH_DETAIL_IS_RANGE_HPP_INCLUDED
+#endif // #ifndef BOOST_HASH_IS_RANGE_HPP_INCLUDED

include/boost/container_hash/is_unordered_range.hpp

@@ -2,10 +2,10 @@
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 
-#ifndef BOOST_HASH_DETAIL_IS_UNORDERED_RANGE_HPP_INCLUDED
-#define BOOST_HASH_DETAIL_IS_UNORDERED_RANGE_HPP_INCLUDED
+#ifndef BOOST_HASH_IS_UNORDERED_RANGE_HPP_INCLUDED
+#define BOOST_HASH_IS_UNORDERED_RANGE_HPP_INCLUDED
 
-#include <boost/container_hash/detail/is_range.hpp>
+#include <boost/container_hash/is_range.hpp>
 #include <boost/type_traits/integral_constant.hpp>
 #include <boost/type_traits/is_same.hpp>
 
@@ -24,11 +24,16 @@ template<class T> struct has_hasher_< T, integral_constant< bool,
 {
 };
 
-template<class T> struct is_unordered_range: integral_constant< bool, is_range<T>::value && has_hasher_<T>::value >
+} // namespace hash_detail
+
+namespace container_hash
+{
+
+template<class T> struct is_unordered_range: integral_constant< bool, is_range<T>::value && hash_detail::has_hasher_<T>::value >
 {
 };
 
-} // namespace hash_detail
+} // namespace container_hash
 } // namespace boost
 
-#endif // #ifndef BOOST_HASH_DETAIL_IS_UNORDERED_RANGE_HPP_INCLUDED
+#endif // #ifndef BOOST_HASH_IS_UNORDERED_RANGE_HPP_INCLUDED

test/Jamfile.v2

@@ -62,9 +62,9 @@ build-project ../examples ;
 
 run hash_reference_values.cpp ;
 
-run detail_is_range_test.cpp ;
-run detail_is_contiguous_range_test.cpp ;
-run detail_is_unordered_range_test.cpp ;
+run is_range_test.cpp ;
+run is_contiguous_range_test.cpp ;
+run is_unordered_range_test.cpp ;
 
 run hash_forward_list_test.cpp ;
 
@@ -78,7 +78,7 @@ run hash_string_test2.cpp ;
 local fs-path-req = "-<toolset>gcc:<cxxflags>-Wshadow" "-<toolset>gcc:<cxxflags>-Wconversion" ;
 
 run hash_fs_path_test.cpp /boost//filesystem/<warnings>off : : : $(fs-path-req) <toolset>msvc-14.0,<cxxstd>latest:<build>no ;
-run detail_is_range_test2.cpp : : : $(fs-path-req) ;
+run is_range_test2.cpp : : : $(fs-path-req) ;
 
 run hash_container_test.cpp ;
 
@@ -86,3 +86,6 @@ run hash_vector_test2.cpp ;
 
 run hash_string_test3.cpp ;
 run hash_string_test4.cpp ;
+
+run hash_multiset_test.cpp ;
+run hash_multimap_test.cpp ;

test/hash_multimap_test.cpp

@@ -0,0 +1,46 @@
+// Copyright 2021, 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#if defined(__GNUC__) && __GNUC__ == 8
+# pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
+
+#include <boost/container_hash/hash.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <map>
+
+template<class T> void test()
+{
+    typedef std::multimap<T, T> map;
+    typedef boost::hash<map> hash;
+
+    int const N = 32;
+
+    std::size_t h[ N ];
+
+    map v;
+
+    for( int i = 0; i < N; ++i )
+    {
+        h[ i ] = hash()( v );
+
+        BOOST_TEST_EQ( h[ i ], hash()( v ) );
+
+        for( int j = 0; j < i; ++j )
+        {
+            BOOST_TEST_NE( h[ j ], h[ i ] );
+        }
+
+		v.insert( std::pair<T const, T>() );
+    }
+}
+
+int main()
+{
+    test<int>();
+    test<float>();
+    test<double>();
+
+    return boost::report_errors();
+}

test/hash_multiset_test.cpp

@@ -0,0 +1,46 @@
+// Copyright 2021, 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#if defined(__GNUC__) && __GNUC__ == 8
+# pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
+
+#include <boost/container_hash/hash.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <set>
+
+template<class T> void test()
+{
+    typedef std::multiset<T> set;
+    typedef boost::hash<set> hash;
+
+    int const N = 32;
+
+    std::size_t h[ N ];
+
+    set v;
+
+    for( int i = 0; i < N; ++i )
+    {
+        h[ i ] = hash()( v );
+
+        BOOST_TEST_EQ( h[ i ], hash()( v ) );
+
+        for( int j = 0; j < i; ++j )
+        {
+            BOOST_TEST_NE( h[ j ], h[ i ] );
+        }
+
+        v.insert( T() );
+    }
+}
+
+int main()
+{
+    test<int>();
+    test<float>();
+    test<double>();
+
+    return boost::report_errors();
+}

test/is_contiguous_range_test.cpp

@@ -2,7 +2,7 @@
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 
-#include <boost/container_hash/detail/is_contiguous_range.hpp>
+#include <boost/container_hash/is_contiguous_range.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
 #include <boost/config.hpp>
 #include <string>
@@ -30,7 +30,7 @@ struct X
 
 int main()
 {
-    using boost::hash_detail::is_contiguous_range;
+    using boost::container_hash::is_contiguous_range;
 
     BOOST_TEST_TRAIT_FALSE((is_contiguous_range<void>));
     BOOST_TEST_TRAIT_FALSE((is_contiguous_range<void const>));

test/is_range_test.cpp

@@ -2,7 +2,7 @@
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 
-#include <boost/container_hash/detail/is_range.hpp>
+#include <boost/container_hash/is_range.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
 #include <boost/config.hpp>
 #include <string>
@@ -30,7 +30,7 @@ struct X
 
 int main()
 {
-    using boost::hash_detail::is_range;
+    using boost::container_hash::is_range;
 
     BOOST_TEST_TRAIT_FALSE((is_range<void>));
     BOOST_TEST_TRAIT_FALSE((is_range<void const>));

test/is_range_test2.cpp

@@ -10,7 +10,7 @@
 # pragma GCC diagnostic ignored "-Wsign-conversion"
 #endif
 
-#include <boost/container_hash/detail/is_range.hpp>
+#include <boost/container_hash/is_range.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
 #include <boost/config.hpp>
 #include <boost/filesystem/path.hpp>
@@ -21,7 +21,7 @@
 
 int main()
 {
-    using boost::hash_detail::is_range;
+    using boost::container_hash::is_range;
 
     BOOST_TEST_TRAIT_FALSE((is_range< boost::filesystem::path >));
     BOOST_TEST_TRAIT_FALSE((is_range< boost::filesystem::path const >));

test/is_unordered_range_test.cpp

@@ -2,7 +2,7 @@
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 
-#include <boost/container_hash/detail/is_unordered_range.hpp>
+#include <boost/container_hash/is_unordered_range.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
 #include <boost/config.hpp>
 #include <string>
@@ -30,7 +30,7 @@ struct X
 
 int main()
 {
-    using boost::hash_detail::is_unordered_range;
+    using boost::container_hash::is_unordered_range;
 
     BOOST_TEST_TRAIT_FALSE((is_unordered_range<void>));
     BOOST_TEST_TRAIT_FALSE((is_unordered_range<void const>));