Added function value_or()

doc/html/boost_optional/detailed_semantics.html

@@ -1235,6 +1235,30 @@
   <span class="identifier">asert</span> <span class="special">(</span> <span class="keyword">true</span> <span class="special">);</span>
 <span class="special">}</span>
 </pre>
+          <span class="inlinemediaobject"><img src="../images/space.png" alt="space"></span>
+        </li>
+</ul></div>
+<a name="reference_optional_value_or"></a><div class="blockquote"><blockquote class="blockquote"><p>
+        <code class="computeroutput"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span> <span class="identifier">T</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value_or</span><span class="special">(</span><span class="identifier">U</span> <span class="special">&amp;&amp;</span>
+        <span class="identifier">v</span><span class="special">)</span> <span class="keyword">const</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>
+          is CopyConstructible.
+        </li>
+<li class="listitem">
+          <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="keyword">bool</span><span class="special">(*</span><span class="keyword">this</span><span class="special">)</span>
+          <span class="special">?</span> <span class="special">**</span><span class="keyword">this</span> <span class="special">:</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;(</span><span class="identifier">v</span><span class="special">))</span></code>.
+        </li>
+<li class="listitem">
+          <span class="bold"><strong>Throws:</strong></span> Any exception thrown by the selected
+          constructor of <code class="computeroutput"><span class="identifier">T</span></code>.
+        </li>
+<li class="listitem">
+          <span class="bold"><strong>Notes:</strong></span> On compilers without rvalue reference
+          support the type of <code class="computeroutput"><span class="identifier">v</span></code> becomes
+          <code class="computeroutput"><span class="identifier">U</span> <span class="keyword">const</span><span class="special">&amp;</span></code>.
         </li>
 </ul></div>
 <p>
@@ -1264,6 +1288,9 @@
         <span class="identifier">o</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="keyword">default</span> <span class="special">)</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>Deprecated:</strong></span> Use <code class="computeroutput"><span class="identifier">value_or</span><span class="special">()</span></code> instead.
+        </li>
 <li class="listitem">
           <span class="bold"><strong>Returns:</strong></span> A reference to the contained
           value, if any, or <code class="computeroutput"><span class="keyword">default</span></code>.

doc/html/boost_optional/synopsis.html

@@ -81,9 +81,6 @@
     <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">get</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_get"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
     <span class="identifier">T</span><span class="special">&amp;</span>       <span class="identifier">get</span><span class="special">()</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_get"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
 
-    <span class="comment">// [new in 1.34]</span>
-    <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">get_value_or</span><span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="keyword">default</span> <span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_get_value_or_value"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
     <span class="identifier">T</span> <span class="keyword">const</span><span class="special">*</span> <span class="keyword">operator</span> <span class="special">-&gt;()</span> <span class="keyword">const</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_operator_arrow"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
     <span class="identifier">T</span><span class="special">*</span>       <span class="keyword">operator</span> <span class="special">-&gt;()</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_operator_arrow"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
 
@@ -93,6 +90,8 @@
     <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">value</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_value"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
     <span class="identifier">T</span><span class="special">&amp;</span>       <span class="identifier">value</span><span class="special">()</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_value"><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">U</span><span class="special">&gt;</span> <span class="identifier">T</span> <span class="identifier">value_or</span><span class="special">(</span> <span class="identifier">U</span> <span class="special">&amp;&amp;</span> <span class="identifier">v</span> <span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_value_or"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
+
     <span class="identifier">T</span> <span class="keyword">const</span><span class="special">*</span> <span class="identifier">get_ptr</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_get_ptr"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
     <span class="identifier">T</span><span class="special">*</span>       <span class="identifier">get_ptr</span><span class="special">()</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_get_ptr"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
 
@@ -111,6 +110,8 @@
     <span class="comment">// (deprecated)</span>
     <span class="keyword">bool</span> <span class="identifier">is_initialized</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_is_initialized"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
 
+    <span class="comment">// (deprecated)</span>
+    <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">get_value_or</span><span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="keyword">default</span> <span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_get_value_or_value"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
 <span class="special">};</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="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">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_equal_optional_optional"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
@@ -129,13 +130,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">!=</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>
 
-<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="keyword">bool</span> <span class="identifier">condition</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_bool_value"><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">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">get_optional_value_or</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">opt</span><span class="special">,</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="keyword">default</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_get_value_or_value"><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="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">get</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">opt</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_get"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>

doc/html/index.html

@@ -92,7 +92,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: May 22, 2014 at 21:28:38 GMT</small></p></td>
+<td align="left"><p><small>Last revised: May 23, 2014 at 14:35:08 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>

doc/reference.qbk

@@ -66,9 +66,6 @@
         T const& get() const ; ``[link reference_optional_get __GO_TO__]``
         T&       get() ; ``[link reference_optional_get __GO_TO__]``
 
-        // [new in 1.34]
-        T const& get_value_or( T const& default ) const ; ``[link reference_optional_get_value_or_value __GO_TO__]`` 
-
         T const* operator ->() const ; ``[link reference_optional_operator_arrow __GO_TO__]``
         T*       operator ->() ; ``[link reference_optional_operator_arrow __GO_TO__]``
 
@@ -77,6 +74,8 @@
         
         T const& value() const ; ``[link reference_optional_value __GO_TO__]``
         T&       value() ; ``[link reference_optional_value __GO_TO__]``
+        
+        template<class U> T value_or( U && v ) const ; ``[link reference_optional_value_or __GO_TO__]``
 
         T const* get_ptr() const ; ``[link reference_optional_get_ptr __GO_TO__]``
         T*       get_ptr() ; ``[link reference_optional_get_ptr __GO_TO__]``
@@ -96,6 +95,8 @@
         // (deprecated)
         bool is_initialized() const ; ``[link reference_optional_is_initialized __GO_TO__]``
 
+        // (deprecated)
+        T const& get_value_or( T const& default ) const ; ``[link reference_optional_get_value_or_value __GO_TO__]`` 
     };
 
     template<class T> inline bool operator == ( optional<T> const& x, optional<T> const& y ) ; ``[link reference_operator_compare_equal_optional_optional __GO_TO__]``
@@ -114,13 +115,10 @@
 
     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__]``
 
-    // [new in 1.34]
     template<class T> inline optional<T> make_optional ( bool condition, T const& v ) ; ``[link reference_make_optional_bool_value __GO_TO__]``
 
-    // [new in 1.34]
     template<class T> inline T const& get_optional_value_or ( optional<T> const& opt, T const& default ) ; ``[link reference_optional_get_value_or_value __GO_TO__]`` 
 
     template<class T> inline T const& get ( optional<T> const& opt ) ; ``[link reference_optional_get __GO_TO__]``
@@ -828,6 +826,17 @@ catch(bad_optional_access&) {
   asert ( true );
 }
 ``
+__SPACE__
+
+
+[#reference_optional_value_or]
+
+[: `template<class U> T optional<T>::value_or(U && v) const ;`]
+
+* [*Requires:] `T` is CopyConstructible.
+* [*Returns:] `bool(*this) ? **this : static_cast<T>(forward<U>(v))`.
+* [*Throws:] Any exception thrown by the selected constructor of `T`.
+* [*Notes:] On compilers without rvalue reference support the type of `v` becomes `U const&`.
 
 __SPACE__
 
@@ -839,6 +848,7 @@ __SPACE__
 [: `inline T const& get_optional_value_or ( optional<T` ['(not a ref)]`> const& o, T const& default ) ;`]
 [: `inline T&       get_optional_value_or ( optional<T` ['(not a ref)]`>&       o, T&       default ) ;`]
 
+* [*Deprecated:] Use `value_or()` instead.
 * [*Returns:] A reference to the contained value, if any, or `default`.
 * [*Throws:] Nothing.
 * [*Example:]

include/boost/optional/optional.hpp

@@ -23,7 +23,7 @@
 
 #include <boost/config.hpp>
 #include <boost/assert.hpp>
-#include <boost/bad_optional_access.hpp>
+#include <boost/optional/bad_optional_access.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/throw_exception.hpp>
 #include <boost/type.hpp>
@@ -441,11 +441,11 @@ class optional_base : public optional_tag
 
   public :
 
-    // Destroys the current value, if any, leaving this UNINITIALIZED
+    // **DEPPRECATED** Destroys the current value, if any, leaving this UNINITIALIZED
     // No-throw (assuming T::~T() doesn't)
     void reset() BOOST_NOEXCEPT { destroy(); }
 
-    // Replaces the current value -if any- with 'val'
+    // **DEPPRECATED** Replaces the current value -if any- with 'val'
     void reset ( argument_type val ) { assign(val); }
 
     // Returns a pointer to the value if this is initialized, otherwise,
@@ -954,6 +954,14 @@ class optional : public optional_detail::optional_base<T>
           throw_exception(bad_optional_access("Attempted to access the value of an uninitialized optional object."));
       }
 
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    template <class U>
+    value_type value_or ( U&& v ) const { return this->is_initialized() ? get() : static_cast<value_type>(boost::forward<U>(v)); }
+#else
+    template <class U>
+    value_type value_or ( U const& v ) const { return this->is_initialized() ? get() : static_cast<value_type>(v); }
+#endif
+      
     bool operator!() const BOOST_NOEXCEPT { return !this->is_initialized() ; }
     
     BOOST_EXPLICIT_OPERATOR_BOOL()

test/optional_test_value_access.cpp

@@ -40,6 +40,20 @@ struct IntWrapper
   bool operator==(IntWrapper const& rhs) const { return _i == rhs._i; }
 };
 
+template <typename T>
+void test_function_value_or_for()
+{
+  optional<T> oM0;
+  const optional<T> oC0;
+  optional<T> oM1(1);
+  const optional<T> oC2(2);
+  
+  BOOST_CHECK(oM0.value_or(5) == 5);
+  BOOST_CHECK(oC0.value_or(5) == 5);
+  BOOST_CHECK(oM1.value_or(5) == 1);
+  BOOST_CHECK(oC2.value_or(5) == 2);
+}
+
 template <typename T>
 void test_function_value_for()
 {
@@ -85,16 +99,41 @@ void test_function_value_for()
 void test_function_value()
 {
     test_function_value_for<int>();
-    test_function_value_for<float>();
+    test_function_value_for<double>();
     test_function_value_for<IntWrapper>();
 }
 
+struct FatToIntConverter
+{
+  static int conversions;
+  int _val;
+  FatToIntConverter(int val) : _val(val) {}
+  operator int() { conversions += 1; return _val; }
+};
+
+int FatToIntConverter::conversions = 0;
+
+void test_function_value_or()
+{
+    test_function_value_or_for<int>();
+    test_function_value_or_for<double>();
+    test_function_value_or_for<IntWrapper>();
+    
+    optional<int> oi(1);
+    BOOST_CHECK(oi.value_or(FatToIntConverter(2)) == 1);
+    BOOST_CHECK(FatToIntConverter::conversions == 0);
+    
+    oi = boost::none;
+    BOOST_CHECK(oi.value_or(FatToIntConverter(2)) == 2);
+    BOOST_CHECK(FatToIntConverter::conversions == 1);
+}
+
 int test_main( int, char* [] )
 {
   try
   {
     test_function_value();
-
+    test_function_value_or();
   }
   catch ( ... )
   {