Add examples/point2.cpp

.drone.jsonnet

@@ -140,12 +140,26 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
         { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14', ADDRMD: '32,64' },
     ),
 
+    linux_pipeline(
+        "Linux 18.04 GCC 6 32/64",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-6', CXXSTD: '03,11,14', ADDRMD: '32,64' },
+        "g++-6-multilib",
+    ),
+
     linux_pipeline(
         "Linux 18.04 GCC 7* 32/64",
         "cppalliance/droneubuntu1804:1",
         { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17', ADDRMD: '32,64' },
     ),
 
+    linux_pipeline(
+        "Linux 18.04 GCC 8 32/64",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-8', CXXSTD: '03,11,14,17', ADDRMD: '32,64' },
+        "g++-8-multilib",
+    ),
+
     linux_pipeline(
         "Linux 20.04 GCC 9* 32/64",
         "cppalliance/droneubuntu2004:1",
@@ -166,6 +180,13 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
         arch="s390x",
     ),
 
+    linux_pipeline(
+        "Linux 20.04 GCC 10 32/64",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-10', CXXSTD: '03,11,14,17,20', ADDRMD: '32,64' },
+        "g++-10-multilib",
+    ),
+
     linux_pipeline(
         "Linux 22.04 GCC 11* 32/64",
         "cppalliance/droneubuntu2204:1",
@@ -214,6 +235,83 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
         "clang-3.8",
     ),
 
+    linux_pipeline(
+        "Linux 18.04 Clang 3.9",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.9', CXXSTD: '03,11,14' },
+        "clang-3.9",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 4.0",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-4.0', CXXSTD: '03,11,14' },
+        "clang-4.0",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 5.0",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-5.0', CXXSTD: '03,11,14,1z' },
+        "clang-5.0",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 6.0",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-6.0', CXXSTD: '03,11,14,17' },
+        "clang-6.0",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 7",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-7', CXXSTD: '03,11,14,17' },
+        "clang-7",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 8",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-8', CXXSTD: '03,11,14,17' },
+        "clang-8",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 9",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-9', CXXSTD: '03,11,14,17,2a' },
+        "clang-9",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 10",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-10', CXXSTD: '03,11,14,17,2a' },
+        "clang-10",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 11",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-11', CXXSTD: '03,11,14,17,2a' },
+        "clang-11",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 12",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-12', CXXSTD: '03,11,14,17,2a' },
+        "clang-12",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 Clang 13",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-13', CXXSTD: '03,11,14,17,20' },
+        "clang-13",
+    ),
+
     linux_pipeline(
         "Linux 22.04 Clang 14 UBSAN",
         "cppalliance/droneubuntu2204:1",

doc/hash.adoc

@@ -22,6 +22,7 @@ include::hash/recent.adoc[]
 include::hash/tutorial.adoc[]
 include::hash/user.adoc[]
 include::hash/combine.adoc[]
+include::hash/describe.adoc[]
 include::hash/reference.adoc[]
 include::hash/notes.adoc[]
 include::hash/links.adoc[]

doc/hash/describe.adoc

@@ -0,0 +1,61 @@
+////
+Copyright 2022 Peter Dimov
+Distributed under the Boost Software License, Version 1.0.
+https://www.boost.org/LICENSE_1_0.txt
+////
+
+[#describe]
+= Hashing User Types with Boost.Describe
+:idprefix: describe_
+
+Let's look at our `point` class again:
+
+[source]
+----
+class point
+{
+    int x;
+    int y;
+
+public:
+
+    point() : x(0), y(0) {}
+    point(int x, int y) : x(x), y(y) {}
+};
+----
+
+If you're using {cpp}14 or above, a much easier way to add
+support for `boost::hash` to `point` is by using
+link:../../../describe/index.html[Boost.Describe] (and
+get an automatic definition of `operator==` for free):
+
+[source]
+----
+
+#include <boost/describe/class.hpp>
+#include <boost/describe/operators.hpp>
+
+class point
+{
+    int x;
+    int y;
+
+    BOOST_DESCRIBE_CLASS(point, (), (), (), (x, y))
+
+public:
+
+    point() : x(0), y(0) {}
+    point(int x, int y) : x(x), y(y) {}
+};
+
+using boost::describe::operators::operator==;
+using boost::describe::operators::operator!=;
+----
+
+(Full code for this example is at
+link:../../examples/point2.cpp[examples/point2.cpp].)
+
+Since the `point` class has been annotated with `BOOST_DESCRIBE_CLASS`,
+the library can enumerate its members (and base classes) and automatically
+synthesize the appropriate `hash_value` overload for it, without us needing
+to do so.

doc/hash/intro.adoc

@@ -32,6 +32,9 @@ Out of the box, `boost::hash` supports
 * unordered sequences, standard or user-defined (sequences for which the hash
   value does not depend on the element order, such as `std::unordered_set` and
   `std::unordered_map`);
+* described structs and classes -- ones that have been annotated with the
+  `BOOST_DESCRIBE_STRUCT` or `BOOST_DESCRIBE_CLASS` macros from
+  link:../../../describe/index.html[Boost.Describe];
 * `std::unique_ptr`, `std::shared_ptr`;
 * `std::type_index`;
 * `std::error_code`, `std::error_condition`;

doc/hash/recent.adoc

@@ -21,6 +21,9 @@ Major update.
 * User-defined containers (types that have `begin()` and `end()`
   member functions that return iterators) are now supported out
   of the box.
+* Described structs and classes (those annotated with
+  `BOOST_DESCRIBE_STRUCT` or `BOOST_DESCRIBE_CLASS`) are now
+  supported out of the box.
 * `hash_combine` has been improved.
 * The performance (and quality, as a result of the above change)
   of string hashing has been improved. `boost::hash` for strings

doc/hash/reference.adoc

@@ -29,6 +29,7 @@ namespace container_hash
 template<class T> struct is_range;
 template<class T> struct is_contiguous_range;
 template<class T> struct is_unordered_range;
+template<class T> struct is_described_class;
 
 } // namespace container_hash
 
@@ -103,6 +104,10 @@ template<class T>
 template<class T>
   std::size_t hash_value( T const& v );
 
+// Enabled only when container_hash::is_described_class<T>::value is true
+template<class T>
+  std::size_t hash_value( T const& v );
+
 template<class T>
   std::size_t hash_value( std::shared_ptr<T> const& v );
 
@@ -446,6 +451,34 @@ Remarks: ::
 This overload handles the standard unordered containers, such as
 `std::unordered_set` and `std::unordered_map`.
 
+[source]
+----
+// Enabled only when container_hash::is_described_class<T>::value is true
+template<class T>
+  std::size_t hash_value( T const& v );
+----
+
+Effects: ::
++
+[source]
+----
+std::size_t seed = 0;
+
+boost::hash_combine( seed, b1 );
+boost::hash_combine( seed, b2 );
+// ...
+boost::hash_combine( seed, bM );
+
+boost::hash_combine( seed, m1 );
+boost::hash_combine( seed, m2 );
+// ...
+boost::hash_combine( seed, mN );
+
+return seed;
+----
++
+where `bi` are the bases of `v` and `mi` are its members.
+
 [source]
 ----
 template<class T>
@@ -633,3 +666,40 @@ template<class T> struct is_unordered_range
 
 Users are allowed to specialize `is_unordered_range` for their types
 if the default behavior does not deduce the correct value.
+
+== <boost/container_hash/{zwsp}is_described_class.hpp>
+
+Defines the trait `boost::container_hash::is_described_class`.
+
+[source]
+----
+namespace boost
+{
+
+namespace container_hash
+{
+
+template<class T> struct is_described_class;
+
+} // namespace container_hash
+
+} // namespace boost
+----
+
+=== is_described_class<T>
+
+[source]
+----
+template<class T> struct is_described_class
+{
+    static constexpr bool value = /* see below */;
+};
+----
+
+`is_described_class<T>::value` is `true` when
+`boost::describe::has_describe_bases<T>::value` is `true`,
+`boost::describe::has_describe_members<T>::value` is `true`, and
+`T` is not a union.
+
+Users are allowed to specialize `is_described_class` for their types
+if the default behavior does not deduce the correct value.

doc/hash/user.adoc

@@ -74,7 +74,7 @@ assert(books.find(knife) != books.end());
 assert(books.find(dandelion) == books.end());
 ----
 
-The full example can be found in:
+The full example can be found in
 link:../../examples/books.hpp[examples/books.hpp] and
 link:../../examples/books.cpp[examples/books.cpp].
 

examples/Jamfile.v2

@@ -7,3 +7,4 @@ run books.cpp ;
 run point.cpp ;
 run portable.cpp ;
 run template.cpp : : : <toolset>msvc-8.0:<build>no ;
+run point2.cpp ;

examples/point2.cpp

@@ -0,0 +1,65 @@
+
+// Copyright 2005 Daniel James.
+// Copyright 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+// Force use of assert.
+#if defined(NDEBUG)
+#undef NDEBUG
+#endif
+
+#include <boost/container_hash/hash.hpp>
+#include <boost/describe/class.hpp>
+#include <boost/describe/operators.hpp>
+#include <cassert>
+
+// This example illustrates how to use Boost.Describe to obtain
+// automatic boost::hash support. For full details see the hash
+// tutorial.
+
+#if defined(BOOST_DESCRIBE_CXX14)
+
+class point
+{
+    int x;
+    int y;
+
+    BOOST_DESCRIBE_CLASS(point, (), (), (), (x, y))
+
+public:
+
+    point() : x(0), y(0) {}
+    point(int x, int y) : x(x), y(y) {}
+};
+
+using boost::describe::operators::operator==;
+using boost::describe::operators::operator!=;
+
+int main()
+{
+    boost::hash<point> point_hasher;
+
+    point p1(0, 0);
+    point p2(1, 2);
+    point p3(4, 1);
+    point p4 = p1;
+
+    assert(point_hasher(p1) == point_hasher(p4));
+
+    // These tests could legally fail, but if they did it'd be a pretty bad
+    // hash function.
+    assert(point_hasher(p1) != point_hasher(p2));
+    assert(point_hasher(p1) != point_hasher(p3));
+}
+
+#else
+
+#include <cstdio>
+
+int main()
+{
+    std::puts( "This example requires C++14." );
+}
+
+#endif

include/boost/container_hash/hash.hpp

@@ -63,6 +63,10 @@
 #include <variant>
 #endif
 
+#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
+# include <string_view>
+#endif
+
 namespace boost
 {
 
@@ -629,6 +633,30 @@ namespace boost
     };
 
 #endif
-}
+
+    // boost::unordered::hash_is_avalanching
+
+    namespace unordered
+    {
+        template<class T> struct hash_is_avalanching;
+        template<class Ch> struct hash_is_avalanching< boost::hash< std::basic_string<Ch> > >: boost::is_integral<Ch> {};
+
+        // boost::is_integral<char8_t> is false, but should be true (https://github.com/boostorg/type_traits/issues/175)
+#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
+        template<> struct hash_is_avalanching< boost::hash< std::basic_string<char8_t> > >: boost::true_type {};
+#endif
+
+#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
+
+        template<class Ch> struct hash_is_avalanching< boost::hash< std::basic_string_view<Ch> > >: boost::is_integral<Ch> {};
+
+#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
+        template<> struct hash_is_avalanching< boost::hash< std::basic_string_view<char8_t> > >: boost::true_type {};
+#endif
+
+#endif
+    } // namespace unordered
+
+} // namespace boost
 
 #endif // #ifndef BOOST_FUNCTIONAL_HASH_HASH_HPP

test/CMakeLists.txt

@@ -1,4 +1,4 @@
-# Copyright 2018, 2019, 2021 Peter Dimov
+# Copyright 2018, 2019, 2021, 2022 Peter Dimov
 # 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
 
@@ -6,6 +6,7 @@ include(BoostTestJamfile OPTIONAL RESULT_VARIABLE HAVE_BOOST_TEST)
 
 if(HAVE_BOOST_TEST)
 
-boost_test_jamfile(FILE Jamfile.v2 LINK_LIBRARIES Boost::container_hash Boost::core Boost::utility)
+boost_test_jamfile(FILE Jamfile.v2
+  LINK_LIBRARIES Boost::container_hash Boost::core Boost::utility Boost::unordered)
 
 endif()

test/Jamfile.v2

@@ -112,3 +112,6 @@ run is_described_class_test3.cpp
 
 run described_class_test.cpp
   : : : <warnings>extra ;
+
+run hash_is_avalanching_test.cpp ;
+run hash_is_avalanching_test2.cpp ;

test/hash_is_avalanching_test.cpp

@@ -0,0 +1,57 @@
+// Copyright 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/container_hash/hash.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
+
+BOOST_PRAGMA_MESSAGE( "Test skipped, BOOST_NO_CXX11_HDR_TYPE_TRAITS is defined" )
+int main() {}
+
+#elif defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+BOOST_PRAGMA_MESSAGE( "Test skipped, BOOST_NO_CXX11_TEMPLATE_ALIASES is defined" )
+int main() {}
+
+#else
+
+#include <boost/unordered/hash_traits.hpp>
+#include <string>
+
+enum my_char { min = 0, max = 255 };
+
+int main()
+{
+    using boost::unordered::hash_is_avalanching;
+
+    BOOST_TEST_TRAIT_TRUE(( hash_is_avalanching< boost::hash<std::string> > ));
+    BOOST_TEST_TRAIT_TRUE(( hash_is_avalanching< boost::hash<std::wstring> > ));
+
+#if !defined(BOOST_NO_CXX11_CHAR16_T)
+
+    BOOST_TEST_TRAIT_TRUE(( hash_is_avalanching< boost::hash<std::u16string> > ));
+
+#endif
+
+#if !defined(BOOST_NO_CXX11_CHAR32_T)
+
+    BOOST_TEST_TRAIT_TRUE(( hash_is_avalanching< boost::hash<std::u32string> > ));
+
+#endif
+
+#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
+
+    BOOST_TEST_TRAIT_TRUE(( hash_is_avalanching< boost::hash< std::basic_string<char8_t> > > ));
+
+#endif
+
+    BOOST_TEST_TRAIT_FALSE(( hash_is_avalanching< boost::hash<std::basic_string<my_char> > > ));
+
+    return boost::report_errors();
+}
+
+#endif

test/hash_is_avalanching_test2.cpp

@@ -0,0 +1,62 @@
+// Copyright 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/container_hash/hash.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
+
+BOOST_PRAGMA_MESSAGE( "Test skipped, BOOST_NO_CXX11_HDR_TYPE_TRAITS is defined" )
+int main() {}
+
+#elif defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+BOOST_PRAGMA_MESSAGE( "Test skipped, BOOST_NO_CXX11_TEMPLATE_ALIASES is defined" )
+int main() {}
+
+#elif defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
+
+BOOST_PRAGMA_MESSAGE( "Test skipped, BOOST_NO_CXX17_HDR_STRING_VIEW is defined" )
+int main() {}
+
+#else
+
+#include <boost/unordered/hash_traits.hpp>
+#include <string_view>
+
+enum my_char { min = 0, max = 255 };
+
+int main()
+{
+    using boost::unordered::hash_is_avalanching;
+
+    BOOST_TEST_TRAIT_TRUE(( hash_is_avalanching< boost::hash<std::string_view> > ));
+    BOOST_TEST_TRAIT_TRUE(( hash_is_avalanching< boost::hash<std::wstring_view> > ));
+
+#if !defined(BOOST_NO_CXX11_CHAR16_T)
+
+    BOOST_TEST_TRAIT_TRUE(( hash_is_avalanching< boost::hash<std::u16string_view> > ));
+
+#endif
+
+#if !defined(BOOST_NO_CXX11_CHAR32_T)
+
+    BOOST_TEST_TRAIT_TRUE(( hash_is_avalanching< boost::hash<std::u32string_view> > ));
+
+#endif
+
+#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
+
+    BOOST_TEST_TRAIT_TRUE(( hash_is_avalanching< boost::hash< std::basic_string_view<char8_t> > > ));
+
+#endif
+
+    BOOST_TEST_TRAIT_FALSE(( hash_is_avalanching< boost::hash<std::basic_string_view<my_char> > > ));
+
+    return boost::report_errors();
+}
+
+#endif