relnotes: info about breaking change

But I do not know if they copile with QuickBook.

doc/00_optional.qbk

@@ -2,7 +2,7 @@
     [quickbook 1.4]
     [authors [Cacciola Carballal, Fernando Luis]]
     [copyright 2003-2007 Fernando Luis Cacciola Carballal]
-    [copyright 2014-2021 Andrzej Krzemieński]
+    [copyright 2014-2022 Andrzej Krzemieński]
     [category miscellaneous]
     [id optional]
     [dirname optional]

doc/17_gotchas.qbk

@@ -61,12 +61,12 @@ When an optional object that contains a value is moved from (is a source of move
     assert (opi);
     assert (*opi == nullptr);
 
-Quite a lot of people expect that when an object that contains a value is moved from, its contained value should be destroyed. This is not so, for performance reasons. Current semantics allow the implementation of `boost::opiotnal<T>` to be trivially copyable when `T` is trivial.
+Quite a lot of people expect that when an object that contains a value is moved from, its contained value should be destroyed. This is not so, for performance reasons. Current semantics allow the implementation of `boost::optional<T>` to be trivially copyable when `T` is trivial.
 [endsect]
 
 [section Mixed relational comparisons]
 
-Because `T` is convertible to `optional<T>` and because `opiotnal<T>` is __SGI_LESS_THAN_COMPARABLE__ when `T` is __SGI_LESS_THAN_COMPARABLE__,
+Because `T` is convertible to `optional<T>` and because `optional<T>` is __SGI_LESS_THAN_COMPARABLE__ when `T` is __SGI_LESS_THAN_COMPARABLE__,
 you can sometimes get an unexpected runtime result where you would rather expect a compiler error:
 
     optional<double> Flight_plan::weight(); // sometimes no weight can be returned
@@ -108,4 +108,4 @@ This is obviously redundant, but makes the warning disappear.
 
 [endsect]
 
-[endsect]
+[endsect]

doc/23_ref_optional_io.qbk

@@ -26,11 +26,11 @@ template <class CharType, class CharTrait, class T>
   template <class CharType, class CharTrait>
   std::basic_ostream<CharType, CharTrait>&
   operator<<(std::basic_ostream<CharType, CharTrait>& out, none_t const&); ``[link reference_operator_ostream_none __GO_TO__]``
-  
+
 template<class CharType, class CharTrait, class T>
   std::basic_istream<CharType, CharTrait>&
   operator>>(std::basic_istream<CharType, CharTrait>& in, optional<T>& v); ``[link reference_operator_istream __GO_TO__]``
-  
+
 } // namespace boost
 ```
 
@@ -43,8 +43,8 @@ template<class CharType, class CharTrait, class T>
 
 
 `template <class CharType, class CharTrait, class T>` [br]
-\u00A0\u00A0\u00A0\u00A0`std::basic_ostream<CharType, CharTrait>&` [br]
-\u00A0\u00A0\u00A0\u00A0`operator<<(std::basic_ostream<CharType, CharTrait>& out, optional<T> const& v);`
+ std::basic_ostream<CharType, CharTrait>&` [br]
+ operator<<(std::basic_ostream<CharType, CharTrait>& out, optional<T> const& v);`
 
 * [*Effect:] Outputs an implementation-defined string. The output contains the information about whether the optional object contains a value or not. If `v` contains a value, the output contains result of calling `out << *v`.
 * [*Returns:] `out`.
@@ -53,8 +53,8 @@ __SPACE__
 [#reference_operator_ostream_none]
 
 `template <class CharType, class CharTrait, class T>` [br]
-\u00A0\u00A0\u00A0\u00A0`std::basic_ostream<CharType, CharTrait>&` [br]
-\u00A0\u00A0\u00A0\u00A0`operator<<(std::basic_ostream<CharType, CharTrait>& out, none_t);`
+ std::basic_ostream<CharType, CharTrait>&` [br]
+ operator<<(std::basic_ostream<CharType, CharTrait>& out, none_t);`
 
 * [*Effect:] Outputs an implementation-defined string.
 * [*Returns:] `out`.
@@ -63,11 +63,11 @@ __SPACE__
 [#reference_operator_istream]
 
 `template <class CharType, class CharTrait, class T>` [br]
-\u00A0\u00A0\u00A0\u00A0`std::basic_ostream<CharType, CharTrait>&` [br]
-\u00A0\u00A0\u00A0\u00A0`operator>>(std::basic_istream<CharType, CharTrait>& in, optional<T>& v);`
+ std::basic_ostream<CharType, CharTrait>&` [br]
+ operator>>(std::basic_istream<CharType, CharTrait>& in, optional<T>& v);`
 
 * [*Requires:] `T` is __SGI_DEFAULT_CONSTRUCTIBLE__ and __MOVE_CONSTRUCTIBLE__.
-* [*Effect:] Reads the value of optional object from `in`. If the string representation indicates that the optional object should contain a value, `v` contains a value and its contained value is obtained as if by default-constructing an object `o` of type `T` and then calling `in >> o`; otherwise `v` does not contain a value, and the previously contained value (if any) has been destroyed. 
+* [*Effect:] Reads the value of optional object from `in`. If the string representation indicates that the optional object should contain a value, `v` contains a value and its contained value is obtained as if by default-constructing an object `o` of type `T` and then calling `in >> o`; otherwise `v` does not contain a value, and the previously contained value (if any) has been destroyed.
 * [*Returns:] `out`.
 
 [endsect]

doc/27_ref_optional_synopsis.qbk

@@ -73,6 +73,16 @@
 
     } // namespace boost
 
+    namespace std {
+
+    template <typename T>
+    struct hash<boost::optional<T> > ; ``[link reference_std_hash_spec __GO_TO__]``
+
+    template <typename T>
+    struct hash<boost::optional<T&> > ; ``[link reference_std_hash_spec __GO_TO__]``
+
+    } // namespace std
+
 
 [endsect]
 

doc/28_ref_optional_semantics.qbk

@@ -1408,3 +1408,37 @@ assert (addressof(*opt0) == addressof(y));
 ``
 
 [endsect]
+
+
+[section Detailed Semantics - std::hash Specializations]
+
+__SPACE__
+[#reference_std_hash_spec]
+
+``
+namespace std {
+
+template <typename T>
+struct hash<boost::optional<T> > ;
+
+template <typename T>
+struct hash<boost::optional<T&> > ;
+
+} // namespace std
+``
+
+The specialization `hash<optional<T>>` is enabled if and only if
+`hash<remove_­const_­t<T>>` is enabled. When enabled, for an object `o`
+of type `optional<T>`, if `o.has_­value() == true`, then `hash<optional<T>>()(o)`
+ evaluates to the same value as `hash<remove_­const_­t<T>>()(*o)`; otherwise it
+evaluates to an unspecified value.
+The member functions are not guaranteed to be `noexcept`.
+
+[caution
+You may get compiler errors when your program provides specializations for
+`std::hash<boost::optional<T>>`. If this happens, define macro
+`BOOST_OPTIONAL_CONFIG_DO_NOT_SPECIALIZE_STD_HASH` to suppress the specializations
+of `std::hash` in this library.
+]
+
+[endsect]

doc/91_relnotes.qbk

@@ -1,7 +1,7 @@
 [/
     Boost.Optional
 
-    Copyright (c) 2015 - 2021 Andrzej Krzemienski
+    Copyright (c) 2015 - 2022 Andrzej Krzemienski
 
     Distributed under the Boost Software License, Version 1.0.
     (See accompanying file LICENSE_1_0.txt or copy at
@@ -11,6 +11,10 @@
 
 [section:relnotes Release Notes]
 
+[heading Boost Release 1.80]
+
+* [*Breaking change:] Added specializations for `std::hash<boost::opitonal<T>>`. This fixes [@https://github.com/boostorg/optional/issues/55 issue #55]. You may get compiler errors when your program provides specializations for `std::hash<boost::optional<T>>`. If this happens, define macro `BOOST_OPTIONAL_CONFIG_DO_NOT_SPECIALIZE_STD_HASH` to suppress the specializations of `std::hash` in this library.
+
 [heading Boost Release 1.79]
 
 * Fixed [@https://github.com/boostorg/optional/issues/98 issue #98].

include/boost/optional/detail/optional_aligned_storage.hpp

@@ -28,7 +28,7 @@ class aligned_storage
     // BOOST_MAY_ALIAS works around GCC warnings about breaking strict aliasing rules when casting storage address to T*
     union BOOST_MAY_ALIAS dummy_u
     {
-        char data[ sizeof(T) ];
+        unsigned char data[ sizeof(T) ];
         BOOST_DEDUCED_TYPENAME type_with_alignment<
           ::boost::alignment_of<T>::value >::type aligner_;
     } dummy_ ;

include/boost/optional/detail/optional_hash.hpp

@@ -0,0 +1,49 @@
+// Copyright (C) 2022 Andrzej Krzemienski.
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/libs/optional for documentation.
+//
+// You are welcome to contact the author at:
+//  akrzemi1@gmail.com
+
+#ifndef BOOST_OPTIONAL_DETAIL_OPTIONAL_HASH_AJK_20MAY2022_HPP
+#define BOOST_OPTIONAL_DETAIL_OPTIONAL_HASH_AJK_20MAY2022_HPP
+
+#include <boost/optional/optional_fwd.hpp>
+#include <boost/config.hpp>
+
+#if !defined(BOOST_OPTIONAL_CONFIG_DO_NOT_SPECIALIZE_STD_HASH) && !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
+
+#include <functional>
+
+namespace std
+{
+  template <typename T>
+  struct hash<boost::optional<T> >
+  {
+    typedef std::size_t result_type;
+    typedef boost::optional<T> argument_type;
+
+    BOOST_CONSTEXPR result_type operator()(const argument_type& arg) const {
+      return arg ? std::hash<T>()(*arg) : result_type();
+    }
+  };
+
+  template <typename T>
+  struct hash<boost::optional<T&> >
+  {
+    typedef std::size_t result_type;
+    typedef boost::optional<T&> argument_type;
+
+    BOOST_CONSTEXPR result_type operator()(const argument_type& arg) const {
+      return arg ? std::hash<T>()(*arg) : result_type();
+    }
+  };
+}
+
+#endif // !defined(BOOST_OPTIONAL_CONFIG_DO_NOT_SPECIALIZE_STD_HASH) && !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
+
+#endif // header guard

include/boost/optional/detail/optional_trivially_copyable_base.hpp

@@ -1,3 +1,14 @@
+// Copyright (C) 2017 Andrzej Krzemienski.
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/libs/optional for documentation.
+//
+// You are welcome to contact the author at:
+//  akrzemi1@gmail.com
+
 // trivilally-copyable version of the storage
 
 template<class T>
@@ -69,7 +80,7 @@ class tc_optional_base : public optional_tag
     // ~tc_optional_base() = default;
 
     // Assigns from another optional<T> (deep-copies the rhs value)
-    void assign ( tc_optional_base const& rhs ) 
+    void assign ( tc_optional_base const& rhs )
     {
       *this = rhs;
     }
@@ -84,7 +95,7 @@ class tc_optional_base : public optional_tag
 #else
         m_storage = static_cast<value_type>(rhs.get());
 #endif
-          
+
       m_initialized = rhs.is_initialized();
     }
 
@@ -99,7 +110,7 @@ class tc_optional_base : public optional_tag
       m_initialized = rhs.is_initialized();
     }
 #endif
-    
+
     void assign ( argument_type val )
     {
       construct(val);
@@ -166,7 +177,7 @@ class tc_optional_base : public optional_tag
     {
       construct(in_place_init, boost::forward<Args>(args)...);
     }
-     
+
     template<class... Args>
     explicit tc_optional_base ( in_place_init_t, Args&&... args )
       :
@@ -174,7 +185,7 @@ class tc_optional_base : public optional_tag
     {
       construct(in_place_init, boost::forward<Args>(args)...);
     }
-    
+
     template<class... Args>
     explicit tc_optional_base ( in_place_init_if_t, bool cond, Args&&... args )
       :
@@ -190,24 +201,24 @@ class tc_optional_base : public optional_tag
        m_storage = value_type( boost::forward<Arg>(arg) );
        m_initialized = true ;
      }
-     
+
     void construct ( in_place_init_t )
      {
        m_storage = value_type();
        m_initialized = true ;
      }
-     
+
     template<class Arg>
     void emplace_assign ( Arg&& arg )
      {
        construct(in_place_init, boost::forward<Arg>(arg)) ;
      }
-     
+
     void emplace_assign ()
      {
        construct(in_place_init) ;
      }
-     
+
     template<class Arg>
     explicit tc_optional_base ( in_place_init_t, Arg&& arg )
       :
@@ -215,11 +226,11 @@ class tc_optional_base : public optional_tag
     {
       construct(in_place_init, boost::forward<Arg>(arg));
     }
-    
+
     explicit tc_optional_base ( in_place_init_t )
       :
       m_initialized(false), m_storage() {}
-    
+
     template<class Arg>
     explicit tc_optional_base ( in_place_init_if_t, bool cond, Arg&& arg )
       :
@@ -228,7 +239,7 @@ class tc_optional_base : public optional_tag
       if ( cond )
         construct(in_place_init, boost::forward<Arg>(arg));
     }
-    
+
     explicit tc_optional_base ( in_place_init_if_t, bool cond )
       :
       m_initialized(false)
@@ -238,21 +249,21 @@ class tc_optional_base : public optional_tag
     }
 
 #else
-     
+
     template<class Arg>
     void construct ( in_place_init_t, const Arg& arg )
      {
        m_storage = value_type( arg );
        m_initialized = true ;
      }
-     
+
     template<class Arg>
     void construct ( in_place_init_t, Arg& arg )
      {
        m_storage = value_type( arg );
        m_initialized = true ;
      }
-     
+
     void construct ( in_place_init_t )
      {
        m_storage = value_type();
@@ -264,18 +275,18 @@ class tc_optional_base : public optional_tag
     {
       construct(in_place_init, arg);
     }
-     
+
     template<class Arg>
     void emplace_assign ( Arg& arg )
     {
       construct(in_place_init, arg);
     }
-     
+
     void emplace_assign ()
     {
       construct(in_place_init);
     }
-    
+
     template<class Arg>
     explicit tc_optional_base ( in_place_init_t, const Arg& arg )
       : m_initialized(false)
@@ -289,13 +300,13 @@ class tc_optional_base : public optional_tag
     {
       construct(in_place_init, arg);
     }
-    
+
     explicit tc_optional_base ( in_place_init_t )
       : m_initialized(false)
     {
       construct(in_place_init);
     }
-    
+
     template<class Arg>
     explicit tc_optional_base ( in_place_init_if_t, bool cond, const Arg& arg )
       : m_initialized(false)
@@ -303,15 +314,15 @@ class tc_optional_base : public optional_tag
       if ( cond )
         construct(in_place_init, arg);
     }
-    
+
     template<class Arg>
     explicit tc_optional_base ( in_place_init_if_t, bool cond, Arg& arg )
       : m_initialized(false)
     {
       if ( cond )
         construct(in_place_init, arg);
-    } 
-    
+    }
+
     explicit tc_optional_base ( in_place_init_if_t, bool cond )
       : m_initialized(false)
     {

include/boost/optional/optional.hpp

@@ -65,6 +65,7 @@
 #include <boost/optional/detail/optional_config.hpp>
 #include <boost/optional/detail/optional_factory_support.hpp>
 #include <boost/optional/detail/optional_aligned_storage.hpp>
+#include <boost/optional/detail/optional_hash.hpp>
 
 namespace boost { namespace optional_detail {
 

test/Jamfile.v2

@@ -26,6 +26,7 @@ import testing ;
     [ run optional_test_empty_braces.cpp ]
     [ run optional_test_make_optional.cpp ]
     [ run optional_test_flat_map.cpp ]
+    [ run optional_test_hash.cpp ]
     [ run optional_test_map.cpp ]
     [ run optional_test_tie.cpp ]
     [ run optional_test_ref_assign_portable_minimum.cpp ]

test/optional_test_hash.cpp

@@ -0,0 +1,64 @@
+// Copyright (C) 2014 Andrzej Krzemienski.
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/lib/optional for documentation.
+//
+// You are welcome to contact the author at:
+//  akrzemi1@gmail.com
+
+#include "boost/optional/optional.hpp"
+#include "boost/config.hpp"
+#include "boost/core/lightweight_test.hpp"
+
+#if !defined(BOOST_NO_CXX11_HDR_UNORDERED_SET) && !defined(BOOST_OPTIONAL_CONFIG_DO_NOT_SPECIALIZE_STD_HASH)
+
+#include <unordered_set>
+
+void test_unordered_map()
+{
+  std::unordered_set<boost::optional<int> > set;
+  set.insert(boost::optional<int>(1));
+  set.insert(boost::optional<int>(1));
+
+
+  BOOST_TEST(set.size() == 1u);
+  BOOST_TEST(set.find(boost::optional<int>(1)) != set.end());
+}
+
+#else
+
+void test_unordered_map()
+{}
+
+#endif
+
+
+#if !defined(BOOST_OPTIONAL_CONFIG_DO_NOT_SPECIALIZE_STD_HASH) && !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
+
+void tets_hash()
+{
+  std::hash<boost::optional<int> > hash_int;
+  boost::optional<int> oN;
+  boost::optional<int> o1(1);
+
+  BOOST_TEST(hash_int(oN) == hash_int(oN));
+  BOOST_TEST(hash_int(o1) == hash_int(o1));
+}
+
+#else
+
+void tets_hash()
+{}
+
+#endif
+
+
+int main()
+{
+  test_unordered_map();
+  tets_hash();
+  return boost::report_errors();
+}