The (in)equality comparison with boost::none does not require that T be EqualityComparable

doc/html/boost_optional/detailed_semantics.html

@@ -1497,6 +1497,10 @@
         <span class="identifier">y</span> <span class="special">);</span></code>
       </p></blockquote></div>
 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+          <span class="bold"><strong>Requires:</strong></span> <code class="computeroutput"><span class="identifier">T</span></code>
+          shall meet requirements of <code class="computeroutput"><span class="identifier">EqualityComparable</span></code>.
+        </li>
 <li class="listitem">
           <span class="bold"><strong>Returns:</strong></span> If both <code class="computeroutput"><span class="identifier">x</span></code>
           and <code class="computeroutput"><span class="identifier">y</span></code> are initialized,
@@ -1553,6 +1557,10 @@
         <span class="identifier">y</span> <span class="special">);</span></code>
       </p></blockquote></div>
 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+          <span class="bold"><strong>Requires:</strong></span> <code class="computeroutput"><span class="identifier">T</span></code>
+          shall meet requirements of <code class="computeroutput"><span class="identifier">LessThanComparable</span></code>.
+        </li>
 <li class="listitem">
           <span class="bold"><strong>Returns:</strong></span> If <code class="computeroutput"><span class="identifier">y</span></code>
           is not initialized, <code class="computeroutput"><span class="keyword">false</span></code>.
@@ -1648,7 +1656,8 @@
 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 <li class="listitem">
           <span class="bold"><strong>Returns: </strong></span> <code class="computeroutput"><span class="special">!(</span>
-          <span class="identifier">y</span><span class="special">&lt;</span><span class="identifier">x</span> <span class="special">);</span></code>
+          <span class="identifier">y</span> <span class="special">&lt;</span>
+          <span class="identifier">x</span> <span class="special">);</span></code>
         </li>
 <li class="listitem">
           <span class="bold"><strong>Throws:</strong></span> Nothing.
@@ -1673,6 +1682,33 @@
           <span class="bold"><strong>Throws:</strong></span> Nothing.
         </li>
 </ul></div>
+<a name="reference_operator_compare_equal_optional_none"></a><div class="blockquote"><blockquote class="blockquote"><p>
+        <code class="computeroutput"><span class="keyword">bool</span> <span class="keyword">operator</span>
+        <span class="special">==</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">none_t</span>
+        <span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></code>
+      </p></blockquote></div>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+          <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="special">!</span><span class="identifier">x</span></code>.
+        </li>
+<li class="listitem">
+          <span class="bold"><strong>Notes:</strong></span> <code class="computeroutput"><span class="identifier">T</span></code>
+          need not meet requirements of <code class="computeroutput"><span class="identifier">EqualityComparable</span></code>.
+        </li>
+</ul></div>
+<p>
+      <span class="inlinemediaobject"><img src="../images/space.png" alt="space"></span>
+    </p>
+<a name="reference_operator_compare_not_equal_optional_none"></a><div class="blockquote"><blockquote class="blockquote"><p>
+        <code class="computeroutput"><span class="keyword">bool</span> <span class="keyword">operator</span>
+        <span class="special">!=</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">none_t</span>
+        <span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></code>
+      </p></blockquote></div>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+          <span class="bold"><strong>Returns: </strong></span> <code class="computeroutput"><span class="special">!(</span>
+          <span class="identifier">x</span> <span class="special">==</span>
+          <span class="identifier">y</span> <span class="special">);</span></code>
+        </li></ul></div>
 <p>
       <span class="inlinemediaobject"><img src="../images/space.png" alt="space"></span>
     </p>

doc/html/boost_optional/synopsis.html

@@ -122,6 +122,10 @@
 
 <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">inline</span> <span class="keyword">bool</span> <span class="keyword">operator</span> <span class="special">&gt;=</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">y</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_operator_compare_greater_or_equal_optional_optional"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
 
+<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">inline</span> <span class="keyword">bool</span> <span class="keyword">operator</span> <span class="special">==</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">none_t</span> <span class="special">)</span> <span class="keyword">noexcept</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_operator_compare_equal_optional_none"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
+
+<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">inline</span> <span class="keyword">bool</span> <span class="keyword">operator</span> <span class="special">!=</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">none_t</span> <span class="special">)</span> <span class="keyword">noexcept</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_operator_compare_not_equal_optional_none"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
+
 <span class="comment">// [new in 1.34]</span>
 <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">inline</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">make_optional</span> <span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">v</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_make_optional_value"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
 

doc/html/boost_optional/type_requirements.html

@@ -27,9 +27,9 @@
 <a name="boost_optional.type_requirements"></a><a class="link" href="type_requirements.html" title="Type requirements">Type requirements</a>
 </h2></div></div></div>
 <p>
-      In general, <code class="computeroutput"><span class="identifier">T</span></code> must be <a href="../../../../utility/CopyConstructible.html" target="_top">Copy Constructible</a> and
+      In general, <code class="computeroutput"><span class="identifier">T</span></code> must be <code class="computeroutput"><span class="identifier">MoveConstructible</span></code> and have a no-throw destructor.
-      have a no-throw destructor. The copy-constructible requirement is not needed
+      The <code class="computeroutput"><span class="identifier">MoveConstructible</span></code> requirement
-      if <span class="bold"><strong>InPlaceFactories</strong></span> are used.
+      is not needed if <span class="bold"><strong>InPlaceFactories</strong></span> are used.
     </p>
 <p>
       <code class="computeroutput"><span class="identifier">T</span></code> <span class="underline">is

doc/html/index.html

@@ -163,7 +163,7 @@
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"><p><small>Last revised: April 28, 2014 at 23:21:56 GMT</small></p></td>
+<td align="left"><p><small>Last revised: April 29, 2014 at 20:56:30 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>

doc/reference.qbk

@@ -106,6 +106,10 @@
     template<class T> inline bool operator <= ( optional<T> const& x, optional<T> const& y ) ; ``[link reference_operator_compare_less_or_equal_optional_optional __GO_TO__]``
 
     template<class T> inline bool operator >= ( optional<T> const& x, optional<T> const& y ) ; ``[link reference_operator_compare_greater_or_equal_optional_optional __GO_TO__]``
+    
+    template<class T> inline bool operator == ( optional<T> const& x, none_t ) noexcept ; ``[link reference_operator_compare_equal_optional_none __GO_TO__]``
+
+    template<class T> inline bool operator != ( optional<T> const& x, none_t ) noexcept ; ``[link reference_operator_compare_not_equal_optional_none __GO_TO__]``
 
     // [new in 1.34]
     template<class T> inline optional<T> make_optional ( T const& v ) ; ``[link reference_make_optional_value __GO_TO__]``
@@ -972,6 +976,7 @@ __SPACE__
 
 [: `bool operator == ( optional<T> const& x, optional<T> const& y );`]
 
+* [*Requires:] `T` shall meet requirements of `EqualityComparable`.
 * [*Returns:] If both `x` and `y` are initialized, `(*x == *y)`. If only
 `x` or `y` is initialized, `false`. If both are uninitialized, `true`.
 * [*Throws:] Nothing.
@@ -1011,6 +1016,7 @@ __SPACE__
 
 [: `bool operator < ( optional<T> const& x, optional<T> const& y );`]
 
+* [*Requires:] `T` shall meet requirements of `LessThanComparable`.
 * [*Returns:] If `y` is not initialized, `false`. If `y` is initialized
 and `x` is not initialized, `true`. If both `x` and `y` are initialized,
 `(*x < *y)`.
@@ -1065,7 +1071,7 @@ __SPACE__
 
 [: `bool operator <= ( optional<T> const& x, optional<T> const& y );`]
 
-* [*Returns: ] `!( y<x );`
+* [*Returns: ] `!( y < x );`
 * [*Throws:] Nothing.
 
 __SPACE__
@@ -1077,6 +1083,23 @@ __SPACE__
 * [*Returns: ] `!( x<y );`
 * [*Throws:] Nothing.
 
+[#reference_operator_compare_equal_optional_none]
+
+[: `bool operator == ( optional<T> const& x, none_t ) noexcept;`]
+
+* [*Returns:] `!x`.
+* [*Notes:] `T` need not meet requirements of `EqualityComparable`.
+
+
+__SPACE__
+
+[#reference_operator_compare_not_equal_optional_none]
+
+[: `bool operator != ( optional<T> const& x, none_t ) noexcept;`]
+
+* [*Returns: ] `!( x == y );`
+
+
 __SPACE__
 
 [#reference_swap_optional_optional]

doc/special_cases.qbk

@@ -369,8 +369,8 @@ since it is a no-op.
 
 [section Type requirements]
 
-In general, `T` must be __COPY_CONSTRUCTIBLE__ and have a no-throw destructor.
+In general, `T` must be `MoveConstructible` and have a no-throw destructor.
-The copy-constructible requirement is not needed if [*InPlaceFactories] are used.
+The `MoveConstructible` requirement is not needed if [*InPlaceFactories] are used.
 
 `T` [_is not] required to be __SGI_DEFAULT_CONSTRUCTIBLE__.
 

include/boost/optional/optional.hpp

@@ -1143,8 +1143,8 @@ bool operator >= ( T const& x, optional<T> const& y )
 
 template<class T>
 inline
-bool operator == ( optional<T> const& x, none_t )
+bool operator == ( optional<T> const& x, none_t ) BOOST_NOEXCEPT
-{ return equal_pointees(x, optional<T>() ); }
+{ return !x; }
 
 template<class T>
 inline
@@ -1153,8 +1153,8 @@ bool operator < ( optional<T> const& x, none_t )
 
 template<class T>
 inline
-bool operator != ( optional<T> const& x, none_t y )
+bool operator != ( optional<T> const& x, none_t ) BOOST_NOEXCEPT
-{ return !( x == y ) ; }
+{ return bool(x); }
 
 template<class T>
 inline
@@ -1177,8 +1177,8 @@ bool operator >= ( optional<T> const& x, none_t y )
 
 template<class T>
 inline
-bool operator == ( none_t , optional<T> const& y )
+bool operator == ( none_t , optional<T> const& y ) BOOST_NOEXCEPT
-{ return equal_pointees(optional<T>() ,y); }
+{ return !y; }
 
 template<class T>
 inline
@@ -1187,8 +1187,8 @@ bool operator < ( none_t , optional<T> const& y )
 
 template<class T>
 inline
-bool operator != ( none_t x, optional<T> const& y )
+bool operator != ( none_t, optional<T> const& y ) BOOST_NOEXCEPT
-{ return !( x == y ) ; }
+{ return bool(y); }
 
 template<class T>
 inline

test/Jamfile.v2

@@ -22,6 +22,7 @@ import testing ;
     [ run optional_test_inplace.cpp ]
     [ run optional_test_io.cpp ]
     [ run optional_test_move.cpp ]
+    [ run optional_test_equals_none.cpp ]
     [ compile-fail optional_test_fail1.cpp ]
     [ compile-fail optional_test_fail3a.cpp ]
     [ compile-fail optional_test_fail3b.cpp ]

test/optional_test_equals_none.cpp

@@ -0,0 +1,68 @@
+// 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
+//
+// Revisions:
+//
+#include<iostream>
+#include<stdexcept>
+#include<string>
+
+#define BOOST_ENABLE_ASSERT_HANDLER
+
+#include "boost/bind/apply.hpp" // Included just to test proper interaction with boost::apply<> as reported by Daniel Wallin
+#include "boost/mpl/bool.hpp"
+#include "boost/mpl/bool_fwd.hpp"  // For mpl::true_ and mpl::false_
+
+#include "boost/optional/optional.hpp"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#include "boost/none.hpp"
+
+#include "boost/test/minimal.hpp"
+
+#include "optional_test_common.cpp"
+
+struct SemiRegular // no operator==
+{ 
+private: void operator==(SemiRegular const&) const {}
+private: void operator!=(SemiRegular const&) const {}
+};
+
+void test_equal_to_none_of_noncomparable_T()
+{
+    optional<SemiRegular> i = SemiRegular();
+    optional<SemiRegular> o;
+    
+    BOOST_CHECK(i != boost::none);
+    BOOST_CHECK(boost::none != i);
+    BOOST_CHECK(o == boost::none);
+    BOOST_CHECK(boost::none == o);
+}
+
+int test_main( int, char* [] )
+{
+  try
+  {
+    test_equal_to_none_of_noncomparable_T();
+
+  }
+  catch ( ... )
+  {
+    BOOST_ERROR("Unexpected Exception caught!");
+  }
+
+  return 0;
+}
+
+