docs: 1.60 relnotes

When we detect that compiler supports rvalue references, we implement swap() in term of moves (as intuition suggests).
Otherwise we fall back to old tricks with default constructor+swap

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 Andrzej Krzemieński]
+    [copyright 2014-2015 Andrzej Krzemieński]
     [category miscellaneous]
     [id optional]
     [dirname optional]
@@ -54,7 +54,7 @@ Distributed under the Boost Software License, Version 1.0.
 Class template `optional` is a wrapper for representing 'optional' (or 'nullable') objects who may not (yet) contain a valid value. Optional objects offer full value semantics; they are good for passing by value and usage inside STL containers. This is a header-only library.
 
 [heading Problem]
-Suppose we want to read a parameter form a config file which represents some integral value, let's call it `"MaxValue"`. It is possible that this parameter is not specified; such situation is no error. It is valid to not specify the parameter and in that case the program is supposed to behave slightly different. Also suppose that any possible value of type `int` is a valid value for `"MaxValue"`, so we cannot jut use `-1` to represent the absence of the parameter in the config file.
+Suppose we want to read a parameter form a config file which represents some integral value, let's call it `"MaxValue"`. It is possible that this parameter is not specified; such situation is no error. It is valid to not specify the parameter and in that case the program is supposed to behave slightly differently. Also, suppose that any possible value of type `int` is a valid value for `"MaxValue"`, so we cannot just use `-1` to represent the absence of the parameter in the config file.
 
 [heading Solution]
 
@@ -80,16 +80,27 @@ This is how you solve it with `boost::optional`:
 [include 11_development.qbk]
 [include 12_when_to_use.qbk]
 [include 13_relational_operators.qbk]
-[include 14_optional_references.qbk]
-[include 15_in_place_factories.qbk]
-[include 16_optional_bool.qbk]
-[include 17_exception_safety.qbk]
-[include 18_type_requirements.qbk]
+[include 14_io.qbk]
+[include 15_optional_references.qbk]
+[include 16_in_place_factories.qbk]
+[include 17_optional_bool.qbk]
+[include 18_exception_safety.qbk]
+[include 19_type_requirements.qbk]
+[include 1A_on_performance.qbk]
 [endsect]
-[section Reference]
-[include 20_reference.qbk]
+[section:reference Reference]
+[include 21_ref_none.qbk]
+[include 22_ref_bad_optional_access.qbk]
+[include 23_ref_optional_io.qbk]
+[include 24_ref_optional_fwd.qbk]
+[section Header <boost/optional/optional.hpp>]
+[include 27_ref_optional_synopsis.qbk]
+[include 28_ref_optional_semantics.qbk]
+[endsect]
+[include 29_ref_optional_convenience.qbk]
 [endsect]
 [include 90_dependencies.qbk]
-[include 91_acknowledgments.qbk]
+[include 91_relnotes.qbk]
+[include 92_acknowledgments.qbk]
 
 

doc/01_quick_start.qbk

@@ -14,7 +14,7 @@
 
 [section Optional return values]
 
-Let's write and use a converter function that converts an a `std::string` to an `int`. It is possible that for a given string (e.g. `"cat"`) there exist no value of type `int` capable of representing the conversion result. We do not consider such situation an error. We expect that the converter can be used only to check if the conversion is possible. A natural signature for this function can be:
+Let's write and use a converter function that converts a `std::string` to an `int`. It is possible that for a given string (e.g. `"cat"`) there exists no value of type `int` capable of representing the conversion result. We do not consider such situation an error. We expect that the converter can be used only to check if the conversion is possible. A natural signature for this function can be:
 
     #include <boost/optional.hpp>
     boost::optional<int> convert(const std::string& text);
@@ -91,7 +91,7 @@ We could write function `convert` in a slightly different manner, so that it has
       return ans;
     }
 
-The default constructor of `optional` creates an unitialized optional object. Unlike with `int`s you cannot have an `optional<int>` in an indeterminate state. Its state is always well defined. Instruction `ans = i` initializes the optional object. It uses the assignment from `int`. In general, for `optional<T>`, when an assignment from `T` is invoked, it can do two things. If the optional object is not initialized our case here), it initializes it with `T`'s copy constructor. If the optional object is already initialized, it assigns the new value to it using `T`'s copy assignment.      
+The default constructor of `optional` creates an unitialized optional object. Unlike with `int`s you cannot have an `optional<int>` in an indeterminate state. Its state is always well defined. Instruction `ans = i` initializes the optional object. It uses the 'mixed' assignment from `int`. In general, for `optional<T>`, when an assignment from `T` is invoked, it can do two things. If the optional object is not initialized (our case here), it initializes the contained value using `T`'s copy constructor. If the optional object is already initialized, it assigns the new value to it using `T`'s copy assignment.      
 [endsect]
 
 [section Optional data members]

doc/11_development.qbk

@@ -171,7 +171,7 @@ Also, the presence of the possibly uninitialized state requires additional
 operations not provided by `T` itself which are supported by a special interface.
 
 [heading Lexically-hinted Value Access in the presence of possibly
-untitialized optional objects: The operators * and ->]
+uninitialized optional objects: The operators * and ->]
 
 A relevant feature of a pointer is that it can have a [*null pointer value].
 This is a ['special] value which is used to indicate that the pointer is not

doc/13_relational_operators.qbk

@@ -1,7 +1,7 @@
 
 [section Relational operators]
 
-Type `optional<T>` is __SGI_EQUALITY_COMPARABLE__ whenever `T` is __SGI_EQUALITY_COMPARABLE__. Two optional objects containing a value compare in the same as their contained values. The uninitialized state of `optional<T>` is treated as a distinct value, equal to itself, and unequal to any value of type `T`:
+Type `optional<T>` is __SGI_EQUALITY_COMPARABLE__ whenever `T` is __SGI_EQUALITY_COMPARABLE__. Two optional objects containing a value compare in the same way as their contained values. The uninitialized state of `optional<T>` is treated as a distinct value, equal to itself, and unequal to any value of type `T`:
 
     boost::optional<int> oN = boost::none;
     boost::optional<int> o0 = 0;
@@ -9,7 +9,7 @@ Type `optional<T>` is __SGI_EQUALITY_COMPARABLE__ whenever `T` is __SGI_EQUALITY
     
     assert(oN != o0);
     assert(o1 != oN);
-    assert(o2 != o1);
+    assert(o0 != o1);
     assert(oN == oN);
     assert(o0 == o0);
     
@@ -17,7 +17,7 @@ The converting constructor from `T` as well as from `boost::none` implies the ex
 
     assert(oN != 0);
     assert(o1 != boost::none);
-    assert(o2 != 1);
+    assert(o0 != 1);
     assert(oN == boost::none);
     assert(o0 == 0);
     

doc/14_io.qbk

@@ -0,0 +1,37 @@
+
+[section IO operators]
+
+It is possible to use `optional<T>` with IO streams, provided that `T` can be used with streams. IOStream operators are defined in a separate header.
+
+``
+#include <iostream>
+#include <boost/optional/optional_io.hpp>
+
+int main()
+{
+  boost::optional<int> o1 = 1, oN = boost::none;
+  std::cout << o1;
+  std::cin >> oN;
+}
+``
+
+The current implementation does not guarantee any particular output. What it guarantees is that if streaming out and then back in `T` gives the same value, then streaming out and then back in `optional<T>` will also give back the same result:
+
+``
+#include <cassert>
+#include <sstream>
+#include <boost/optional/optional_io.hpp>
+
+int main()
+{
+  boost::optional<int> o1 = 1, oN = boost::none;
+  boost::optional<int> x1, x2;
+  std::stringstream s;
+  s << o1 << oN;
+  s >> x1 >> x2;
+  assert (o1 == x1);
+  assert (oN == x2);
+}
+``
+
+[endsect]

doc/1A_on_performance.qbk

@@ -0,0 +1,131 @@
+
+[section Performance considerations]
+
+Technical details aside, the memory layout of `optional<T>` is more-less this:
+
+  template <typename T>
+  class optional
+  {
+    bool _initialized;
+    std::aligned_storage_t<sizeof(t), alignof(T)> _storage;
+  };
+  
+But for the purpose of this analysis, considering memory layouts, we can think of it as:
+
+  template <typename T>
+  class optional
+  {
+    bool _initialized;
+    T _storage;
+  };
+  
+Given type `optional<int>`, and assuming that `sizeof(int) == 4`, we will get `sizeof(optional<int>) == 8`. This is so because of the alignment rules, for our two members we get the following alignment:
+
+[$images/opt_align1.png]
+
+This means you can fit twice as many `int`s as `optional<int>`s into the same space of memory. Therefore, if the size of the objects is critical for your application (e.g., because you want to utilize your CPU cache in order to gain performance) and you have determined you are willing to trade the code clarity, it is recommended that you simply go with type `int` and use some 'magic value' to represent ['not-an-int].
+
+Even if you cannot spare any value of `int` to represent ['not-an-int] (e.g., because every value is useful, or you do want to signal ['not-an-int] explicitly), at least for `Trivial` types you should consider storing the value and the `bool` flag representing the ['null-state] separately. Consider the following class:
+
+  struct Record
+  {
+    optional<int> _min;
+    optional<int> _max;
+  };
+  
+Its memory layout can be depicted as follows:
+
+[$images/opt_align2.png]
+
+This is exactly the same as if we had the following members:
+
+  struct Record
+  {
+    bool _has_min;
+    int  _min;
+    bool _has_max;
+    int  _max;
+  };
+
+But when they are stored separately, we at least have an option to reorder them like this:
+
+  struct Record
+  {
+    bool _has_min;  
+    bool _has_max;
+    int  _min;
+    int  _max;
+  };
+
+Which gives us the following layout (and smaller total size):
+
+[$images/opt_align3.png]
+
+Sometimes it requires detailed consideration what data we make optional. In our case above, if we determine that both minimum and maximum value can be provided or not provided together, but one is never provided without the other, we can make only one optional memebr:
+
+  struct Limits
+  {
+    int  _min;
+    int  _max;
+  };
+  
+  struct Record
+  {
+    optional<Limits> _limits;  
+  };
+  
+This would give us the following layout:
+
+[$images/opt_align4.png]
+
+[heading Optional function parameters]
+
+Having function parameters of type `const optional<T>&` may incur certain unexpected run-time cost connected to copy construction of `T`. Consider the following code. 
+
+  void fun(const optional<Big>& v)
+  {
+    if (v) doSomethingWith(*v);
+    else   doSomethingElse();
+  }
+
+  int main()
+  {
+    optional<Big> ov;
+    Big v;
+    fun(none);
+    fun(ov); // no copy
+    fun(v);  // copy constructor of Big
+  }
+
+No copy elision or move semantics can save us from copying type `Big` here. Not that we need any copy, but this is how `optional` works. In order to avoid copying in this case, one could provide second overload of `fun`:
+
+  void fun(const Big& v)
+  {
+    doSomethingWith(v);
+  }
+
+  int main()
+  {
+    optional<Big> ov;
+    Big v;
+    fun(ov); // no copy
+    fun(v);  // no copy: second overload selected
+  }
+
+Alternatively, you could consider using an optional reference instead:
+
+  void fun(optional<const Big&> v) // note where the reference is
+  {
+    if (v) doSomethingWith(*v);
+    else   doSomethingElse();
+  }
+
+  int main()
+  {
+    optional<Big> ov;
+    Big v;
+    fun(none);
+    fun(ov); // doesn't compile
+    fun(v);  // no copy
+  }
+[endsect]

doc/21_ref_none.qbk

@@ -0,0 +1,31 @@
+[/
+    Boost.Optional
+
+    Copyright (c) 2003-2007 Fernando Luis Cacciola Carballal
+    Copyright (c) 2015 Andrzej Krzemienski
+
+    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)
+]
+
+[section Header <boost/none.hpp>]
+
+[section Synopsis]
+```
+namespace boost {
+
+class none_t {/* see below */};
+
+const none_t none (/* see below */); 
+    
+} // namespace boost
+```
+
+Class `none_t` is meant to serve as a tag for selecting appropriate overloads of from `optional`'s interface. It is an empty, trivially copyable class with disabled default constructor.
+
+Constant `none` is used to indicate an optional object that does not contain a value in initialization, assignment and relational operations of `optional`.
+
+[endsect]
+
+[endsect]

doc/22_ref_bad_optional_access.qbk

@@ -0,0 +1,40 @@
+[/
+    Boost.Optional
+
+    Copyright (c) 2003-2007 Fernando Luis Cacciola Carballal
+    Copyright (c) 2015 Andrzej Krzemienski
+
+    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)
+]
+
+[section Header <boost/optional/bad_optional_access.hpp>]
+
+[section Synopsis]
+```
+namespace boost {
+
+class bad_optional_access : public std::logic_error
+{
+public:
+    bad_optional_access(); ``[link reference_bad_optional_access_constructor __GO_TO__]``
+};
+    
+} // namespace boost
+```
+[endsect]
+
+[section Detailed semantics]
+
+__SPACE__
+
+[#reference_bad_optional_access_constructor]
+
+`bad_optional_access();`
+
+* [*Effect:] Constructs an object of class `bad_optional_access`.
+* [*Postconditions:] `what()` returns an implementation-defined NTBS.
+
+[endsect]
+[endsect]

doc/23_ref_optional_io.qbk

@@ -0,0 +1,74 @@
+[/
+    Boost.Optional
+
+    Copyright (c) 2003-2007 Fernando Luis Cacciola Carballal
+    Copyright (c) 2015 Andrzej Krzemienski
+
+    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)
+]
+
+[section:io_header Header <boost/optional/optional_io.hpp>]
+
+[section:io_synop Synopsis]
+```
+#include <istream>
+#include <ostream>
+#include <boost/optional/optional.hpp>
+
+namespace boost {
+
+template <class CharType, class CharTrait, class T>
+  std::basic_ostream<CharType, CharTrait>&
+  operator<<(std::basic_ostream<CharType, CharTrait>& out, optional<T> const& v); ``[link reference_operator_ostream __GO_TO__]``
+
+  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
+```
+
+[endsect]
+
+[section:io_semantics Detailed semantics]
+
+
+[#reference_operator_ostream]
+
+
+`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);`
+
+* [*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`.
+
+__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);`
+
+* [*Effect:] Outputs an implementation-defined string.
+* [*Returns:] `out`.
+
+__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);`
+
+* [*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. 
+* [*Returns:] `out`.
+
+[endsect]
+[endsect]

doc/24_ref_optional_fwd.qbk

@@ -0,0 +1,32 @@
+[/
+    Boost.Optional
+
+    Copyright (c) 2003-2007 Fernando Luis Cacciola Carballal
+    Copyright (c) 2015 Andrzej Krzemienski
+
+    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)
+]
+
+[section Header <boost/optional/optional_fwd.hpp>]
+
+[section Synopsis]
+```
+namespace boost {
+
+template <class T> class optional ;
+
+template <class T> void swap ( optional<T>& , optional<T>& );
+
+template <class T> struct optional_swap_should_use_default_constructor ;
+  
+} // namespace boost
+```
+
+This header only contains declarations.
+
+[endsect]
+
+
+[endsect]

doc/27_ref_optional_synopsis.qbk

@@ -0,0 +1,151 @@
+[/
+    Boost.Optional
+
+    Copyright (c) 2003-2007 Fernando Luis Cacciola Carballal
+
+    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)
+]
+
+
+[#ref_header_optional_optional_hpp][section:header_optional_optional Synopsis]
+
+    ```// In Header: <`[@boost:/boost/optional/optional.hpp boost/optional/optional.hpp]'''<phrase role="comment">&gt;</phrase>'''``
+
+    namespace boost {
+
+    template <class T>
+    class optional
+    {
+    public :
+
+        typedef T value_type;
+        
+        // (If T is of reference type, the parameters and results by reference are by value)
+
+        optional () noexcept ; ``[link reference_optional_constructor __GO_TO__]``
+
+        optional ( none_t ) noexcept ; ``[link reference_optional_constructor_none_t __GO_TO__]``
+
+        optional ( T const& v ) ; ``[link reference_optional_constructor_value __GO_TO__]``
+        
+        optional ( T&& v ) ; ``[link reference_optional_constructor_move_value __GO_TO__]``
+
+        // [new in 1.34]
+        optional ( bool condition, T const& v ) ; ``[link reference_optional_constructor_bool_value __GO_TO__]`` 
+
+        optional ( optional const& rhs ) ; ``[link reference_optional_constructor_optional __GO_TO__]``
+        
+        optional ( optional&& rhs ) noexcept(``['see below]``) ; ``[link reference_optional_move_constructor_optional __GO_TO__]``
+
+        template<class U> explicit optional ( optional<U> const& rhs ) ; ``[link reference_optional_constructor_other_optional __GO_TO__]``
+        
+        template<class U> explicit optional ( optional<U>&& rhs ) ; ``[link reference_optional_move_constructor_other_optional __GO_TO__]``
+
+        template<class InPlaceFactory> explicit optional ( InPlaceFactory const& f ) ; ``[link reference_optional_constructor_factory __GO_TO__]``
+
+        template<class TypedInPlaceFactory> explicit optional ( TypedInPlaceFactory const& f ) ; ``[link reference_optional_constructor_factory __GO_TO__]``
+
+        optional& operator = ( none_t ) noexcept ; ``[link reference_optional_operator_equal_none_t __GO_TO__]``
+
+        optional& operator = ( T const& v ) ; ``[link reference_optional_operator_equal_value __GO_TO__]``
+        
+        optional& operator = ( T&& v ) ; ``[link reference_optional_operator_move_equal_value __GO_TO__]``
+
+        optional& operator = ( optional const& rhs ) ; ``[link reference_optional_operator_equal_optional __GO_TO__]``
+        
+        optional& operator = ( optional&& rhs ) noexcept(``['see below]``) ; ``[link reference_optional_operator_move_equal_optional __GO_TO__]``
+
+        template<class U> optional& operator = ( optional<U> const& rhs ) ; ``[link reference_optional_operator_equal_other_optional __GO_TO__]``
+        
+        template<class U> optional& operator = ( optional<U>&& rhs ) ; ``[link reference_optional_operator_move_equal_other_optional __GO_TO__]``
+        
+        template<class... Args> void emplace ( Args...&& args ) ; ``[link reference_optional_emplace __GO_TO__]``
+
+        template<class InPlaceFactory> optional& operator = ( InPlaceFactory const& f ) ; ``[link reference_optional_operator_equal_factory __GO_TO__]``
+
+        template<class TypedInPlaceFactory> optional& operator = ( TypedInPlaceFactory const& f ) ; ``[link reference_optional_operator_equal_factory __GO_TO__]``
+
+        T const& get() const ; ``[link reference_optional_get __GO_TO__]``
+        T&       get() ; ``[link reference_optional_get __GO_TO__]``
+
+        T const* operator ->() const ; ``[link reference_optional_operator_arrow __GO_TO__]``
+        T*       operator ->() ; ``[link reference_optional_operator_arrow __GO_TO__]``
+
+        T const& operator *() const& ; ``[link reference_optional_operator_asterisk __GO_TO__]``
+        T&       operator *() & ; ``[link reference_optional_operator_asterisk __GO_TO__]``
+        T&&      operator *() && ; ``[link reference_optional_operator_asterisk_move __GO_TO__]``
+        
+        T const& value() const& ; ``[link reference_optional_value __GO_TO__]``
+        T&       value() & ; ``[link reference_optional_value __GO_TO__]``
+        T&&      value() && ; ``[link reference_optional_value_move __GO_TO__]``
+        
+        template<class U> T value_or( U && v ) const& ; ``[link reference_optional_value_or __GO_TO__]``
+        template<class U> T value_or( U && v ) && ; ``[link reference_optional_value_or_move __GO_TO__]``
+        
+        template<class F> T value_or_eval( F f ) const& ; ``[link reference_optional_value_or_call __GO_TO__]``
+        template<class F> T value_or_eval( F f ) && ; ``[link reference_optional_value_or_call_move __GO_TO__]``
+
+        T const* get_ptr() const ; ``[link reference_optional_get_ptr __GO_TO__]``
+        T*       get_ptr() ; ``[link reference_optional_get_ptr __GO_TO__]``
+
+        explicit operator bool() const noexcept ; ``[link reference_optional_operator_bool __GO_TO__]``
+
+        bool operator!() const noexcept ; ``[link reference_optional_operator_not __GO_TO__]``
+
+        // deprecated methods
+
+        // (deprecated)
+        void reset() noexcept ; ``[link reference_optional_reset __GO_TO__]``
+
+        // (deprecated)
+        void reset ( T const& ) ; ``[link reference_optional_reset_value __GO_TO__]``
+
+        // (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__]``
+
+    template<class T> inline bool operator != ( optional<T> const& x, optional<T> const& y ) ; ``[link reference_operator_compare_not_equal_optional_optional __GO_TO__]``
+
+    template<class T> inline bool operator <  ( optional<T> const& x, optional<T> const& y ) ; ``[link reference_operator_compare_less_optional_optional __GO_TO__]``
+
+    template<class T> inline bool operator >  ( optional<T> const& x, optional<T> const& y ) ; ``[link reference_operator_compare_greater_optional_optional __GO_TO__]``
+
+    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__]``
+
+    template<class T> inline optional<T> make_optional ( T const& v ) ; ``[link reference_make_optional_value __GO_TO__]``
+
+    template<class T> inline optional<T> make_optional ( bool condition, T const& v ) ; ``[link reference_make_optional_bool_value __GO_TO__]``
+
+    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__]``
+
+    template<class T> inline T& get ( optional<T> & opt ) ; ``[link reference_optional_get __GO_TO__]``
+
+    template<class T> inline T const* get ( optional<T> const* opt ) ; ``[link reference_optional_get __GO_TO__]``
+
+    template<class T> inline T* get ( optional<T>* opt ) ; ``[link reference_optional_get __GO_TO__]``
+
+    template<class T> inline T const* get_pointer ( optional<T> const& opt ) ; ``[link reference_optional_get_ptr __GO_TO__]``
+
+    template<class T> inline T* get_pointer ( optional<T> & opt ) ; ``[link reference_optional_get_ptr __GO_TO__]``
+
+    template<class T> inline void swap( optional<T>& x, optional<T>& y ) ; ``[link reference_swap_optional_optional __GO_TO__]``
+
+    } // namespace boost
+
+
+[endsect]

doc/28_ref_optional_semantics.qbk

@@ -9,145 +9,6 @@
 ]
 
 
-[section Synopsis]
-
-    ```// In Header: <`[@boost:/boost/optional/optional.hpp boost/optional/optional.hpp]'''<phrase role="comment">&gt;</phrase>'''``
-
-    namespace boost {
-
-    template<class T>
-    class optional
-    {
-        public :
-
-        // (If T is of reference type, the parameters and results by reference are by value)
-
-        optional () noexcept ; ``[link reference_optional_constructor __GO_TO__]``
-
-        optional ( none_t ) noexcept ; ``[link reference_optional_constructor_none_t __GO_TO__]``
-
-        optional ( T const& v ) ; ``[link reference_optional_constructor_value __GO_TO__]``
-        
-        optional ( T&& v ) ; ``[link reference_optional_constructor_move_value __GO_TO__]``
-
-        // [new in 1.34]
-        optional ( bool condition, T const& v ) ; ``[link reference_optional_constructor_bool_value __GO_TO__]`` 
-
-        optional ( optional const& rhs ) ; ``[link reference_optional_constructor_optional __GO_TO__]``
-        
-        optional ( optional&& rhs ) noexcept(``['see below]``) ; ``[link reference_optional_move_constructor_optional __GO_TO__]``
-
-        template<class U> explicit optional ( optional<U> const& rhs ) ; ``[link reference_optional_constructor_other_optional __GO_TO__]``
-        
-        template<class U> explicit optional ( optional<U>&& rhs ) ; ``[link reference_optional_move_constructor_other_optional __GO_TO__]``
-
-        template<class InPlaceFactory> explicit optional ( InPlaceFactory const& f ) ; ``[link reference_optional_constructor_factory __GO_TO__]``
-
-        template<class TypedInPlaceFactory> explicit optional ( TypedInPlaceFactory const& f ) ; ``[link reference_optional_constructor_factory __GO_TO__]``
-
-        optional& operator = ( none_t ) noexcept ; ``[link reference_optional_operator_equal_none_t __GO_TO__]``
-
-        optional& operator = ( T const& v ) ; ``[link reference_optional_operator_equal_value __GO_TO__]``
-        
-        optional& operator = ( T&& v ) ; ``[link reference_optional_operator_move_equal_value __GO_TO__]``
-
-        optional& operator = ( optional const& rhs ) ; ``[link reference_optional_operator_equal_optional __GO_TO__]``
-        
-        optional& operator = ( optional&& rhs ) noexcept(``['see below]``) ; ``[link reference_optional_operator_move_equal_optional __GO_TO__]``
-
-        template<class U> optional& operator = ( optional<U> const& rhs ) ; ``[link reference_optional_operator_equal_other_optional __GO_TO__]``
-        
-        template<class U> optional& operator = ( optional<U>&& rhs ) ; ``[link reference_optional_operator_move_equal_other_optional __GO_TO__]``
-        
-        template<class... Args> void emplace ( Args...&& args ) ; ``[link reference_optional_emplace __GO_TO__]``
-
-        template<class InPlaceFactory> optional& operator = ( InPlaceFactory const& f ) ; ``[link reference_optional_operator_equal_factory __GO_TO__]``
-
-        template<class TypedInPlaceFactory> optional& operator = ( TypedInPlaceFactory const& f ) ; ``[link reference_optional_operator_equal_factory __GO_TO__]``
-
-        T const& get() const ; ``[link reference_optional_get __GO_TO__]``
-        T&       get() ; ``[link reference_optional_get __GO_TO__]``
-
-        T const* operator ->() const ; ``[link reference_optional_operator_arrow __GO_TO__]``
-        T*       operator ->() ; ``[link reference_optional_operator_arrow __GO_TO__]``
-
-        T const& operator *() const& ; ``[link reference_optional_operator_asterisk __GO_TO__]``
-        T&       operator *() & ; ``[link reference_optional_operator_asterisk __GO_TO__]``
-        T&&      operator *() && ; ``[link reference_optional_operator_asterisk_move __GO_TO__]``
-        
-        T const& value() const& ; ``[link reference_optional_value __GO_TO__]``
-        T&       value() & ; ``[link reference_optional_value __GO_TO__]``
-        T&&      value() && ; ``[link reference_optional_value_move __GO_TO__]``
-        
-        template<class U> T value_or( U && v ) const& ; ``[link reference_optional_value_or __GO_TO__]``
-        template<class U> T value_or( U && v ) && ; ``[link reference_optional_value_or_move __GO_TO__]``
-        
-        template<class F> T value_or_eval( F f ) const& ; ``[link reference_optional_value_or_call __GO_TO__]``
-        template<class F> T value_or_eval( F f ) && ; ``[link reference_optional_value_or_call_move __GO_TO__]``
-
-        T const* get_ptr() const ; ``[link reference_optional_get_ptr __GO_TO__]``
-        T*       get_ptr() ; ``[link reference_optional_get_ptr __GO_TO__]``
-
-        explicit operator bool() const noexcept ; ``[link reference_optional_operator_bool __GO_TO__]``
-
-        bool operator!() const noexcept ; ``[link reference_optional_operator_not __GO_TO__]``
-
-        // deprecated methods
-
-        // (deprecated)
-        void reset() noexcept ; ``[link reference_optional_reset __GO_TO__]``
-
-        // (deprecated)
-        void reset ( T const& ) ; ``[link reference_optional_reset_value __GO_TO__]``
-
-        // (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__]``
-
-    template<class T> inline bool operator != ( optional<T> const& x, optional<T> const& y ) ; ``[link reference_operator_compare_not_equal_optional_optional __GO_TO__]``
-
-    template<class T> inline bool operator <  ( optional<T> const& x, optional<T> const& y ) ; ``[link reference_operator_compare_less_optional_optional __GO_TO__]``
-
-    template<class T> inline bool operator >  ( optional<T> const& x, optional<T> const& y ) ; ``[link reference_operator_compare_greater_optional_optional __GO_TO__]``
-
-    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__]``
-
-    template<class T> inline optional<T> make_optional ( T const& v ) ; ``[link reference_make_optional_value __GO_TO__]``
-
-    template<class T> inline optional<T> make_optional ( bool condition, T const& v ) ; ``[link reference_make_optional_bool_value __GO_TO__]``
-
-    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__]``
-
-    template<class T> inline T& get ( optional<T> & opt ) ; ``[link reference_optional_get __GO_TO__]``
-
-    template<class T> inline T const* get ( optional<T> const* opt ) ; ``[link reference_optional_get __GO_TO__]``
-
-    template<class T> inline T* get ( optional<T>* opt ) ; ``[link reference_optional_get __GO_TO__]``
-
-    template<class T> inline T const* get_pointer ( optional<T> const& opt ) ; ``[link reference_optional_get_ptr __GO_TO__]``
-
-    template<class T> inline T* get_pointer ( optional<T> & opt ) ; ``[link reference_optional_get_ptr __GO_TO__]``
-
-    template<class T> inline void swap( optional<T>& x, optional<T>& y ) ; ``[link reference_swap_optional_optional __GO_TO__]``
-
-    } // namespace boost
-
-
-[endsect]
-
 [section Detailed Semantics]
 
 Because `T` might be of reference type, in the sequel, those entries whose
@@ -602,10 +463,12 @@ __SPACE__
 
 * [*Requires:] `T` is __COPY_CONSTRUCTIBLE__ and `CopyAssignable`.
 * [*Effects:]
-  * If `!*this && !rhs` no effect, otherwise
-  * if `bool(*this) && !rhs`, destroys the contained value by calling `val->T::~T()`, otherwise
-  * if `!*this && bool(rhs)`, initializes the contained value as if direct-initializing an object of type `T` with `*rhs`, otherwise
-  * (if `bool(*this) && bool(rhs)`) assigns `*rhs` to the contained value.
+[table
+  [] 
+  [[][[*`*this` contains a value]][[*`*this` does not contain a value]]]
+  [[[*`rhs` contains a value]][assigns `*rhs` to the contained value][initializes the contained value as if direct-initializing an object of type `T` with `*rhs`]]
+  [[[*`rhs` does not contain a value]][destroys the contained value by calling `val->T::~T()`][no effect]]
+]
 * [*Returns:] `*this`;
 * [*Postconditions:] `bool(rhs) == bool(*this)`. 
 * [*Exception Safety:] If any exception is thrown, the initialization state of `*this` and `rhs` remains unchanged.
@@ -662,10 +525,12 @@ __SPACE__
 
 * [*Requires:] `T` is __MOVE_CONSTRUCTIBLE__ and `MoveAssignable`.
 * [*Effects:]
-  * If `!*this && !rhs` no effect, otherwise
-  * if `bool(*this) && !rhs`, destroys the contained value by calling `val->T::~T()`, otherwise
-  * if `!*this && bool(rhs)`, initializes the contained value as if direct-initializing an object of type `T` with `std::move(*rhs)`, otherwise
-  * (if `bool(*this) && bool(rhs)`) assigns `std::move(*rhs)` to the contained value.
+[table 
+  []
+  [[][[*`*this` contains a value]][[*`*this` does not contain a value]]]
+  [[[*`rhs` contains a value]][assigns `std::move(*rhs)` to the contained value][initializes the contained value as if direct-initializing an object of type `T` with `std::move(*rhs)`]]
+  [[[*`rhs` does not contain a value]][destroys the contained value by calling `val->T::~T()`][no effect]]
+]
 * [*Returns:] `*this`;
 * [*Postconditions:] `bool(rhs) == bool(*this)`. 
 * [*Remarks:] The expression inside `noexcept` is equivalent to `is_nothrow_move_constructible<T>::value && is_nothrow_move_assignable<T>::value`.
@@ -696,21 +561,18 @@ __SPACE__
 
 [: `template<U> optional& optional<T` ['(not a ref)]`>::operator= ( optional<U> const& rhs ) ;`]
 
-* [*Effect:] Assigns another convertible optional to an optional.
-* [*Postconditions:] If `rhs` is initialized, `*this` is initialized and
-its value is a ['copy] of the value of `rhs` ['converted] to type `T`; else
-`*this` is uninitialized. 
-* [*Throws:] Whatever `T::operator=( U const& )` or `T::T( U const& )` throws.
-* [*Notes:] If both `*this` and rhs are initially initialized, `T`'s
-['assignment operator] (from `U`) is used. If `*this` is initially initialized
-but `rhs` is uninitialized, `T`'s ['destructor] is called. If `*this` is
-initially uninitialized but rhs is initialized, `T`'s ['converting constructor]
-(from `U`) is called.
-* [*Exception Safety:] In the event of an exception, the initialization state
-of `*this` is unchanged and its value unspecified as far as optional is
-concerned (it is up to `T`'s `operator=()`). If `*this` is initially
-uninitialized and `T`'s converting constructor fails, `*this` is left properly
-uninitialized.
+* [*Effect:] 
+[table 
+  []
+  [[][[*`*this` contains a value]][[*`*this` does not contain a value]]]
+  [[[*`rhs` contains a value]][assigns `*rhs` to the contained value][initializes the contained value as if direct-initializing an object of type `T` with `*rhs`]]
+  [[[*`rhs` does not contain a value]][destroys the contained value by calling `val->T::~T()`][no effect]]
+]
+* [*Returns:] `*this`.
+* [*Postconditions:] `bool(rhs) == bool(*this)`. 
+* [*Exception Safety:] If any exception is thrown, the result of the expression `bool(*this)` remains unchanged.
+If an exception is thrown during the call to `T`'s constructor, no effect.
+If an exception is thrown during the call to `T`'s assignment, the state of its contained value is as defined by the exception safety guarantee of `T`'s copy assignment.
 * [*Example:]
 ``
 T v;
@@ -727,21 +589,18 @@ __SPACE__
 
 [: `template<U> optional& optional<T` ['(not a ref)]`>::operator= ( optional<U>&& rhs ) ;`]
 
-* [*Effect:] Move-assigns another convertible optional to an optional.
-* [*Postconditions:] If `rhs` is initialized, `*this` is initialized and
-its value is moved from the value of `rhs`; else
-`*this` is uninitialized. 
-* [*Throws:] Whatever `T::operator=( U&& )` or `T::T( U&& )` throws.
-* [*Notes:] If both `*this` and `rhs` are initially initialized, `T`'s
-[' assignment operator] (from `U&&`) is used. If `*this` is initially initialized
-but `rhs` is uninitialized, `T`'s ['destructor] is called. If `*this` is
-initially uninitialized but `rhs` is initialized, `T`'s ['converting constructor]
-(from `U&&`) is called.
-* [*Exception Safety:] In the event of an exception, the initialization state
-of `*this` is unchanged and its value unspecified as far as optional is
-concerned (it is up to `T`'s `operator=()`). If `*this` is initially
-uninitialized and `T`'s converting constructor fails, `*this` is left properly
-uninitialized.
+* [*Effect:]
+[table
+  [] 
+  [[][[*`*this` contains a value]][[*`*this` does not contain a value]]]
+  [[[*`rhs` contains a value]][assigns `std::move(*rhs)` to the contained value][initializes the contained value as if direct-initializing an object of type `T` with `std::move(*rhs)`]]
+  [[[*`rhs` does not contain a value]][destroys the contained value by calling `val->T::~T()`][no effect]]
+]
+* [*Returns:] `*this`.
+* [*Postconditions:] `bool(rhs) == bool(*this)`. 
+* [*Exception Safety:] If any exception is thrown, the result of the expression `bool(*this)` remains unchanged.
+If an exception is thrown during the call to `T`'s constructor, no effect.
+If an exception is thrown during the call to `T`'s assignment, the state of its contained value is as defined by the exception safety guarantee of `T`'s copy assignment.
 * [*Example:]
 ``
 T v;
@@ -766,8 +625,10 @@ __SPACE__
  of type `T` with `std::forward<Args>(args)...`. 
 * [*Postconditions: ] `*this` is [_initialized].
 * [*Throws:] Whatever the selected `T`'s  constructor throws.
-* [*Notes:] `T` need not be __MOVE_CONSTRUCTIBLE__ or `MoveAssignable`. On compilers that do not support variadic templates, the signature falls back to single-argument: `template<class Arg> void emplace(Arg&& arg)`. On compilers that do not support rvalue references, the signature falls back to two overloads: taking `const` and non-`const` lvalue reference. 
 * [*Exception Safety:] If an exception is thrown during the initialization of `T`, `*this` is ['uninitialized].
+* [*Notes:] `T` need not be __MOVE_CONSTRUCTIBLE__ or `MoveAssignable`. 
+ On compilers that do not support variadic templates, the signature falls back to two overloads:`template<class Arg> void emplace(Arg&& arg)` and `void emplace()`. 
+ On compilers that do not support rvalue references, the signature falls back to three overloads: taking `const` and non-`const` lvalue reference, and third with empty function argument list. 
 * [*Example:]
 ``
 T v;
@@ -1143,9 +1004,8 @@ __SPACE__
 * [*Requires:] `T` shall meet requirements of __SGI_EQUALITY_COMPARABLE__.
 * [*Returns:] If both `x` and `y` are initialized, `(*x == *y)`. If only
 `x` or `y` is initialized, `false`. If both are uninitialized, `true`.
-* [*Notes:] Pointers have shallow relational operators while `optional` has
-deep relational operators. Do not use `operator==` directly in generic
-code which expect to be given either an `optional<T>` or a pointer; use
+* [*Notes:] This definition guarantees that `optional<T>` not containing a value is compared unequal to any `optional<T>` containing any value, and equal to any other `optional<T>` not containing a value.
+Pointers have shallow relational operators while `optional` has deep relational operators. Do not use `operator==` directly in generic code which expect to be given either an `optional<T>` or a pointer; use
 __FUNCTION_EQUAL_POINTEES__ instead
 * [*Example:]
 ``
@@ -1172,8 +1032,8 @@ __SPACE__
 
 * [*Requires:] Expression `*x < *y` shall be well-formed and its result shall be convertible to `bool`.
 * [*Returns:] `(!y) ? false : (!x) ? true : *x < *y`.
-* [*Notes:] Pointers have shallow relational operators while `optional` has
-deep relational operators. Do not use `operator<` directly in generic code
+* [*Notes:] This definition guarantees that `optional<T>` not containing a value is ordered as less than any `optional<T>` containing any value, and equivalent to any other `optional<T>` not containing a value.
+Pointers have shallow relational operators while `optional` has deep relational operators. Do not use `operator<` directly in generic code
 which expect to be given either an `optional<T>` or a pointer; use __FUNCTION_LESS_POINTEES__ instead. `T` need not be __SGI_LESS_THAN_COMPARABLE__. Only single `operator<` is required. Other relational operations are defined in terms of this one. If `T`'s `operator<` satisfies the axioms of __SGI_LESS_THAN_COMPARABLE__ (transitivity, antisymmetry and irreflexivity), `optinal<T>` is __SGI_LESS_THAN_COMPARABLE__.
 * [*Example:]
 ``
@@ -1256,10 +1116,12 @@ __SPACE__
 
 * [*Requires:] Lvalues of type `T` shall be swappable and `T` shall be __MOVE_CONSTRUCTIBLE__.
 * [*Effects:]
-  * If `!*this && !rhs`, no effect, otherwise
-  * if `bool(*this) && !rhs`, initializes the contained value of `rhs` as if direct-initializing an object of type `T` with the expression `std::move(*(*this))`, followed by `val->T::~T()`, `*this` does not contain a value and `rhs` contains a value, otherwise
-  * if `!*this && bool(rhs)`, initializes the contained value of `*this` as if direct-initializing an object of type `T` with the expression `std::move(*rhs)`, followed by `rhs.val->T::~T()`, `*this` contains a value and `rhs` does not contain a value, otherwise
-  * (if `bool(*this) && bool(rhs)`) calls `swap(*(*this), *rhs)`.
+[table 
+  []
+  [[][[*`*this` contains a value]][[*`*this` does not contain a value]]]
+  [[[*`rhs` contains a value]][calls `swap(*(*this), *rhs)`][initializes the contained value of `*this` as if direct-initializing an object of type `T` with the expression `std::move(*rhs)`, followed by `rhs.val->T::~T()`, `*this` contains a value and `rhs` does not contain a value]]
+  [[[*`rhs` does not contain a value]][initializes the contained value of `rhs` as if direct-initializing an object of type `T` with the expression `std::move(*(*this))`, followed by `val->T::~T()`, `*this` does not contain a value and `rhs` contains a value][no effect]]
+]
 * [*Postconditions:] The states of `x` and `y` interchanged.
 * [*Throws:] If both are initialized, whatever `swap(T&,T&)` throws. If only
 one is initialized, whatever `T::T ( T&& )` throws.

doc/29_ref_optional_convenience.qbk

@@ -0,0 +1,17 @@
+[/
+    Boost.Optional
+
+    Copyright (c) 2003-2007 Fernando Luis Cacciola Carballal
+    Copyright (c) 2015 Andrzej Krzemienski
+
+    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)
+]
+
+[section Header <boost/optional.hpp>]
+
+This is an alias for header [link boost_optional.reference.header__boost_optional_optional_hpp_.header_optional_optional `<boost/optional/optional.hpp>`].
+
+
+[endsect]

doc/91_relnotes.qbk

@@ -0,0 +1,55 @@
+[/
+    Boost.Optional
+
+    Copyright (c) 2015 Andrzej Krzemienski
+
+    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)
+]
+
+
+[section:relnotes Release Notes]
+
+[heading Boost Release 1.60]
+
+* Changed the implementation of `boost::none` again. Now it is a const object with internal linkage (as any other tag). This fixes [@https://svn.boost.org/trac/boost/ticket/11203 Trac #11203].
+
+[heading Boost Release 1.59]  
+
+* For C++03 compilers, added 0-argument overload for member function `emplace()`, and therewith removed the dependency on `<boost/utility/in_place_factory.hpp>`.
+* Fixed [@https://svn.boost.org/trac/boost/ticket/11241 Trac #11241].
+
+[heading Boost Release 1.58]
+
+* `boost::none_t` is no longer convertible from literal `0`. This avoids a bug where `optional<rational<int>> oi = 0;` would initialize an optional object with no contained value.
+* Improved the trick that prevents streaming out `optional` without header `optional_io.hpp` by using safe-bool idiom. This addresses [@https://svn.boost.org/trac/boost/ticket/10825 Trac #10825].
+* IOStream operators are now mentioned in documentation.
+* Added a way to manually disable move semantics: just define macro `BOOST_OPTIONAL_CONFIG_NO_RVALUE_REFERENCES`. This can be used to work around [@https://svn.boost.org/trac/boost/ticket/10399 Trac #10399].
+* It is no longer possible to assign `optional<U>` to `optional<T>` when `U` is not assignable or convertible to `T` ([@https://svn.boost.org/trac/boost/ticket/11087 Trac #11087]).
+* Value accessors now work correctly on rvalues of `optional<T&>` ([@https://svn.boost.org/trac/boost/ticket/10839 Trac #10839]).  
+
+
+[heading Boost Release 1.57]
+
+* [@https://github.com/boostorg/optional/pull/9 Git pull #9]: ['"Supply `<string>` to fix C++03 compile error on `logic_error("...")`"].
+
+
+[heading Boost Release 1.56]
+
+* Added support for rvalue references. Now `optional<T>` works with moveable but non-copyable `T`'s,
+* Improved `swap` (now uses move operations),
+* Added function `emplace()`. This is the last of the requests from [@https://svn.boost.org/trac/boost/ticket/1841 Trac #1841],
+* `optional` is moveable, including conditional `noexcept` specifications, which make it `move_if_noexcept`-friendly,
+* Using explicit operator bool() on platforms that support it ([@https://svn.boost.org/trac/boost/ticket/4227 Trac #4227]) (breaking change),
+* Forward declaration of `operator<<(ostream&, optional const&)` to prevent inadvertent incorrect serialization of optional objects,
+* Removed deprecated function `reset()` from examples ([@https://svn.boost.org/trac/boost/ticket/9005 Trac #9005]),
+* Equality comparison with `boost::none` does not require that `T` be EqualityComparable,
+* Optional rvalue references are explicitly disallowed,
+* Binding temporaries to optional references is explicitly disallowed (breaking change),
+* More ways to access the contained value, functions `value()`, `value_or()`, `value_or_eval()`,
+* Updated and reorganized documentation, added tutorial and quick guide sections.
+
+
+
+[endsect][/ relnotes]

doc/92_acknowledgments.qbk

@@ -9,7 +9,7 @@
 ]
 
 
-[section Acknowledgements]
+[section:acknowledgements Acknowledgements]
 
 [heading Pre-formal review]
 

doc/Jamfile.v2

@@ -20,6 +20,16 @@ xml optional
         00_optional.qbk
     ;
 
+install images
+    :
+        images/opt_align1.png
+        images/opt_align2.png
+        images/opt_align3.png
+        images/opt_align4.png
+    :
+        <location>html/images
+    ;
+        
 boostbook standalone
     :
         optional

doc/html/boost_optional/acknowledgements.html

@@ -6,7 +6,7 @@
 <meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
 <link rel="home" href="../index.html" title="Boost.Optional">
 <link rel="up" href="../index.html" title="Boost.Optional">
-<link rel="prev" href="dependencies_and_portability/optional_reference_binding.html" title="Optional Reference Binding">
+<link rel="prev" href="relnotes.html" title="Release Notes">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -19,7 +19,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="dependencies_and_portability/optional_reference_binding.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a>
+<a accesskey="p" href="relnotes.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
@@ -116,7 +116,7 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014 Andrzej Krzemie&#324;ski<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
@@ -124,7 +124,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="dependencies_and_portability/optional_reference_binding.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a>
+<a accesskey="p" href="relnotes.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a>
 </div>
 </body>
 </html>

doc/html/boost_optional/dependencies_and_portability.html

@@ -6,7 +6,7 @@
 <meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
 <link rel="home" href="../index.html" title="Boost.Optional">
 <link rel="up" href="../index.html" title="Boost.Optional">
-<link rel="prev" href="reference/detailed_semantics.html" title="Detailed Semantics">
+<link rel="prev" href="reference/header__boost_optional_hpp_.html" title="Header &lt;boost/optional.hpp&gt;">
 <link rel="next" href="dependencies_and_portability/optional_reference_binding.html" title="Optional Reference Binding">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -20,7 +20,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="reference/detailed_semantics.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="dependencies_and_portability/optional_reference_binding.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="reference/header__boost_optional_hpp_.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="dependencies_and_portability/optional_reference_binding.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
@@ -75,7 +75,7 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014 Andrzej Krzemie&#324;ski<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
@@ -83,7 +83,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="reference/detailed_semantics.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="dependencies_and_portability/optional_reference_binding.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="reference/header__boost_optional_hpp_.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="dependencies_and_portability/optional_reference_binding.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

doc/html/boost_optional/dependencies_and_portability/optional_reference_binding.html

@@ -7,7 +7,7 @@
 <link rel="home" href="../../index.html" title="Boost.Optional">
 <link rel="up" href="../dependencies_and_portability.html" title="Dependencies and Portability">
 <link rel="prev" href="../dependencies_and_portability.html" title="Dependencies and Portability">
-<link rel="next" href="../acknowledgements.html" title="Acknowledgements">
+<link rel="next" href="../relnotes.html" title="Release Notes">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -20,7 +20,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="../dependencies_and_portability.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../dependencies_and_portability.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../acknowledgements.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="../dependencies_and_portability.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../dependencies_and_portability.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../relnotes.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -86,7 +86,7 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014 Andrzej Krzemie&#324;ski<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
@@ -94,7 +94,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="../dependencies_and_portability.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../dependencies_and_portability.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../acknowledgements.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="../dependencies_and_portability.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../dependencies_and_portability.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../relnotes.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

doc/html/boost_optional/quick_start.html

@@ -44,10 +44,10 @@
       return values</a>
 </h3></div></div></div>
 <p>
-        Let's write and use a converter function that converts an a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code>
+        Let's write and use a converter function that converts a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code>
         to an <code class="computeroutput"><span class="keyword">int</span></code>. It is possible that
         for a given string (e.g. <code class="computeroutput"><span class="string">"cat"</span></code>)
-        there exist no value of type <code class="computeroutput"><span class="keyword">int</span></code>
+        there exists no value of type <code class="computeroutput"><span class="keyword">int</span></code>
         capable of representing the conversion result. We do not consider such situation
         an error. We expect that the converter can be used only to check if the conversion
         is possible. A natural signature for this function can be:
@@ -155,7 +155,7 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014 Andrzej Krzemie&#324;ski<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>

doc/html/boost_optional/quick_start/bypassing_unnecessary_default_construction.html

@@ -61,7 +61,7 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014 Andrzej Krzemie&#324;ski<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>

doc/html/boost_optional/quick_start/optional_automatic_variables.html

@@ -49,11 +49,11 @@
         in an indeterminate state. Its state is always well defined. Instruction
         <code class="computeroutput"><span class="identifier">ans</span> <span class="special">=</span>
         <span class="identifier">i</span></code> initializes the optional object.
-        It uses the assignment from <code class="computeroutput"><span class="keyword">int</span></code>.
+        It uses the 'mixed' assignment from <code class="computeroutput"><span class="keyword">int</span></code>.
         In general, for <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>,
         when an assignment from <code class="computeroutput"><span class="identifier">T</span></code>
         is invoked, it can do two things. If the optional object is not initialized
-        our case here), it initializes it with <code class="computeroutput"><span class="identifier">T</span></code>'s
+        (our case here), it initializes the contained value using <code class="computeroutput"><span class="identifier">T</span></code>'s
         copy constructor. If the optional object is already initialized, it assigns
         the new value to it using <code class="computeroutput"><span class="identifier">T</span></code>'s
         copy assignment.
@@ -61,7 +61,7 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014 Andrzej Krzemie&#324;ski<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>

doc/html/boost_optional/quick_start/optional_data_members.html

@@ -80,7 +80,7 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014 Andrzej Krzemie&#324;ski<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>

doc/html/boost_optional/quick_start/storage_in_containers.html

@@ -50,7 +50,7 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014 Andrzej Krzemie&#324;ski<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>

doc/html/boost_optional/reference/header__boost_optional_bad_optional_access_hpp_.html

@@ -0,0 +1,63 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Header &lt;boost/optional/bad_optional_access.hpp&gt;</title>
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../index.html" title="Boost.Optional">
+<link rel="up" href="../../optional/reference.html" title="Reference">
+<link rel="prev" href="../../optional/reference.html" title="Reference">
+<link rel="next" href="header__boost_optional_bad_optional_access_hpp_/detailed_semantics.html" title="Detailed semantics">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../../optional/reference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../optional/reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="header__boost_optional_bad_optional_access_hpp_/detailed_semantics.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_optional.reference.header__boost_optional_bad_optional_access_hpp_"></a><a class="link" href="header__boost_optional_bad_optional_access_hpp_.html" title="Header &lt;boost/optional/bad_optional_access.hpp&gt;">Header
+      &lt;boost/optional/bad_optional_access.hpp&gt;</a>
+</h3></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_optional.reference.header__boost_optional_bad_optional_access_hpp_.synopsis"></a><a class="link" href="header__boost_optional_bad_optional_access_hpp_.html#boost_optional.reference.header__boost_optional_bad_optional_access_hpp_.synopsis" title="Synopsis">Synopsis</a>
+</h4></div></div></div>
+<p>
+</p>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
+
+<span class="keyword">class</span> <span class="identifier">bad_optional_access</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">logic_error</span>
+<span class="special">{</span>
+<span class="keyword">public</span><span class="special">:</span>
+    <span class="identifier">bad_optional_access</span><span class="special">();</span> <a class="link" href="header__boost_optional_bad_optional_access_hpp_/detailed_semantics.html#reference_bad_optional_access_constructor"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
+<span class="special">};</span>
+
+<span class="special">}</span> <span class="comment">// namespace boost</span>
+</pre>
+<p>
+        </p>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../../optional/reference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../optional/reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="header__boost_optional_bad_optional_access_hpp_/detailed_semantics.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

doc/html/boost_optional/reference/header__boost_optional_bad_optional_access_hpp_/detailed_semantics.html

@@ -0,0 +1,60 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Detailed semantics</title>
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../index.html" title="Boost.Optional">
+<link rel="up" href="../header__boost_optional_bad_optional_access_hpp_.html" title="Header &lt;boost/optional/bad_optional_access.hpp&gt;">
+<link rel="prev" href="../header__boost_optional_bad_optional_access_hpp_.html" title="Header &lt;boost/optional/bad_optional_access.hpp&gt;">
+<link rel="next" href="../io_header.html" title="Header &lt;boost/optional/optional_io.hpp&gt;">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../header__boost_optional_bad_optional_access_hpp_.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../header__boost_optional_bad_optional_access_hpp_.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../io_header.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_optional.reference.header__boost_optional_bad_optional_access_hpp_.detailed_semantics"></a><a class="link" href="detailed_semantics.html" title="Detailed semantics">Detailed
+        semantics</a>
+</h4></div></div></div>
+<p>
+          <span class="inlinemediaobject"><img src="../../../images/space.png" alt="space"></span>
+        </p>
+<p>
+          <a name="reference_bad_optional_access_constructor"></a><code class="computeroutput"><span class="identifier">bad_optional_access</span><span class="special">();</span></code>
+        </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+              <span class="bold"><strong>Effect:</strong></span> Constructs an object of class
+              <code class="computeroutput"><span class="identifier">bad_optional_access</span></code>.
+            </li>
+<li class="listitem">
+              <span class="bold"><strong>Postconditions:</strong></span> <code class="computeroutput"><span class="identifier">what</span><span class="special">()</span></code> returns an implementation-defined
+              NTBS.
+            </li>
+</ul></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../header__boost_optional_bad_optional_access_hpp_.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../header__boost_optional_bad_optional_access_hpp_.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../io_header.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

doc/html/boost_optional/reference/header__boost_optional_hpp_.html

@@ -0,0 +1,47 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Header &lt;boost/optional.hpp&gt;</title>
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../index.html" title="Boost.Optional">
+<link rel="up" href="../../optional/reference.html" title="Reference">
+<link rel="prev" href="header__boost_optional_optional_hpp_/detailed_semantics.html" title="Detailed Semantics">
+<link rel="next" href="../dependencies_and_portability.html" title="Dependencies and Portability">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="header__boost_optional_optional_hpp_/detailed_semantics.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../optional/reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../dependencies_and_portability.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_optional.reference.header__boost_optional_hpp_"></a><a class="link" href="header__boost_optional_hpp_.html" title="Header &lt;boost/optional.hpp&gt;">Header
+      &lt;boost/optional.hpp&gt;</a>
+</h3></div></div></div>
+<p>
+        This is an alias for header <a class="link" href="../../optional/reference/header__boost_optional_optional_hpp_.html#boost_optional.reference.header__boost_optional_optional_hpp_.header_optional_optional" title="Synopsis"><code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">optional</span><span class="special">/</span><span class="identifier">optional</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code></a>.
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="header__boost_optional_optional_hpp_/detailed_semantics.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../optional/reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../dependencies_and_portability.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

doc/html/boost_optional/reference/header__boost_optional_optional_fwd_hpp_.html

@@ -0,0 +1,66 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Header &lt;boost/optional/optional_fwd.hpp&gt;</title>
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../index.html" title="Boost.Optional">
+<link rel="up" href="../../optional/reference.html" title="Reference">
+<link rel="prev" href="io_header/io_semantics.html" title="Detailed semantics">
+<link rel="next" href="../../optional/reference/header__boost_optional_optional_hpp_.html" title="Header &lt;boost/optional/optional.hpp&gt;">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="io_header/io_semantics.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../optional/reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../../optional/reference/header__boost_optional_optional_hpp_.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_optional.reference.header__boost_optional_optional_fwd_hpp_"></a><a class="link" href="header__boost_optional_optional_fwd_hpp_.html" title="Header &lt;boost/optional/optional_fwd.hpp&gt;">Header
+      &lt;boost/optional/optional_fwd.hpp&gt;</a>
+</h3></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_optional.reference.header__boost_optional_optional_fwd_hpp_.synopsis"></a><a class="link" href="header__boost_optional_optional_fwd_hpp_.html#boost_optional.reference.header__boost_optional_optional_fwd_hpp_.synopsis" title="Synopsis">Synopsis</a>
+</h4></div></div></div>
+<p>
+</p>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <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">class</span> <span class="identifier">optional</span> <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">void</span> <span class="identifier">swap</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&amp;</span> <span class="special">,</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&amp;</span> <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">struct</span> <span class="identifier">optional_swap_should_use_default_constructor</span> <span class="special">;</span>
+
+<span class="special">}</span> <span class="comment">// namespace boost</span>
+</pre>
+<p>
+        </p>
+<p>
+          This header only contains declarations.
+        </p>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="io_header/io_semantics.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../optional/reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../../optional/reference/header__boost_optional_optional_hpp_.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

doc/html/boost_optional/reference/io_header.html

@@ -0,0 +1,72 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Header &lt;boost/optional/optional_io.hpp&gt;</title>
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../index.html" title="Boost.Optional">
+<link rel="up" href="../../optional/reference.html" title="Reference">
+<link rel="prev" href="header__boost_optional_bad_optional_access_hpp_/detailed_semantics.html" title="Detailed semantics">
+<link rel="next" href="io_header/io_semantics.html" title="Detailed semantics">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="header__boost_optional_bad_optional_access_hpp_/detailed_semantics.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../optional/reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="io_header/io_semantics.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_optional.reference.io_header"></a><a class="link" href="io_header.html" title="Header &lt;boost/optional/optional_io.hpp&gt;">Header &lt;boost/optional/optional_io.hpp&gt;</a>
+</h3></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_optional.reference.io_header.io_synop"></a><a class="link" href="io_header.html#boost_optional.reference.io_header.io_synop" title="Synopsis">Synopsis</a>
+</h4></div></div></div>
+<p>
+</p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">istream</span><span class="special">&gt;</span>
+<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">ostream</span><span class="special">&gt;</span>
+<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">optional</span><span class="special">/</span><span class="identifier">optional</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+
+<span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CharType</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">CharTrait</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
+  <span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">CharType</span><span class="special">,</span> <span class="identifier">CharTrait</span><span class="special">&gt;&amp;</span>
+  <span class="keyword">operator</span><span class="special">&lt;&lt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">CharType</span><span class="special">,</span> <span class="identifier">CharTrait</span><span class="special">&gt;&amp;</span> <span class="identifier">out</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">v</span><span class="special">);</span> <a class="link" href="io_header/io_semantics.html#reference_operator_ostream"><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">CharType</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">CharTrait</span><span class="special">&gt;</span>
+  <span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">CharType</span><span class="special">,</span> <span class="identifier">CharTrait</span><span class="special">&gt;&amp;</span>
+  <span class="keyword">operator</span><span class="special">&lt;&lt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">CharType</span><span class="special">,</span> <span class="identifier">CharTrait</span><span class="special">&gt;&amp;</span> <span class="identifier">out</span><span class="special">,</span> <span class="identifier">none_t</span> <span class="keyword">const</span><span class="special">&amp;);</span> <a class="link" href="io_header/io_semantics.html#reference_operator_ostream_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">CharType</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">CharTrait</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
+  <span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_istream</span><span class="special">&lt;</span><span class="identifier">CharType</span><span class="special">,</span> <span class="identifier">CharTrait</span><span class="special">&gt;&amp;</span>
+  <span class="keyword">operator</span><span class="special">&gt;&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_istream</span><span class="special">&lt;</span><span class="identifier">CharType</span><span class="special">,</span> <span class="identifier">CharTrait</span><span class="special">&gt;&amp;</span> <span class="identifier">in</span><span class="special">,</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&amp;</span> <span class="identifier">v</span><span class="special">);</span> <a class="link" href="io_header/io_semantics.html#reference_operator_istream"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
+
+<span class="special">}</span> <span class="comment">// namespace boost</span>
+</pre>
+<p>
+        </p>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="header__boost_optional_bad_optional_access_hpp_/detailed_semantics.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../optional/reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="io_header/io_semantics.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

doc/html/boost_optional/reference/io_header/io_semantics.html

@@ -0,0 +1,112 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Detailed semantics</title>
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../index.html" title="Boost.Optional">
+<link rel="up" href="../io_header.html" title="Header &lt;boost/optional/optional_io.hpp&gt;">
+<link rel="prev" href="../io_header.html" title="Header &lt;boost/optional/optional_io.hpp&gt;">
+<link rel="next" href="../header__boost_optional_optional_fwd_hpp_.html" title="Header &lt;boost/optional/optional_fwd.hpp&gt;">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../io_header.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../io_header.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../header__boost_optional_optional_fwd_hpp_.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_optional.reference.io_header.io_semantics"></a><a class="link" href="io_semantics.html" title="Detailed semantics">Detailed
+        semantics</a>
+</h4></div></div></div>
+<p>
+          <a name="reference_operator_ostream"></a><code class="computeroutput"><span class="keyword">template</span>
+          <span class="special">&lt;</span><span class="keyword">class</span>
+          <span class="identifier">CharType</span><span class="special">,</span>
+          <span class="keyword">class</span> <span class="identifier">CharTrait</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span></code>
+          <br> &#160;&#160;&#160;&#160;<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">CharType</span><span class="special">,</span> <span class="identifier">CharTrait</span><span class="special">&gt;&amp;</span></code> <br> &#160;&#160;&#160;&#160;<code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">CharType</span><span class="special">,</span> <span class="identifier">CharTrait</span><span class="special">&gt;&amp;</span>
+          <span class="identifier">out</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">v</span><span class="special">);</span></code>
+        </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+              <span class="bold"><strong>Effect:</strong></span> Outputs an implementation-defined
+              string. The output contains the information about whether the optional
+              object contains a value or not. If <code class="computeroutput"><span class="identifier">v</span></code>
+              contains a value, the output contains result of calling <code class="computeroutput"><span class="identifier">out</span> <span class="special">&lt;&lt;</span>
+              <span class="special">*</span><span class="identifier">v</span></code>.
+            </li>
+<li class="listitem">
+              <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="identifier">out</span></code>.
+            </li>
+</ul></div>
+<p>
+          <span class="inlinemediaobject"><img src="../../../images/space.png" alt="space"></span> <a name="reference_operator_ostream_none"></a>
+        </p>
+<p>
+          <code class="computeroutput"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CharType</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">CharTrait</span><span class="special">,</span>
+          <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span></code> <br> &#160;&#160;&#160;&#160;<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">CharType</span><span class="special">,</span> <span class="identifier">CharTrait</span><span class="special">&gt;&amp;</span></code>
+          <br> &#160;&#160;&#160;&#160;<code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">CharType</span><span class="special">,</span> <span class="identifier">CharTrait</span><span class="special">&gt;&amp;</span> <span class="identifier">out</span><span class="special">,</span> <span class="identifier">none_t</span><span class="special">);</span></code>
+        </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+              <span class="bold"><strong>Effect:</strong></span> Outputs an implementation-defined
+              string.
+            </li>
+<li class="listitem">
+              <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="identifier">out</span></code>.
+            </li>
+</ul></div>
+<p>
+          <span class="inlinemediaobject"><img src="../../../images/space.png" alt="space"></span> <a name="reference_operator_istream"></a>
+        </p>
+<p>
+          <code class="computeroutput"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CharType</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">CharTrait</span><span class="special">,</span>
+          <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span></code> <br> &#160;&#160;&#160;&#160;<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">CharType</span><span class="special">,</span> <span class="identifier">CharTrait</span><span class="special">&gt;&amp;</span></code>
+          <br> &#160;&#160;&#160;&#160;<code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_istream</span><span class="special">&lt;</span><span class="identifier">CharType</span><span class="special">,</span> <span class="identifier">CharTrait</span><span class="special">&gt;&amp;</span> <span class="identifier">in</span><span class="special">,</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&amp;</span> <span class="identifier">v</span><span class="special">);</span></code>
+        </p>
+<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 <a href="http://www.sgi.com/tech/stl/DefaultConstructible.html" target="_top"><code class="computeroutput"><span class="identifier">DefaultConstructible</span></code></a> and
+              <code class="computeroutput"><span class="identifier">MoveConstructible</span></code>.
+            </li>
+<li class="listitem">
+              <span class="bold"><strong>Effect:</strong></span> Reads the value of optional
+              object from <code class="computeroutput"><span class="identifier">in</span></code>. If
+              the string representation indicates that the optional object should
+              contain a value, <code class="computeroutput"><span class="identifier">v</span></code>
+              contains a value and its contained value is obtained as if by default-constructing
+              an object <code class="computeroutput"><span class="identifier">o</span></code> of type
+              <code class="computeroutput"><span class="identifier">T</span></code> and then calling
+              <code class="computeroutput"><span class="identifier">in</span> <span class="special">&gt;&gt;</span>
+              <span class="identifier">o</span></code>; otherwise <code class="computeroutput"><span class="identifier">v</span></code> does not contain a value, and the
+              previously contained value (if any) has been destroyed.
+            </li>
+<li class="listitem">
+              <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="identifier">out</span></code>.
+            </li>
+</ul></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../io_header.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../io_header.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../header__boost_optional_optional_fwd_hpp_.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

doc/html/boost_optional/relnotes.html

@@ -0,0 +1,169 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Release Notes</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../index.html" title="Boost.Optional">
+<link rel="up" href="../index.html" title="Boost.Optional">
+<link rel="prev" href="dependencies_and_portability/optional_reference_binding.html" title="Optional Reference Binding">
+<link rel="next" href="acknowledgements.html" title="Acknowledgements">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="dependencies_and_portability/optional_reference_binding.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="acknowledgements.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_optional.relnotes"></a><a class="link" href="relnotes.html" title="Release Notes">Release Notes</a>
+</h2></div></div></div>
+<h4>
+<a name="boost_optional.relnotes.h0"></a>
+      <span class="phrase"><a name="boost_optional.relnotes.boost_release_1_60"></a></span><a class="link" href="relnotes.html#boost_optional.relnotes.boost_release_1_60">Boost
+      Release 1.60</a>
+    </h4>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+          Changed the implementation of <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">none</span></code>
+          again. Now it is a const object with internal linkage (as any other tag).
+          This fixes <a href="https://svn.boost.org/trac/boost/ticket/11203" target="_top">Trac
+          #11203</a>.
+        </li></ul></div>
+<h4>
+<a name="boost_optional.relnotes.h1"></a>
+      <span class="phrase"><a name="boost_optional.relnotes.boost_release_1_59"></a></span><a class="link" href="relnotes.html#boost_optional.relnotes.boost_release_1_59">Boost
+      Release 1.59</a>
+    </h4>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+          For C++03 compilers, added 0-argument overload for member function <code class="computeroutput"><span class="identifier">emplace</span><span class="special">()</span></code>,
+          and therewith removed the dependency on <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">utility</span><span class="special">/</span><span class="identifier">in_place_factory</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>.
+        </li>
+<li class="listitem">
+          Fixed <a href="https://svn.boost.org/trac/boost/ticket/11241" target="_top">Trac #11241</a>.
+        </li>
+</ul></div>
+<h4>
+<a name="boost_optional.relnotes.h2"></a>
+      <span class="phrase"><a name="boost_optional.relnotes.boost_release_1_58"></a></span><a class="link" href="relnotes.html#boost_optional.relnotes.boost_release_1_58">Boost
+      Release 1.58</a>
+    </h4>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+          <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">none_t</span></code> is no longer convertible from
+          literal <code class="computeroutput"><span class="number">0</span></code>. This avoids a bug
+          where <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">rational</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;&gt;</span> <span class="identifier">oi</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span></code> would
+          initialize an optional object with no contained value.
+        </li>
+<li class="listitem">
+          Improved the trick that prevents streaming out <code class="computeroutput"><span class="identifier">optional</span></code>
+          without header <code class="computeroutput"><span class="identifier">optional_io</span><span class="special">.</span><span class="identifier">hpp</span></code>
+          by using safe-bool idiom. This addresses <a href="https://svn.boost.org/trac/boost/ticket/10825" target="_top">Trac
+          #10825</a>.
+        </li>
+<li class="listitem">
+          IOStream operators are now mentioned in documentation.
+        </li>
+<li class="listitem">
+          Added a way to manually disable move semantics: just define macro <code class="computeroutput"><span class="identifier">BOOST_OPTIONAL_CONFIG_NO_RVALUE_REFERENCES</span></code>.
+          This can be used to work around <a href="https://svn.boost.org/trac/boost/ticket/10399" target="_top">Trac
+          #10399</a>.
+        </li>
+<li class="listitem">
+          It is no longer possible to assign <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;</span></code> to <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> when <code class="computeroutput"><span class="identifier">U</span></code>
+          is not assignable or convertible to <code class="computeroutput"><span class="identifier">T</span></code>
+          (<a href="https://svn.boost.org/trac/boost/ticket/11087" target="_top">Trac #11087</a>).
+        </li>
+<li class="listitem">
+          Value accessors now work correctly on rvalues of <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&amp;&gt;</span></code> (<a href="https://svn.boost.org/trac/boost/ticket/10839" target="_top">Trac
+          #10839</a>).
+        </li>
+</ul></div>
+<h4>
+<a name="boost_optional.relnotes.h3"></a>
+      <span class="phrase"><a name="boost_optional.relnotes.boost_release_1_57"></a></span><a class="link" href="relnotes.html#boost_optional.relnotes.boost_release_1_57">Boost
+      Release 1.57</a>
+    </h4>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+          <a href="https://github.com/boostorg/optional/pull/9" target="_top">Git pull #9</a>:
+          <span class="emphasis"><em>"Supply <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">string</span><span class="special">&gt;</span></code>
+          to fix C++03 compile error on <code class="computeroutput"><span class="identifier">logic_error</span><span class="special">(</span><span class="string">"..."</span><span class="special">)</span></code>"</em></span>.
+        </li></ul></div>
+<h4>
+<a name="boost_optional.relnotes.h4"></a>
+      <span class="phrase"><a name="boost_optional.relnotes.boost_release_1_56"></a></span><a class="link" href="relnotes.html#boost_optional.relnotes.boost_release_1_56">Boost
+      Release 1.56</a>
+    </h4>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+          Added support for rvalue references. Now <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> works with moveable but non-copyable
+          <code class="computeroutput"><span class="identifier">T</span></code>'s,
+        </li>
+<li class="listitem">
+          Improved <code class="computeroutput"><span class="identifier">swap</span></code> (now uses
+          move operations),
+        </li>
+<li class="listitem">
+          Added function <code class="computeroutput"><span class="identifier">emplace</span><span class="special">()</span></code>. This is the last of the requests from
+          <a href="https://svn.boost.org/trac/boost/ticket/1841" target="_top">Trac #1841</a>,
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="identifier">optional</span></code> is moveable, including
+          conditional <code class="computeroutput"><span class="keyword">noexcept</span></code> specifications,
+          which make it <code class="computeroutput"><span class="identifier">move_if_noexcept</span></code>-friendly,
+        </li>
+<li class="listitem">
+          Using explicit operator bool() on platforms that support it (<a href="https://svn.boost.org/trac/boost/ticket/4227" target="_top">Trac
+          #4227</a>) (breaking change),
+        </li>
+<li class="listitem">
+          Forward declaration of <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;(</span><span class="identifier">ostream</span><span class="special">&amp;,</span> <span class="identifier">optional</span>
+          <span class="keyword">const</span><span class="special">&amp;)</span></code>
+          to prevent inadvertent incorrect serialization of optional objects,
+        </li>
+<li class="listitem">
+          Removed deprecated function <code class="computeroutput"><span class="identifier">reset</span><span class="special">()</span></code> from examples (<a href="https://svn.boost.org/trac/boost/ticket/9005" target="_top">Trac
+          #9005</a>),
+        </li>
+<li class="listitem">
+          Equality comparison with <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">none</span></code>
+          does not require that <code class="computeroutput"><span class="identifier">T</span></code>
+          be EqualityComparable,
+        </li>
+<li class="listitem">
+          Optional rvalue references are explicitly disallowed,
+        </li>
+<li class="listitem">
+          Binding temporaries to optional references is explicitly disallowed (breaking
+          change),
+        </li>
+<li class="listitem">
+          More ways to access the contained value, functions <code class="computeroutput"><span class="identifier">value</span><span class="special">()</span></code>, <code class="computeroutput"><span class="identifier">value_or</span><span class="special">()</span></code>, <code class="computeroutput"><span class="identifier">value_or_eval</span><span class="special">()</span></code>,
+        </li>
+<li class="listitem">
+          Updated and reorganized documentation, added tutorial and quick guide sections.
+        </li>
+</ul></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="dependencies_and_portability/optional_reference_binding.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="acknowledgements.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

doc/html/boost_optional/tutorial/a_note_about_optional_bool_.html

@@ -94,7 +94,7 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014 Andrzej Krzemie&#324;ski<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>

doc/html/boost_optional/tutorial/design_overview.html

@@ -170,7 +170,7 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014 Andrzej Krzemie&#324;ski<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>

doc/html/boost_optional/tutorial/design_overview/the_interface.html

@@ -63,8 +63,8 @@
         </p>
 <h6>
 <a name="boost_optional.tutorial.design_overview.the_interface.h0"></a>
-          <span class="phrase"><a name="boost_optional.tutorial.design_overview.the_interface.lexically_hinted_value_access_in_the_presence_of_possibly_untitialized_optional_objects__the_operators___and___gt_"></a></span><a class="link" href="the_interface.html#boost_optional.tutorial.design_overview.the_interface.lexically_hinted_value_access_in_the_presence_of_possibly_untitialized_optional_objects__the_operators___and___gt_">Lexically-hinted
-          Value Access in the presence of possibly untitialized optional objects:
+          <span class="phrase"><a name="boost_optional.tutorial.design_overview.the_interface.lexically_hinted_value_access_in_the_presence_of_possibly_uninitialized_optional_objects__the_operators___and___gt_"></a></span><a class="link" href="the_interface.html#boost_optional.tutorial.design_overview.the_interface.lexically_hinted_value_access_in_the_presence_of_possibly_uninitialized_optional_objects__the_operators___and___gt_">Lexically-hinted
+          Value Access in the presence of possibly uninitialized optional objects:
           The operators * and -&gt;</a>
         </h6>
 <p>
@@ -173,7 +173,7 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014 Andrzej Krzemie&#324;ski<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>

doc/html/boost_optional/tutorial/design_overview/the_semantics.html

@@ -107,7 +107,7 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014 Andrzej Krzemie&#324;ski<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>

doc/html/boost_optional/tutorial/exception_safety_guarantees.html

@@ -161,7 +161,7 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014 Andrzej Krzemie&#324;ski<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>

doc/html/boost_optional/tutorial/in_place_factories.html

@@ -183,7 +183,7 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014 Andrzej Krzemie&#324;ski<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>

doc/html/boost_optional/tutorial/io_operators.html

@@ -0,0 +1,87 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>IO operators</title>
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../index.html" title="Boost.Optional">
+<link rel="up" href="../../optional/tutorial.html" title="Tutorial">
+<link rel="prev" href="relational_operators.html" title="Relational operators">
+<link rel="next" href="optional_references.html" title="Optional references">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="relational_operators.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../optional/tutorial.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="optional_references.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_optional.tutorial.io_operators"></a><a class="link" href="io_operators.html" title="IO operators">IO operators</a>
+</h3></div></div></div>
+<p>
+        It is possible to use <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
+        with IO streams, provided that <code class="computeroutput"><span class="identifier">T</span></code>
+        can be used with streams. IOStream operators are defined in a separate header.
+      </p>
+<p>
+</p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
+<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">optional</span><span class="special">/</span><span class="identifier">optional_io</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+
+<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
+<span class="special">{</span>
+  <span class="identifier">boost</span><span class="special">::</span><span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">o1</span> <span class="special">=</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">oN</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">none</span><span class="special">;</span>
+  <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">o1</span><span class="special">;</span>
+  <span class="identifier">std</span><span class="special">::</span><span class="identifier">cin</span> <span class="special">&gt;&gt;</span> <span class="identifier">oN</span><span class="special">;</span>
+<span class="special">}</span>
+</pre>
+<p>
+      </p>
+<p>
+        The current implementation does not guarantee any particular output. What
+        it guarantees is that if streaming out and then back in <code class="computeroutput"><span class="identifier">T</span></code>
+        gives the same value, then streaming out and then back in <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
+        will also give back the same result:
+      </p>
+<p>
+</p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">cassert</span><span class="special">&gt;</span>
+<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">sstream</span><span class="special">&gt;</span>
+<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">optional</span><span class="special">/</span><span class="identifier">optional_io</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+
+<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
+<span class="special">{</span>
+  <span class="identifier">boost</span><span class="special">::</span><span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">o1</span> <span class="special">=</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">oN</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">none</span><span class="special">;</span>
+  <span class="identifier">boost</span><span class="special">::</span><span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">x1</span><span class="special">,</span> <span class="identifier">x2</span><span class="special">;</span>
+  <span class="identifier">std</span><span class="special">::</span><span class="identifier">stringstream</span> <span class="identifier">s</span><span class="special">;</span>
+  <span class="identifier">s</span> <span class="special">&lt;&lt;</span> <span class="identifier">o1</span> <span class="special">&lt;&lt;</span> <span class="identifier">oN</span><span class="special">;</span>
+  <span class="identifier">s</span> <span class="special">&gt;&gt;</span> <span class="identifier">x1</span> <span class="special">&gt;&gt;</span> <span class="identifier">x2</span><span class="special">;</span>
+  <span class="identifier">assert</span> <span class="special">(</span><span class="identifier">o1</span> <span class="special">==</span> <span class="identifier">x1</span><span class="special">);</span>
+  <span class="identifier">assert</span> <span class="special">(</span><span class="identifier">oN</span> <span class="special">==</span> <span class="identifier">x2</span><span class="special">);</span>
+<span class="special">}</span>
+</pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="relational_operators.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../optional/tutorial.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="optional_references.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

doc/html/boost_optional/tutorial/optional_references.html

@@ -6,7 +6,7 @@
 <meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
 <link rel="home" href="../../index.html" title="Boost.Optional">
 <link rel="up" href="../../optional/tutorial.html" title="Tutorial">
-<link rel="prev" href="relational_operators.html" title="Relational operators">
+<link rel="prev" href="io_operators.html" title="IO operators">
 <link rel="next" href="rebinding_semantics_for_assignment_of_optional_references.html" title="Rebinding semantics for assignment of optional references">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -20,7 +20,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="relational_operators.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../optional/tutorial.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rebinding_semantics_for_assignment_of_optional_references.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="io_operators.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../optional/tutorial.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rebinding_semantics_for_assignment_of_optional_references.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -101,7 +101,7 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014 Andrzej Krzemie&#324;ski<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
@@ -109,7 +109,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="relational_operators.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../optional/tutorial.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rebinding_semantics_for_assignment_of_optional_references.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="io_operators.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../optional/tutorial.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rebinding_semantics_for_assignment_of_optional_references.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

doc/html/boost_optional/tutorial/performance_considerations.html

@@ -0,0 +1,223 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Performance considerations</title>
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../index.html" title="Boost.Optional">
+<link rel="up" href="../../optional/tutorial.html" title="Tutorial">
+<link rel="prev" href="type_requirements.html" title="Type requirements">
+<link rel="next" href="../../optional/reference.html" title="Reference">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="type_requirements.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../optional/tutorial.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../../optional/reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_optional.tutorial.performance_considerations"></a><a class="link" href="performance_considerations.html" title="Performance considerations">Performance
+      considerations</a>
+</h3></div></div></div>
+<p>
+        Technical details aside, the memory layout of <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
+        is more-less this:
+      </p>
+<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
+<span class="keyword">class</span> <span class="identifier">optional</span>
+<span class="special">{</span>
+  <span class="keyword">bool</span> <span class="identifier">_initialized</span><span class="special">;</span>
+  <span class="identifier">std</span><span class="special">::</span><span class="identifier">aligned_storage_t</span><span class="special">&lt;</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">t</span><span class="special">),</span> <span class="keyword">alignof</span><span class="special">(</span><span class="identifier">T</span><span class="special">)&gt;</span> <span class="identifier">_storage</span><span class="special">;</span>
+<span class="special">};</span>
+</pre>
+<p>
+        But for the purpose of this analysis, considering memory layouts, we can
+        think of it as:
+      </p>
+<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
+<span class="keyword">class</span> <span class="identifier">optional</span>
+<span class="special">{</span>
+  <span class="keyword">bool</span> <span class="identifier">_initialized</span><span class="special">;</span>
+  <span class="identifier">T</span> <span class="identifier">_storage</span><span class="special">;</span>
+<span class="special">};</span>
+</pre>
+<p>
+        Given type <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span></code>, and
+        assuming that <code class="computeroutput"><span class="keyword">sizeof</span><span class="special">(</span><span class="keyword">int</span><span class="special">)</span> <span class="special">==</span>
+        <span class="number">4</span></code>, we will get <code class="computeroutput"><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;)</span>
+        <span class="special">==</span> <span class="number">8</span></code>.
+        This is so because of the alignment rules, for our two members we get the
+        following alignment:
+      </p>
+<p>
+        <span class="inlinemediaobject"><img src="../../images/opt_align1.png" alt="opt_align1"></span>
+      </p>
+<p>
+        This means you can fit twice as many <code class="computeroutput"><span class="keyword">int</span></code>s
+        as <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span></code>s into
+        the same space of memory. Therefore, if the size of the objects is critical
+        for your application (e.g., because you want to utilize your CPU cache in
+        order to gain performance) and you have determined you are willing to trade
+        the code clarity, it is recommended that you simply go with type <code class="computeroutput"><span class="keyword">int</span></code> and use some 'magic value' to represent
+        <span class="emphasis"><em>not-an-int</em></span>.
+      </p>
+<p>
+        Even if you cannot spare any value of <code class="computeroutput"><span class="keyword">int</span></code>
+        to represent <span class="emphasis"><em>not-an-int</em></span> (e.g., because every value is
+        useful, or you do want to signal <span class="emphasis"><em>not-an-int</em></span> explicitly),
+        at least for <code class="computeroutput"><span class="identifier">Trivial</span></code> types
+        you should consider storing the value and the <code class="computeroutput"><span class="keyword">bool</span></code>
+        flag representing the <span class="emphasis"><em>null-state</em></span> separately. Consider
+        the following class:
+      </p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Record</span>
+<span class="special">{</span>
+  <span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">_min</span><span class="special">;</span>
+  <span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">_max</span><span class="special">;</span>
+<span class="special">};</span>
+</pre>
+<p>
+        Its memory layout can be depicted as follows:
+      </p>
+<p>
+        <span class="inlinemediaobject"><img src="../../images/opt_align2.png" alt="opt_align2"></span>
+      </p>
+<p>
+        This is exactly the same as if we had the following members:
+      </p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Record</span>
+<span class="special">{</span>
+  <span class="keyword">bool</span> <span class="identifier">_has_min</span><span class="special">;</span>
+  <span class="keyword">int</span>  <span class="identifier">_min</span><span class="special">;</span>
+  <span class="keyword">bool</span> <span class="identifier">_has_max</span><span class="special">;</span>
+  <span class="keyword">int</span>  <span class="identifier">_max</span><span class="special">;</span>
+<span class="special">};</span>
+</pre>
+<p>
+        But when they are stored separately, we at least have an option to reorder
+        them like this:
+      </p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Record</span>
+<span class="special">{</span>
+  <span class="keyword">bool</span> <span class="identifier">_has_min</span><span class="special">;</span>
+  <span class="keyword">bool</span> <span class="identifier">_has_max</span><span class="special">;</span>
+  <span class="keyword">int</span>  <span class="identifier">_min</span><span class="special">;</span>
+  <span class="keyword">int</span>  <span class="identifier">_max</span><span class="special">;</span>
+<span class="special">};</span>
+</pre>
+<p>
+        Which gives us the following layout (and smaller total size):
+      </p>
+<p>
+        <span class="inlinemediaobject"><img src="../../images/opt_align3.png" alt="opt_align3"></span>
+      </p>
+<p>
+        Sometimes it requires detailed consideration what data we make optional.
+        In our case above, if we determine that both minimum and maximum value can
+        be provided or not provided together, but one is never provided without the
+        other, we can make only one optional memebr:
+      </p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Limits</span>
+<span class="special">{</span>
+  <span class="keyword">int</span>  <span class="identifier">_min</span><span class="special">;</span>
+  <span class="keyword">int</span>  <span class="identifier">_max</span><span class="special">;</span>
+<span class="special">};</span>
+
+<span class="keyword">struct</span> <span class="identifier">Record</span>
+<span class="special">{</span>
+  <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">Limits</span><span class="special">&gt;</span> <span class="identifier">_limits</span><span class="special">;</span>
+<span class="special">};</span>
+</pre>
+<p>
+        This would give us the following layout:
+      </p>
+<p>
+        <span class="inlinemediaobject"><img src="../../images/opt_align4.png" alt="opt_align4"></span>
+      </p>
+<h5>
+<a name="boost_optional.tutorial.performance_considerations.h0"></a>
+        <span class="phrase"><a name="boost_optional.tutorial.performance_considerations.optional_function_parameters"></a></span><a class="link" href="performance_considerations.html#boost_optional.tutorial.performance_considerations.optional_function_parameters">Optional
+        function parameters</a>
+      </h5>
+<p>
+        Having function parameters of type <code class="computeroutput"><span class="keyword">const</span>
+        <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&amp;</span></code>
+        may incur certain unexpected run-time cost connected to copy construction
+        of <code class="computeroutput"><span class="identifier">T</span></code>. Consider the following
+        code.
+      </p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">fun</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">Big</span><span class="special">&gt;&amp;</span> <span class="identifier">v</span><span class="special">)</span>
+<span class="special">{</span>
+  <span class="keyword">if</span> <span class="special">(</span><span class="identifier">v</span><span class="special">)</span> <span class="identifier">doSomethingWith</span><span class="special">(*</span><span class="identifier">v</span><span class="special">);</span>
+  <span class="keyword">else</span>   <span class="identifier">doSomethingElse</span><span class="special">();</span>
+<span class="special">}</span>
+
+<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
+<span class="special">{</span>
+  <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">Big</span><span class="special">&gt;</span> <span class="identifier">ov</span><span class="special">;</span>
+  <span class="identifier">Big</span> <span class="identifier">v</span><span class="special">;</span>
+  <span class="identifier">fun</span><span class="special">(</span><span class="identifier">none</span><span class="special">);</span>
+  <span class="identifier">fun</span><span class="special">(</span><span class="identifier">ov</span><span class="special">);</span> <span class="comment">// no copy</span>
+  <span class="identifier">fun</span><span class="special">(</span><span class="identifier">v</span><span class="special">);</span>  <span class="comment">// copy constructor of Big</span>
+<span class="special">}</span>
+</pre>
+<p>
+        No copy elision or move semantics can save us from copying type <code class="computeroutput"><span class="identifier">Big</span></code> here. Not that we need any copy, but
+        this is how <code class="computeroutput"><span class="identifier">optional</span></code> works.
+        In order to avoid copying in this case, one could provide second overload
+        of <code class="computeroutput"><span class="identifier">fun</span></code>:
+      </p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">fun</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Big</span><span class="special">&amp;</span> <span class="identifier">v</span><span class="special">)</span>
+<span class="special">{</span>
+  <span class="identifier">doSomethingWith</span><span class="special">(</span><span class="identifier">v</span><span class="special">);</span>
+<span class="special">}</span>
+
+<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
+<span class="special">{</span>
+  <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">Big</span><span class="special">&gt;</span> <span class="identifier">ov</span><span class="special">;</span>
+  <span class="identifier">Big</span> <span class="identifier">v</span><span class="special">;</span>
+  <span class="identifier">fun</span><span class="special">(</span><span class="identifier">ov</span><span class="special">);</span> <span class="comment">// no copy</span>
+  <span class="identifier">fun</span><span class="special">(</span><span class="identifier">v</span><span class="special">);</span>  <span class="comment">// no copy: second overload selected</span>
+<span class="special">}</span>
+</pre>
+<p>
+        Alternatively, you could consider using an optional reference instead:
+      </p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">fun</span><span class="special">(</span><span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">Big</span><span class="special">&amp;&gt;</span> <span class="identifier">v</span><span class="special">)</span> <span class="comment">// note where the reference is</span>
+<span class="special">{</span>
+  <span class="keyword">if</span> <span class="special">(</span><span class="identifier">v</span><span class="special">)</span> <span class="identifier">doSomethingWith</span><span class="special">(*</span><span class="identifier">v</span><span class="special">);</span>
+  <span class="keyword">else</span>   <span class="identifier">doSomethingElse</span><span class="special">();</span>
+<span class="special">}</span>
+
+<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
+<span class="special">{</span>
+  <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">Big</span><span class="special">&gt;</span> <span class="identifier">ov</span><span class="special">;</span>
+  <span class="identifier">Big</span> <span class="identifier">v</span><span class="special">;</span>
+  <span class="identifier">fun</span><span class="special">(</span><span class="identifier">none</span><span class="special">);</span>
+  <span class="identifier">fun</span><span class="special">(</span><span class="identifier">ov</span><span class="special">);</span> <span class="comment">// doesn't compile</span>
+  <span class="identifier">fun</span><span class="special">(</span><span class="identifier">v</span><span class="special">);</span>  <span class="comment">// no copy</span>
+<span class="special">}</span>
+</pre>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="type_requirements.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../optional/tutorial.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../../optional/reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

doc/html/boost_optional/tutorial/rebinding_semantics_for_assignment_of_optional_references.html

@@ -135,7 +135,7 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014 Andrzej Krzemie&#324;ski<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>

doc/html/boost_optional/tutorial/relational_operators.html

@@ -7,7 +7,7 @@
 <link rel="home" href="../../index.html" title="Boost.Optional">
 <link rel="up" href="../../optional/tutorial.html" title="Tutorial">
 <link rel="prev" href="when_to_use_optional.html" title="When to use Optional">
-<link rel="next" href="optional_references.html" title="Optional references">
+<link rel="next" href="io_operators.html" title="IO operators">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -20,7 +20,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="when_to_use_optional.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../optional/tutorial.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="optional_references.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="when_to_use_optional.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../optional/tutorial.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="io_operators.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -30,7 +30,7 @@
 <p>
         Type <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> is
         <a href="http://www.sgi.com/tech/stl/EqualityComparable.html" target="_top"><code class="computeroutput"><span class="identifier">EqualityComparable</span></code></a> whenever <code class="computeroutput"><span class="identifier">T</span></code> is <a href="http://www.sgi.com/tech/stl/EqualityComparable.html" target="_top"><code class="computeroutput"><span class="identifier">EqualityComparable</span></code></a>. Two optional
-        objects containing a value compare in the same as their contained values.
+        objects containing a value compare in the same way as their contained values.
         The uninitialized state of <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
         is treated as a distinct value, equal to itself, and unequal to any value
         of type <code class="computeroutput"><span class="identifier">T</span></code>:
@@ -41,7 +41,7 @@
 
 <span class="identifier">assert</span><span class="special">(</span><span class="identifier">oN</span> <span class="special">!=</span> <span class="identifier">o0</span><span class="special">);</span>
 <span class="identifier">assert</span><span class="special">(</span><span class="identifier">o1</span> <span class="special">!=</span> <span class="identifier">oN</span><span class="special">);</span>
-<span class="identifier">assert</span><span class="special">(</span><span class="identifier">o2</span> <span class="special">!=</span> <span class="identifier">o1</span><span class="special">);</span>
+<span class="identifier">assert</span><span class="special">(</span><span class="identifier">o0</span> <span class="special">!=</span> <span class="identifier">o1</span><span class="special">);</span>
 <span class="identifier">assert</span><span class="special">(</span><span class="identifier">oN</span> <span class="special">==</span> <span class="identifier">oN</span><span class="special">);</span>
 <span class="identifier">assert</span><span class="special">(</span><span class="identifier">o0</span> <span class="special">==</span> <span class="identifier">o0</span><span class="special">);</span>
 </pre>
@@ -55,7 +55,7 @@
       </p>
 <pre class="programlisting"><span class="identifier">assert</span><span class="special">(</span><span class="identifier">oN</span> <span class="special">!=</span> <span class="number">0</span><span class="special">);</span>
 <span class="identifier">assert</span><span class="special">(</span><span class="identifier">o1</span> <span class="special">!=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">none</span><span class="special">);</span>
-<span class="identifier">assert</span><span class="special">(</span><span class="identifier">o2</span> <span class="special">!=</span> <span class="number">1</span><span class="special">);</span>
+<span class="identifier">assert</span><span class="special">(</span><span class="identifier">o0</span> <span class="special">!=</span> <span class="number">1</span><span class="special">);</span>
 <span class="identifier">assert</span><span class="special">(</span><span class="identifier">oN</span> <span class="special">==</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">none</span><span class="special">);</span>
 <span class="identifier">assert</span><span class="special">(</span><span class="identifier">o0</span> <span class="special">==</span> <span class="number">0</span><span class="special">);</span>
 </pre>
@@ -99,7 +99,7 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014 Andrzej Krzemie&#324;ski<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
@@ -107,7 +107,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="when_to_use_optional.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../optional/tutorial.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="optional_references.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="when_to_use_optional.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../optional/tutorial.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="io_operators.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

doc/html/boost_optional/tutorial/type_requirements.html

@@ -7,7 +7,7 @@
 <link rel="home" href="../../index.html" title="Boost.Optional">
 <link rel="up" href="../../optional/tutorial.html" title="Tutorial">
 <link rel="prev" href="exception_safety_guarantees.html" title="Exception Safety Guarantees">
-<link rel="next" href="../../optional/reference.html" title="Reference">
+<link rel="next" href="performance_considerations.html" title="Performance considerations">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -20,7 +20,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="exception_safety_guarantees.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../optional/tutorial.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../../optional/reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="exception_safety_guarantees.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../optional/tutorial.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="performance_considerations.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -95,7 +95,7 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014 Andrzej Krzemie&#324;ski<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
@@ -103,7 +103,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="exception_safety_guarantees.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../optional/tutorial.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../../optional/reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="exception_safety_guarantees.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../optional/tutorial.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="performance_considerations.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

doc/html/boost_optional/tutorial/when_to_use_optional.html

@@ -128,7 +128,7 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014 Andrzej Krzemie&#324;ski<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>

doc/html/index.html

@@ -26,7 +26,7 @@
 <span class="firstname">Fernando Luis</span> <span class="surname">Cacciola Carballal</span>
 </h3></div></div>
 <div><p class="copyright">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal</p></div>
-<div><p class="copyright">Copyright &#169; 2014 Andrzej Krzemie&#324;ski</p></div>
+<div><p class="copyright">Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski</p></div>
 <div><div class="legalnotice">
 <a name="optional.legal"></a><p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -59,6 +59,7 @@
       use Optional</a></span></dt>
 <dt><span class="section"><a href="boost_optional/tutorial/relational_operators.html">Relational
       operators</a></span></dt>
+<dt><span class="section"><a href="boost_optional/tutorial/io_operators.html">IO operators</a></span></dt>
 <dt><span class="section"><a href="boost_optional/tutorial/optional_references.html">Optional
       references</a></span></dt>
 <dt><span class="section"><a href="boost_optional/tutorial/rebinding_semantics_for_assignment_of_optional_references.html">Rebinding
@@ -70,12 +71,22 @@
 <dt><span class="section"><a href="boost_optional/tutorial/exception_safety_guarantees.html">Exception
       Safety Guarantees</a></span></dt>
 <dt><span class="section"><a href="boost_optional/tutorial/type_requirements.html">Type requirements</a></span></dt>
+<dt><span class="section"><a href="boost_optional/tutorial/performance_considerations.html">Performance
+      considerations</a></span></dt>
 </dl></dd>
 <dt><span class="section"><a href="optional/reference.html">Reference</a></span></dt>
 <dd><dl>
-<dt><span class="section"><a href="optional/reference.html#boost_optional.reference.synopsis">Synopsis</a></span></dt>
-<dt><span class="section"><a href="boost_optional/reference/detailed_semantics.html">Detailed
-      Semantics</a></span></dt>
+<dt><span class="section"><a href="optional/reference.html#boost_optional.reference.header__boost_none_hpp_">Header
+      &lt;boost/none.hpp&gt;</a></span></dt>
+<dt><span class="section"><a href="boost_optional/reference/header__boost_optional_bad_optional_access_hpp_.html">Header
+      &lt;boost/optional/bad_optional_access.hpp&gt;</a></span></dt>
+<dt><span class="section"><a href="boost_optional/reference/io_header.html">Header &lt;boost/optional/optional_io.hpp&gt;</a></span></dt>
+<dt><span class="section"><a href="boost_optional/reference/header__boost_optional_optional_fwd_hpp_.html">Header
+      &lt;boost/optional/optional_fwd.hpp&gt;</a></span></dt>
+<dt><span class="section"><a href="optional/reference/header__boost_optional_optional_hpp_.html">Header
+      &lt;boost/optional/optional.hpp&gt;</a></span></dt>
+<dt><span class="section"><a href="boost_optional/reference/header__boost_optional_hpp_.html">Header
+      &lt;boost/optional.hpp&gt;</a></span></dt>
 </dl></dd>
 <dt><span class="section"><a href="boost_optional/dependencies_and_portability.html">Dependencies
     and Portability</a></span></dt>
@@ -84,6 +95,7 @@
 <dt><span class="section"><a href="boost_optional/dependencies_and_portability/optional_reference_binding.html">Optional
       Reference Binding</a></span></dt>
 </dl></dd>
+<dt><span class="section"><a href="boost_optional/relnotes.html">Release Notes</a></span></dt>
 <dt><span class="section"><a href="boost_optional/acknowledgements.html">Acknowledgements</a></span></dt>
 </dl>
 </div>
@@ -107,9 +119,10 @@
       integral value, let's call it <code class="computeroutput"><span class="string">"MaxValue"</span></code>.
       It is possible that this parameter is not specified; such situation is no error.
       It is valid to not specify the parameter and in that case the program is supposed
-      to behave slightly different. Also suppose that any possible value of type
-      <code class="computeroutput"><span class="keyword">int</span></code> is a valid value for <code class="computeroutput"><span class="string">"MaxValue"</span></code>, so we cannot jut use <code class="computeroutput"><span class="special">-</span><span class="number">1</span></code> to represent
-      the absence of the parameter in the config file.
+      to behave slightly differently. Also, suppose that any possible value of type
+      <code class="computeroutput"><span class="keyword">int</span></code> is a valid value for <code class="computeroutput"><span class="string">"MaxValue"</span></code>, so we cannot just use
+      <code class="computeroutput"><span class="special">-</span><span class="number">1</span></code>
+      to represent the absence of the parameter in the config file.
     </p>
 <h4>
 <a name="optional.introduction.h1"></a>
@@ -133,7 +146,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: July 10, 2014 at 11:41:49 GMT</small></p></td>
+<td align="left"><p><small>Last revised: October 20, 2015 at 21:17:45 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>

doc/html/optional/reference.html

@@ -6,8 +6,8 @@
 <meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
 <link rel="home" href="../index.html" title="Boost.Optional">
 <link rel="up" href="../index.html" title="Boost.Optional">
-<link rel="prev" href="../boost_optional/tutorial/type_requirements.html" title="Type requirements">
-<link rel="next" href="../boost_optional/reference/detailed_semantics.html" title="Detailed Semantics">
+<link rel="prev" href="../boost_optional/tutorial/performance_considerations.html" title="Performance considerations">
+<link rel="next" href="../boost_optional/reference/header__boost_optional_bad_optional_access_hpp_.html" title="Header &lt;boost/optional/bad_optional_access.hpp&gt;">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -20,160 +20,62 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="../boost_optional/tutorial/type_requirements.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../boost_optional/reference/detailed_semantics.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="../boost_optional/tutorial/performance_considerations.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../boost_optional/reference/header__boost_optional_bad_optional_access_hpp_.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="optional.reference"></a><a class="link" href="reference.html" title="Reference">Reference</a>
 </h2></div></div></div>
 <div class="toc"><dl class="toc">
-<dt><span class="section"><a href="reference.html#boost_optional.reference.synopsis">Synopsis</a></span></dt>
-<dt><span class="section"><a href="../boost_optional/reference/detailed_semantics.html">Detailed
-      Semantics</a></span></dt>
+<dt><span class="section"><a href="reference.html#boost_optional.reference.header__boost_none_hpp_">Header
+      &lt;boost/none.hpp&gt;</a></span></dt>
+<dt><span class="section"><a href="../boost_optional/reference/header__boost_optional_bad_optional_access_hpp_.html">Header
+      &lt;boost/optional/bad_optional_access.hpp&gt;</a></span></dt>
+<dt><span class="section"><a href="../boost_optional/reference/io_header.html">Header &lt;boost/optional/optional_io.hpp&gt;</a></span></dt>
+<dt><span class="section"><a href="../boost_optional/reference/header__boost_optional_optional_fwd_hpp_.html">Header
+      &lt;boost/optional/optional_fwd.hpp&gt;</a></span></dt>
+<dt><span class="section"><a href="reference/header__boost_optional_optional_hpp_.html">Header
+      &lt;boost/optional/optional.hpp&gt;</a></span></dt>
+<dt><span class="section"><a href="../boost_optional/reference/header__boost_optional_hpp_.html">Header
+      &lt;boost/optional.hpp&gt;</a></span></dt>
 </dl></div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_optional.reference.synopsis"></a><a class="link" href="reference.html#boost_optional.reference.synopsis" title="Synopsis">Synopsis</a>
+<a name="boost_optional.reference.header__boost_none_hpp_"></a><a class="link" href="reference.html#boost_optional.reference.header__boost_none_hpp_" title="Header &lt;boost/none.hpp&gt;">Header
+      &lt;boost/none.hpp&gt;</a>
 </h3></div></div></div>
-<pre class="programlisting"><code class="computeroutput"><span class="comment">// In Header: &lt;</span></code><a href="../../../../../boost/optional/optional.hpp" target="_top">boost/optional/optional.hpp</a><span class="comment">&gt;</span>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_optional.reference.header__boost_none_hpp_.synopsis"></a><a class="link" href="reference.html#boost_optional.reference.header__boost_none_hpp_.synopsis" title="Synopsis">Synopsis</a>
+</h4></div></div></div>
+<p>
+</p>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
 
-<span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
+<span class="keyword">class</span> <span class="identifier">none_t</span> <span class="special">{/*</span> <span class="identifier">see</span> <span class="identifier">below</span> <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">class</span> <span class="identifier">optional</span>
-<span class="special">{</span>
-    <span class="keyword">public</span> <span class="special">:</span>
-
-    <span class="comment">// (If T is of reference type, the parameters and results by reference are by value)</span>
-
-    <span class="identifier">optional</span> <span class="special">()</span> <span class="keyword">noexcept</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_constructor"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="identifier">optional</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="../boost_optional/reference/detailed_semantics.html#reference_optional_constructor_none_t"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="identifier">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="../boost_optional/reference/detailed_semantics.html#reference_optional_constructor_value"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="identifier">optional</span> <span class="special">(</span> <span class="identifier">T</span><span class="special">&amp;&amp;</span> <span class="identifier">v</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_constructor_move_value"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="comment">// [new in 1.34]</span>
-    <span class="identifier">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="../boost_optional/reference/detailed_semantics.html#reference_optional_constructor_bool_value"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="identifier">optional</span> <span class="special">(</span> <span class="identifier">optional</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_constructor_optional"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="identifier">optional</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&amp;&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="keyword">noexcept</span><span class="special">(</span><span class="emphasis"><em>see below</em></span><span class="special">)</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_move_constructor_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">U</span><span class="special">&gt;</span> <span class="keyword">explicit</span> <span class="identifier">optional</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_constructor_other_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">U</span><span class="special">&gt;</span> <span class="keyword">explicit</span> <span class="identifier">optional</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;&amp;&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_move_constructor_other_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">InPlaceFactory</span><span class="special">&gt;</span> <span class="keyword">explicit</span> <span class="identifier">optional</span> <span class="special">(</span> <span class="identifier">InPlaceFactory</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">f</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_constructor_factory"><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">TypedInPlaceFactory</span><span class="special">&gt;</span> <span class="keyword">explicit</span> <span class="identifier">optional</span> <span class="special">(</span> <span class="identifier">TypedInPlaceFactory</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">f</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_constructor_factory"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="identifier">optional</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</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="../boost_optional/reference/detailed_semantics.html#reference_optional_operator_equal_none_t"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="identifier">optional</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</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="../boost_optional/reference/detailed_semantics.html#reference_optional_operator_equal_value"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="identifier">optional</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</span> <span class="special">(</span> <span class="identifier">T</span><span class="special">&amp;&amp;</span> <span class="identifier">v</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_operator_move_equal_value"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="identifier">optional</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</span> <span class="special">(</span> <span class="identifier">optional</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_operator_equal_optional"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="identifier">optional</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&amp;&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="keyword">noexcept</span><span class="special">(</span><span class="emphasis"><em>see below</em></span><span class="special">)</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_operator_move_equal_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">U</span><span class="special">&gt;</span> <span class="identifier">optional</span><span class="special">&amp;</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">U</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_operator_equal_other_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">U</span><span class="special">&gt;</span> <span class="identifier">optional</span><span class="special">&amp;</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">U</span><span class="special">&gt;&amp;&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_operator_move_equal_other_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="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span> <span class="keyword">void</span> <span class="identifier">emplace</span> <span class="special">(</span> <span class="identifier">Args</span><span class="special">...&amp;&amp;</span> <span class="identifier">args</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_emplace"><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">InPlaceFactory</span><span class="special">&gt;</span> <span class="identifier">optional</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</span> <span class="special">(</span> <span class="identifier">InPlaceFactory</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">f</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_operator_equal_factory"><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">TypedInPlaceFactory</span><span class="special">&gt;</span> <span class="identifier">optional</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</span> <span class="special">(</span> <span class="identifier">TypedInPlaceFactory</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">f</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_operator_equal_factory"><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">&amp;</span> <span class="identifier">get</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/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="../boost_optional/reference/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="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="../boost_optional/reference/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="../boost_optional/reference/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="keyword">const</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">*()</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_operator_asterisk"><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="keyword">operator</span> <span class="special">*()</span> <span class="special">&amp;</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_operator_asterisk"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-    <span class="identifier">T</span><span class="special">&amp;&amp;</span>      <span class="keyword">operator</span> <span class="special">*()</span> <span class="special">&amp;&amp;</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_operator_asterisk_move"><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">&amp;</span> <span class="identifier">value</span><span class="special">()</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/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">&amp;</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/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;&amp;</span>      <span class="identifier">value</span><span class="special">()</span> <span class="special">&amp;&amp;</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_value_move"><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">&amp;</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_value_or"><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="special">&amp;&amp;</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_value_or_move"><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">F</span><span class="special">&gt;</span> <span class="identifier">T</span> <span class="identifier">value_or_eval</span><span class="special">(</span> <span class="identifier">F</span> <span class="identifier">f</span> <span class="special">)</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_value_or_call"><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">F</span><span class="special">&gt;</span> <span class="identifier">T</span> <span class="identifier">value_or_eval</span><span class="special">(</span> <span class="identifier">F</span> <span class="identifier">f</span> <span class="special">)</span> <span class="special">&amp;&amp;</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_value_or_call_move"><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="../boost_optional/reference/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="../boost_optional/reference/detailed_semantics.html#reference_optional_get_ptr"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="keyword">explicit</span> <span class="keyword">operator</span> <span class="keyword">bool</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_operator_bool"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_operator_not"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="comment">// deprecated methods</span>
-
-    <span class="comment">// (deprecated)</span>
-    <span class="keyword">void</span> <span class="identifier">reset</span><span class="special">()</span> <span class="keyword">noexcept</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_reset"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="comment">// (deprecated)</span>
-    <span class="keyword">void</span> <span class="identifier">reset</span> <span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_reset_value"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <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="../boost_optional/reference/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="../boost_optional/reference/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="../boost_optional/reference/detailed_semantics.html#reference_operator_compare_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">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="../boost_optional/reference/detailed_semantics.html#reference_operator_compare_not_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">&lt;</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="../boost_optional/reference/detailed_semantics.html#reference_operator_compare_less_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">&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="../boost_optional/reference/detailed_semantics.html#reference_operator_compare_greater_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">&lt;=</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="../boost_optional/reference/detailed_semantics.html#reference_operator_compare_less_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">&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="../boost_optional/reference/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="../boost_optional/reference/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="../boost_optional/reference/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="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="../boost_optional/reference/detailed_semantics.html#reference_make_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">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="../boost_optional/reference/detailed_semantics.html#reference_make_optional_bool_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_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="../boost_optional/reference/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="../boost_optional/reference/detailed_semantics.html#reference_optional_get"><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="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="special">&amp;</span> <span class="identifier">opt</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_get"><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">*</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">*</span> <span class="identifier">opt</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_get"><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="special">*</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="identifier">opt</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_get"><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">*</span> <span class="identifier">get_pointer</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="../boost_optional/reference/detailed_semantics.html#reference_optional_get_ptr"><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="special">*</span> <span class="identifier">get_pointer</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="special">&amp;</span> <span class="identifier">opt</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_optional_get_ptr"><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">void</span> <span class="identifier">swap</span><span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&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;&amp;</span> <span class="identifier">y</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../boost_optional/reference/detailed_semantics.html#reference_swap_optional_optional"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
+<span class="keyword">const</span> <span class="identifier">none_t</span> <span class="identifier">none</span> <span class="special">(/*</span> <span class="identifier">see</span> <span class="identifier">below</span> <span class="special">*/);</span>
 
 <span class="special">}</span> <span class="comment">// namespace boost</span>
 </pre>
+<p>
+        </p>
+<p>
+          Class <code class="computeroutput"><span class="identifier">none_t</span></code> is meant to
+          serve as a tag for selecting appropriate overloads of from <code class="computeroutput"><span class="identifier">optional</span></code>'s interface. It is an empty,
+          trivially copyable class with disabled default constructor.
+        </p>
+<p>
+          Constant <code class="computeroutput"><span class="identifier">none</span></code> is used to
+          indicate an optional object that does not contain a value in initialization,
+          assignment and relational operations of <code class="computeroutput"><span class="identifier">optional</span></code>.
+        </p>
+</div>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014 Andrzej Krzemie&#324;ski<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
@@ -181,7 +83,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="../boost_optional/tutorial/type_requirements.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../boost_optional/reference/detailed_semantics.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="../boost_optional/tutorial/performance_considerations.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../boost_optional/reference/header__boost_optional_bad_optional_access_hpp_.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

doc/html/optional/reference/header__boost_optional_optional_hpp_.html

@@ -1,13 +1,13 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Synopsis</title>
+<title>Header &lt;boost/optional/optional.hpp&gt;</title>
 <link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
 <meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
-<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Optional">
-<link rel="up" href="../../optional/reference.html" title="Reference">
-<link rel="prev" href="../../optional/reference.html" title="Reference">
-<link rel="next" href="detailed_semantics.html" title="Detailed Semantics">
+<link rel="home" href="../../index.html" title="Boost.Optional">
+<link rel="up" href="../reference.html" title="Reference">
+<link rel="prev" href="../../boost_optional/reference/header__boost_optional_optional_fwd_hpp_.html" title="Header &lt;boost/optional/optional_fwd.hpp&gt;">
+<link rel="next" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html" title="Detailed Semantics">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -20,147 +20,158 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="../../optional/reference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../optional/reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="detailed_semantics.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="../../boost_optional/reference/header__boost_optional_optional_fwd_hpp_.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_optional.reference.synopsis"></a><a class="link" href="synopsis.html" title="Synopsis">Synopsis</a>
+<a name="optional.reference.header__boost_optional_optional_hpp_"></a><a class="link" href="header__boost_optional_optional_hpp_.html" title="Header &lt;boost/optional/optional.hpp&gt;">Header
+      &lt;boost/optional/optional.hpp&gt;</a>
 </h3></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_optional.reference.header__boost_optional_optional_hpp_.header_optional_optional"></a><a name="ref_header_optional_optional_hpp"></a><a class="link" href="header__boost_optional_optional_hpp_.html#boost_optional.reference.header__boost_optional_optional_hpp_.header_optional_optional" title="Synopsis">Synopsis</a>
+</h4></div></div></div>
 <pre class="programlisting"><code class="computeroutput"><span class="comment">// In Header: &lt;</span></code><a href="../../../../../../boost/optional/optional.hpp" target="_top">boost/optional/optional.hpp</a><span class="comment">&gt;</span>
 
 <span class="keyword">namespace</span> <span class="identifier">boost</span> <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">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">class</span> <span class="identifier">optional</span>
 <span class="special">{</span>
-    <span class="keyword">public</span> <span class="special">:</span>
+<span class="keyword">public</span> <span class="special">:</span>
+
+    <span class="keyword">typedef</span> <span class="identifier">T</span> <span class="identifier">value_type</span><span class="special">;</span>
 
     <span class="comment">// (If T is of reference type, the parameters and results by reference are by value)</span>
 
-    <span class="identifier">optional</span> <span class="special">()</span> <span class="keyword">noexcept</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_constructor"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
+    <span class="identifier">optional</span> <span class="special">()</span> <span class="keyword">noexcept</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_constructor"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
 
-    <span class="identifier">optional</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_optional_constructor_none_t"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
+    <span class="identifier">optional</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="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_constructor_none_t"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
 
-    <span class="identifier">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_optional_constructor_value"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
+    <span class="identifier">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="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_constructor_value"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
 
-    <span class="identifier">optional</span> <span class="special">(</span> <span class="identifier">T</span><span class="special">&amp;&amp;</span> <span class="identifier">v</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_constructor_move_value"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
+    <span class="identifier">optional</span> <span class="special">(</span> <span class="identifier">T</span><span class="special">&amp;&amp;</span> <span class="identifier">v</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_constructor_move_value"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
 
     <span class="comment">// [new in 1.34]</span>
-    <span class="identifier">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_optional_constructor_bool_value"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
+    <span class="identifier">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="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_constructor_bool_value"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
 
-    <span class="identifier">optional</span> <span class="special">(</span> <span class="identifier">optional</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_constructor_optional"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
+    <span class="identifier">optional</span> <span class="special">(</span> <span class="identifier">optional</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_constructor_optional"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
 
-    <span class="identifier">optional</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&amp;&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="keyword">noexcept</span><span class="special">(</span><span class="emphasis"><em>see below</em></span><span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_move_constructor_optional"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
+    <span class="identifier">optional</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&amp;&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="keyword">noexcept</span><span class="special">(</span><span class="emphasis"><em>see below</em></span><span class="special">)</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_move_constructor_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">U</span><span class="special">&gt;</span> <span class="keyword">explicit</span> <span class="identifier">optional</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_constructor_other_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">U</span><span class="special">&gt;</span> <span class="keyword">explicit</span> <span class="identifier">optional</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_constructor_other_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">U</span><span class="special">&gt;</span> <span class="keyword">explicit</span> <span class="identifier">optional</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;&amp;&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_move_constructor_other_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">U</span><span class="special">&gt;</span> <span class="keyword">explicit</span> <span class="identifier">optional</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;&amp;&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_move_constructor_other_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">InPlaceFactory</span><span class="special">&gt;</span> <span class="keyword">explicit</span> <span class="identifier">optional</span> <span class="special">(</span> <span class="identifier">InPlaceFactory</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">f</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_constructor_factory"><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">InPlaceFactory</span><span class="special">&gt;</span> <span class="keyword">explicit</span> <span class="identifier">optional</span> <span class="special">(</span> <span class="identifier">InPlaceFactory</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">f</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_constructor_factory"><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">TypedInPlaceFactory</span><span class="special">&gt;</span> <span class="keyword">explicit</span> <span class="identifier">optional</span> <span class="special">(</span> <span class="identifier">TypedInPlaceFactory</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">f</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_constructor_factory"><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">TypedInPlaceFactory</span><span class="special">&gt;</span> <span class="keyword">explicit</span> <span class="identifier">optional</span> <span class="special">(</span> <span class="identifier">TypedInPlaceFactory</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">f</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_constructor_factory"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
 
-    <span class="identifier">optional</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</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_optional_operator_equal_none_t"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
+    <span class="identifier">optional</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</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="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_operator_equal_none_t"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
 
-    <span class="identifier">optional</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</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_optional_operator_equal_value"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
+    <span class="identifier">optional</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</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="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_operator_equal_value"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
 
-    <span class="identifier">optional</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</span> <span class="special">(</span> <span class="identifier">T</span><span class="special">&amp;&amp;</span> <span class="identifier">v</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_operator_move_equal_value"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
+    <span class="identifier">optional</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</span> <span class="special">(</span> <span class="identifier">T</span><span class="special">&amp;&amp;</span> <span class="identifier">v</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_operator_move_equal_value"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
 
-    <span class="identifier">optional</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</span> <span class="special">(</span> <span class="identifier">optional</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_operator_equal_optional"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
+    <span class="identifier">optional</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</span> <span class="special">(</span> <span class="identifier">optional</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_operator_equal_optional"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
 
-    <span class="identifier">optional</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&amp;&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="keyword">noexcept</span><span class="special">(</span><span class="emphasis"><em>see below</em></span><span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_operator_move_equal_optional"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
+    <span class="identifier">optional</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&amp;&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="keyword">noexcept</span><span class="special">(</span><span class="emphasis"><em>see below</em></span><span class="special">)</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_operator_move_equal_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">U</span><span class="special">&gt;</span> <span class="identifier">optional</span><span class="special">&amp;</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">U</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_operator_equal_other_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">U</span><span class="special">&gt;</span> <span class="identifier">optional</span><span class="special">&amp;</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">U</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_operator_equal_other_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">U</span><span class="special">&gt;</span> <span class="identifier">optional</span><span class="special">&amp;</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">U</span><span class="special">&gt;&amp;&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_operator_move_equal_other_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">U</span><span class="special">&gt;</span> <span class="identifier">optional</span><span class="special">&amp;</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">U</span><span class="special">&gt;&amp;&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_operator_move_equal_other_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="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span> <span class="keyword">void</span> <span class="identifier">emplace</span> <span class="special">(</span> <span class="identifier">Args</span><span class="special">...&amp;&amp;</span> <span class="identifier">args</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_emplace"><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="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span> <span class="keyword">void</span> <span class="identifier">emplace</span> <span class="special">(</span> <span class="identifier">Args</span><span class="special">...&amp;&amp;</span> <span class="identifier">args</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_emplace"><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">InPlaceFactory</span><span class="special">&gt;</span> <span class="identifier">optional</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</span> <span class="special">(</span> <span class="identifier">InPlaceFactory</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">f</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_operator_equal_factory"><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">InPlaceFactory</span><span class="special">&gt;</span> <span class="identifier">optional</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</span> <span class="special">(</span> <span class="identifier">InPlaceFactory</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">f</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_operator_equal_factory"><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">TypedInPlaceFactory</span><span class="special">&gt;</span> <span class="identifier">optional</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</span> <span class="special">(</span> <span class="identifier">TypedInPlaceFactory</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">f</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_operator_equal_factory"><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">TypedInPlaceFactory</span><span class="special">&gt;</span> <span class="identifier">optional</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</span> <span class="special">(</span> <span class="identifier">TypedInPlaceFactory</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">f</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_operator_equal_factory"><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">&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="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="../../boost_optional/reference/header__boost_optional_optional_hpp_/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="../../boost_optional/reference/header__boost_optional_optional_hpp_/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="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>
+    <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="../../boost_optional/reference/header__boost_optional_optional_hpp_/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="../../boost_optional/reference/header__boost_optional_optional_hpp_/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="keyword">const</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">*()</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_operator_asterisk"><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="keyword">operator</span> <span class="special">*()</span> <span class="special">&amp;;</span> <a class="link" href="detailed_semantics.html#reference_optional_operator_asterisk"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
-    <span class="identifier">T</span><span class="special">&amp;&amp;</span>      <span class="keyword">operator</span> <span class="special">*()</span> <span class="special">&amp;&amp;;</span> <a class="link" href="detailed_semantics.html#reference_optional_operator_asterisk"><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">&amp;</span> <span class="keyword">operator</span> <span class="special">*()</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_operator_asterisk"><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="keyword">operator</span> <span class="special">*()</span> <span class="special">&amp;</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_operator_asterisk"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
+    <span class="identifier">T</span><span class="special">&amp;&amp;</span>      <span class="keyword">operator</span> <span class="special">*()</span> <span class="special">&amp;&amp;</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_operator_asterisk_move"><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">&amp;</span> <span class="identifier">value</span><span class="special">()</span> <span class="keyword">const</span><span class="special">&amp;</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">&amp;</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;&amp;</span>      <span class="identifier">value</span><span class="special">()</span> <span class="special">&amp;&amp;</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="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">&amp;</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/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">&amp;</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/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;&amp;</span>      <span class="identifier">value</span><span class="special">()</span> <span class="special">&amp;&amp;</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_value_move"><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">&amp;</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="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="special">&amp;&amp;</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="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">&amp;</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_value_or"><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="special">&amp;&amp;</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_value_or_move"><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>
+    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">F</span><span class="special">&gt;</span> <span class="identifier">T</span> <span class="identifier">value_or_eval</span><span class="special">(</span> <span class="identifier">F</span> <span class="identifier">f</span> <span class="special">)</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_value_or_call"><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">F</span><span class="special">&gt;</span> <span class="identifier">T</span> <span class="identifier">value_or_eval</span><span class="special">(</span> <span class="identifier">F</span> <span class="identifier">f</span> <span class="special">)</span> <span class="special">&amp;&amp;</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_value_or_call_move"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
 
-    <span class="keyword">explicit</span> <span class="keyword">operator</span> <span class="keyword">bool</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_operator_bool"><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="../../boost_optional/reference/header__boost_optional_optional_hpp_/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="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_get_ptr"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
 
-    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_operator_not"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
+    <span class="keyword">explicit</span> <span class="keyword">operator</span> <span class="keyword">bool</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_operator_bool"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
+
+    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_operator_not"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
 
     <span class="comment">// deprecated methods</span>
 
     <span class="comment">// (deprecated)</span>
-    <span class="keyword">void</span> <span class="identifier">reset</span><span class="special">()</span> <span class="keyword">noexcept</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_reset"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
+    <span class="keyword">void</span> <span class="identifier">reset</span><span class="special">()</span> <span class="keyword">noexcept</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_reset"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
 
     <span class="comment">// (deprecated)</span>
-    <span class="keyword">void</span> <span class="identifier">reset</span> <span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_reset_value"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
+    <span class="keyword">void</span> <span class="identifier">reset</span> <span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_reset_value"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
 
     <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="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="../../boost_optional/reference/header__boost_optional_optional_hpp_/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="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="../../boost_optional/reference/header__boost_optional_optional_hpp_/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>
+<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="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_operator_compare_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">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_not_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">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="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_operator_compare_not_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">&lt;</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_less_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">&lt;</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="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_operator_compare_less_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">&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_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">&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="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_operator_compare_greater_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">&lt;=</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_less_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">&lt;=</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="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_operator_compare_less_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">&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">&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="../../boost_optional/reference/header__boost_optional_optional_hpp_/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="../../boost_optional/reference/header__boost_optional_optional_hpp_/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="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="../../boost_optional/reference/header__boost_optional_optional_hpp_/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="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="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="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_make_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">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="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="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_make_optional_bool_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_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_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="../../boost_optional/reference/header__boost_optional_optional_hpp_/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>
+<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="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_get"><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="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="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>
+<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="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="special">&amp;</span> <span class="identifier">opt</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_get"><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">*</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">*</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>
+<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">*</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">*</span> <span class="identifier">opt</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_get"><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="special">*</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="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>
+<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="special">*</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="identifier">opt</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_get"><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">*</span> <span class="identifier">get_pointer</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_ptr"><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">*</span> <span class="identifier">get_pointer</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="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_get_ptr"><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="special">*</span> <span class="identifier">get_pointer</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="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_ptr"><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="special">*</span> <span class="identifier">get_pointer</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="special">&amp;</span> <span class="identifier">opt</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_optional_get_ptr"><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">void</span> <span class="identifier">swap</span><span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&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;&amp;</span> <span class="identifier">y</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_swap_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">void</span> <span class="identifier">swap</span><span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&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;&amp;</span> <span class="identifier">y</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html#reference_swap_optional_optional"><span class="inlinemediaobject"><img src="../../images/callouts/R.png" alt="R"></span></a>
 
 <span class="special">}</span> <span class="comment">// namespace boost</span>
 </pre>
 </div>
+</div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014 Andrzej Krzemie&#324;ski<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
@@ -168,7 +179,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="../../optional/reference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../optional/reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="detailed_semantics.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="../../boost_optional/reference/header__boost_optional_optional_fwd_hpp_.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../../boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

doc/html/optional/tutorial.html

@@ -33,6 +33,7 @@
       use Optional</a></span></dt>
 <dt><span class="section"><a href="../boost_optional/tutorial/relational_operators.html">Relational
       operators</a></span></dt>
+<dt><span class="section"><a href="../boost_optional/tutorial/io_operators.html">IO operators</a></span></dt>
 <dt><span class="section"><a href="../boost_optional/tutorial/optional_references.html">Optional
       references</a></span></dt>
 <dt><span class="section"><a href="../boost_optional/tutorial/rebinding_semantics_for_assignment_of_optional_references.html">Rebinding
@@ -44,6 +45,8 @@
 <dt><span class="section"><a href="../boost_optional/tutorial/exception_safety_guarantees.html">Exception
       Safety Guarantees</a></span></dt>
 <dt><span class="section"><a href="../boost_optional/tutorial/type_requirements.html">Type requirements</a></span></dt>
+<dt><span class="section"><a href="../boost_optional/tutorial/performance_considerations.html">Performance
+      considerations</a></span></dt>
 </dl></div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -139,7 +142,7 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014 Andrzej Krzemie&#324;ski<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright &#169; 2014, 2015 Andrzej Krzemie&#324;ski<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>

include/boost/none.hpp

@@ -1,4 +1,5 @@
 // Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+// Copyright (C) 2014 Andrzej Krzemienski.
 //
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE_1_0.txt or copy at
@@ -20,9 +21,39 @@
 
 namespace boost {
 
+#ifdef BOOST_OPTIONAL_USE_OLD_DEFINITION_OF_NONE
+
 none_t const none = (static_cast<none_t>(0)) ;
 
+#elif defined BOOST_OPTIONAL_USE_SINGLETON_DEFINITION_OF_NONE
+
+namespace detail { namespace optional_detail {
+
+  // the trick here is to make boost::none defined once as a global but in a header file
+  template <typename T>
+  struct none_instance
+  {
+    static const T instance;
+  };
+  
+  template <typename T>
+  const T none_instance<T>::instance = T(); // global, but because 'tis a template, no cpp file required
+
+} } // namespace detail::optional_detail
+
+
+namespace {
+  // TU-local
+  const none_t& none = detail::optional_detail::none_instance<none_t>::instance; 
+}
+
+#else
+
+const none_t none ((none_t::init_tag()));
+
+#endif // older definitions
+
 } // namespace boost
 
-#endif
+#endif // header guard
 

include/boost/none_t.hpp

@@ -1,4 +1,5 @@
 // Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+// 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
@@ -14,11 +15,26 @@
 
 namespace boost {
 
-namespace detail { struct none_helper{}; }
+#ifdef BOOST_OPTIONAL_USE_OLD_DEFINITION_OF_NONE
 
+namespace detail { struct none_helper{}; }
 typedef int detail::none_helper::*none_t ;
 
+#elif defined BOOST_OPTIONAL_USE_SINGLETON_DEFINITION_OF_NONE
+
+class none_t {};
+
+#else
+
+struct none_t
+{
+  struct init_tag{};
+  explicit none_t(init_tag){} // to prevent default constructor
+};
+
+#endif // old implementation workarounds
+
 } // namespace boost
 
-#endif
+#endif // header guard
 

include/boost/optional/bad_optional_access.hpp

@@ -13,6 +13,9 @@
 #define BOOST_BAD_OPTIONAL_ACCESS_22MAY2014_HPP
 
 #include <stdexcept>
+#if __cplusplus < 201103L
+#include <string> // to make converting-ctor std::string(char const*) visible
+#endif
 
 namespace boost {
 

include/boost/optional/optional.hpp

@@ -1,5 +1,5 @@
 // Copyright (C) 2003, 2008 Fernando Luis Cacciola Carballal.
-// Copyright (C) 2014 Andrzej Krzemienski.
+// Copyright (C) 2014, 2015 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
@@ -18,12 +18,14 @@
 #define BOOST_OPTIONAL_OPTIONAL_FLC_19NOV2002_HPP
 
 #include <new>
-#include <algorithm>
 #include <iosfwd>
 
 #include <boost/config.hpp>
 #include <boost/assert.hpp>
+#include <boost/core/addressof.hpp>
+#include <boost/core/enable_if.hpp>
 #include <boost/core/explicit_operator_bool.hpp>
+#include <boost/core/swap.hpp>
 #include <boost/optional/bad_optional_access.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/throw_exception.hpp>
@@ -47,16 +49,14 @@
 #include <boost/detail/reference_content.hpp>
 #include <boost/move/utility.hpp>
 #include <boost/none.hpp>
-#include <boost/utility/addressof.hpp>
 #include <boost/utility/compare_pointees.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/utility/in_place_factory.hpp>
-#include <boost/utility/swap.hpp>
-
-
 
 #include <boost/optional/optional_fwd.hpp>
 
+#if (defined BOOST_NO_CXX11_RVALUE_REFERENCES) || (defined BOOST_OPTIONAL_CONFIG_NO_RVALUE_REFERENCES)
+#define BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+#endif
+
 #if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION,<=700)
 // AFAICT only Intel 7 correctly resolves the overload set
 // that includes the in-place factory taking functions,
@@ -148,7 +148,7 @@ struct types_when_isnt_ref
 {
   typedef T const& reference_const_type ;
   typedef T &      reference_type ;
-#ifndef  BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
   typedef T &&     rval_reference_type ;
   typedef T &&     reference_type_of_temporary_wrapper;
 #ifdef BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES
@@ -171,7 +171,7 @@ struct types_when_is_ref
 
   typedef raw_type&  reference_const_type ;
   typedef raw_type&  reference_type ;
-#ifndef  BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
   typedef BOOST_DEDUCED_TYPENAME remove_const<raw_type>::type&& rval_reference_type ;
   typedef raw_type&  reference_type_of_temporary_wrapper;
   static reference_type move(reference_type r) { return r; }
@@ -184,7 +184,7 @@ struct types_when_is_ref
 template <class To, class From>
 void prevent_binding_rvalue_ref_to_optional_lvalue_ref()
 {
-#ifndef BOOST_OPTIONAL_ALLOW_BINDING_TO_RVALUES
+#ifndef BOOST_OPTIONAL_CONFIG_ALLOW_BINDING_TO_RVALUES
   BOOST_STATIC_ASSERT_MSG(
     !boost::is_lvalue_reference<To>::value || !boost::is_rvalue_reference<From>::value, 
     "binding rvalue references to optional lvalue references is disallowed");
@@ -226,7 +226,7 @@ class optional_base : public optional_tag
   protected:
     typedef BOOST_DEDUCED_TYPENAME types::reference_type       reference_type ;
     typedef BOOST_DEDUCED_TYPENAME types::reference_const_type reference_const_type ;
-#ifndef  BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     typedef BOOST_DEDUCED_TYPENAME types::rval_reference_type  rval_reference_type ;
     typedef BOOST_DEDUCED_TYPENAME types::reference_type_of_temporary_wrapper reference_type_of_temporary_wrapper ;
 #endif
@@ -255,7 +255,7 @@ class optional_base : public optional_tag
       construct(val);
     }
 
-#ifndef  BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     // move-construct an optional<T> initialized from an rvalue-ref to 'val'.
     // Can throw if T::T(T&&) does
     optional_base ( rval_reference_type val )
@@ -286,7 +286,7 @@ class optional_base : public optional_tag
         construct(rhs.get_impl());
     }
 
-#ifndef  BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     // Creates a deep move of another optional<T>
     // Can throw if T::T(T&&) does
     optional_base ( optional_base&& rhs )
@@ -298,7 +298,7 @@ class optional_base : public optional_tag
     }
 #endif
 
-#ifndef  BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
 
     template<class Expr, class PtrExpr>
     explicit optional_base ( Expr&& expr, PtrExpr const* tag )
@@ -342,7 +342,7 @@ class optional_base : public optional_tag
       }
     }
     
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     // Assigns from another optional<T> (deep-moves the rhs value)
     void assign ( optional_base&& rhs )
     {
@@ -367,17 +367,26 @@ class optional_base : public optional_tag
       if (is_initialized())
       {
         if ( rhs.is_initialized() )
-             assign_value(static_cast<value_type>(rhs.get()), is_reference_predicate() );
+#ifndef BOOST_OPTIONAL_CONFIG_RESTORE_ASSIGNMENT_OF_NONCONVERTIBLE_TYPES
+          assign_value(rhs.get(), is_reference_predicate() );
+#else
+          assign_value(static_cast<value_type>(rhs.get()), is_reference_predicate() );
+#endif
+          
         else destroy();
       }
       else
       {
         if ( rhs.is_initialized() )
+#ifndef BOOST_OPTIONAL_CONFIG_RESTORE_ASSIGNMENT_OF_NONCONVERTIBLE_TYPES
+          construct(rhs.get());
+#else
           construct(static_cast<value_type>(rhs.get()));
+#endif
       }
     }
 
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     // move-assigns from another _convertible_ optional<U> (deep-moves from the rhs value)
     template<class U>
     void assign ( optional<U>&& rhs )
@@ -405,7 +414,7 @@ class optional_base : public optional_tag
       else construct(val);
     }
     
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     // Assigns from a T (deep-moves the rhs value)
     void assign ( rval_reference_type val )
     {
@@ -421,7 +430,7 @@ class optional_base : public optional_tag
 
 #ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
 
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     template<class Expr, class ExprPtr>
     void assign_expr ( Expr&& expr, ExprPtr const* tag )
     {
@@ -466,7 +475,7 @@ class optional_base : public optional_tag
        m_initialized = true ;
      }
      
-#ifndef  BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     void construct ( rval_reference_type val )
      {
        ::new (m_storage.address()) internal_type( types::move(val) ) ;
@@ -475,7 +484,7 @@ class optional_base : public optional_tag
 #endif
 
 
-#if (!defined BOOST_NO_CXX11_RVALUE_REFERENCES) && (!defined BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#if (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) && (!defined BOOST_NO_CXX11_VARIADIC_TEMPLATES)
     // Constructs in-place
     // upon exception *this is always uninitialized
     template<class... Args>
@@ -485,7 +494,7 @@ class optional_base : public optional_tag
        ::new (m_storage.address()) internal_type( boost::forward<Args>(args)... );
        m_initialized = true ;
      }
-#elif (!defined BOOST_NO_CXX11_RVALUE_REFERENCES)
+#elif (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES)
     template<class Arg>
     void emplace_assign ( Arg&& arg )
      {
@@ -493,6 +502,13 @@ class optional_base : public optional_tag
        ::new (m_storage.address()) internal_type( boost::forward<Arg>(arg) );
        m_initialized = true ;
      }
+     
+    void emplace_assign ()
+     {
+       destroy();
+       ::new (m_storage.address()) internal_type();
+       m_initialized = true ;
+     }
 #else
     template<class Arg>
     void emplace_assign ( const Arg& arg )
@@ -502,18 +518,25 @@ class optional_base : public optional_tag
        m_initialized = true ;
      }
      
-     template<class Arg>
+    template<class Arg>
     void emplace_assign ( Arg& arg )
      {
        destroy();
        ::new (m_storage.address()) internal_type( arg );
        m_initialized = true ;
      }
+     
+    void emplace_assign ()
+     {
+       destroy();
+       ::new (m_storage.address()) internal_type();
+       m_initialized = true ;
+     }
 #endif
 
 #ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
 
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     // Constructs in-place using the given factory
     template<class Expr>
     void construct ( Expr&& factory, in_place_factory_base const* )
@@ -584,7 +607,7 @@ class optional_base : public optional_tag
 
 #endif
 
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     // Constructs using any expression implicitly convertible to the single argument
     // of a one-argument T constructor.
     // Converting constructions of optional<T> from optional<U> uses this function with
@@ -642,7 +665,7 @@ class optional_base : public optional_tag
     // For VC<=70 compilers this workaround dosen't work becasue the comnpiler issues and error
     // instead of choosing the wrong overload
     //
-#ifndef  BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     // Notice that 'Expr' will be optional<T> or optional<U> (but not optional_base<..>)
     template<class Expr>
     void construct ( Expr&& expr, optional_tag const* )
@@ -673,7 +696,7 @@ class optional_base : public optional_tag
 
     void assign_value ( argument_type val, is_not_reference_tag ) { get_impl() = val; }
     void assign_value ( argument_type val, is_reference_tag     ) { construct(val); }
-#ifndef  BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     void assign_value ( rval_reference_type val, is_not_reference_tag ) { get_impl() = static_cast<rval_reference_type>(val); }
     void assign_value ( rval_reference_type val, is_reference_tag     ) { construct( static_cast<rval_reference_type>(val) ); }
 #endif
@@ -750,7 +773,7 @@ class optional : public optional_detail::optional_base<T>
     typedef BOOST_DEDUCED_TYPENAME base::value_type           value_type ;
     typedef BOOST_DEDUCED_TYPENAME base::reference_type       reference_type ;
     typedef BOOST_DEDUCED_TYPENAME base::reference_const_type reference_const_type ;
-#ifndef  BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     typedef BOOST_DEDUCED_TYPENAME base::rval_reference_type  rval_reference_type ;
     typedef BOOST_DEDUCED_TYPENAME base::reference_type_of_temporary_wrapper reference_type_of_temporary_wrapper ;
 #endif
@@ -770,7 +793,7 @@ class optional : public optional_detail::optional_base<T>
     // Can throw if T::T(T const&) does
     optional ( argument_type val ) : base(val) {}
 
-#ifndef  BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     // Creates an optional<T> initialized with 'move(val)'.
     // Can throw if T::T(T &&) does
     optional ( rval_reference_type val ) : base( boost::forward<T>(val) ) 
@@ -795,7 +818,7 @@ class optional : public optional_detail::optional_base<T>
         this->construct(rhs.get());
     }
     
-#ifndef  BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     // Creates a deep move of another convertible optional<U>
     // Requires a valid conversion from U to T.
     // Can throw if T::T(U&&) does
@@ -819,7 +842,7 @@ class optional : public optional_detail::optional_base<T>
     //       even though explicit overloads are present for these.
     // Depending on the above some T ctor is called.
     // Can throw if the resolved T ctor throws.
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
 
 
   template<class Expr>
@@ -834,14 +857,14 @@ class optional : public optional_detail::optional_base<T>
 #else
     template<class Expr>
     explicit optional ( Expr const& expr ) : base(expr,boost::addressof(expr)) {}
-#endif // !defined BOOST_NO_CXX11_RVALUE_REFERENCES
+#endif // !defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
 #endif // !defined BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
 
     // Creates a deep copy of another optional<T>
     // Can throw if T::T(T const&) does
     optional ( optional const& rhs ) : base( static_cast<base const&>(rhs) ) {}
 
-#ifndef  BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
 	// Creates a deep move of another optional<T>
 	// Can throw if T::T(T&&) does
 	optional ( optional && rhs ) 
@@ -856,7 +879,7 @@ class optional : public optional_detail::optional_base<T>
 #if !defined(BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT) && !defined(BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION)
     // Assigns from an expression. See corresponding constructor.
     // Basic Guarantee: If the resolved T ctor throws, this is left UNINITIALIZED
-#ifndef  BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
 
     template<class Expr>
     BOOST_DEDUCED_TYPENAME boost::disable_if_c<
@@ -878,7 +901,7 @@ class optional : public optional_detail::optional_base<T>
         this->assign_expr(expr,boost::addressof(expr));
         return *this ;
       }
-#endif // !defined  BOOST_NO_CXX11_RVALUE_REFERENCES
+#endif // !defined  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
 #endif // !defined(BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT) && !defined(BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION)
 
     // Copy-assigns from another convertible optional<U> (converts && deep-copies the rhs value)
@@ -891,7 +914,7 @@ class optional : public optional_detail::optional_base<T>
         return *this ;
       }
       
-#ifndef  BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     // Move-assigns from another convertible optional<U> (converts && deep-moves the rhs value)
     // Requires a valid conversion from U to T.
     // Basic Guarantee: If T::T( U && ) throws, this is left UNINITIALIZED
@@ -912,7 +935,7 @@ class optional : public optional_detail::optional_base<T>
         return *this ;
       }
 
-#ifndef  BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     // Assigns from another optional<T> (deep-moves the rhs value)
     optional& operator= ( optional && rhs ) 
 	  BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value && ::boost::is_nothrow_move_assignable<T>::value)
@@ -930,7 +953,7 @@ class optional : public optional_detail::optional_base<T>
         return *this ;
       }
 
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     // Assigns from a T (deep-moves the rhs value)
     optional& operator= ( rval_reference_type val )
       {
@@ -949,7 +972,7 @@ class optional : public optional_detail::optional_base<T>
         return *this ;
       }
       
-#if (!defined BOOST_NO_CXX11_RVALUE_REFERENCES) && (!defined BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#if (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) && (!defined BOOST_NO_CXX11_VARIADIC_TEMPLATES)
     // Constructs in-place
     // upon exception *this is always uninitialized
     template<class... Args>
@@ -957,12 +980,17 @@ class optional : public optional_detail::optional_base<T>
      {
        this->emplace_assign( boost::forward<Args>(args)... );
      }
-#elif (!defined BOOST_NO_CXX11_RVALUE_REFERENCES)
+#elif (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES)
     template<class Arg>
     void emplace ( Arg&& arg )
      {
        this->emplace_assign( boost::forward<Arg>(arg) );
      }
+     
+    void emplace ()
+     {
+       this->emplace_assign();
+     }
 #else
     template<class Arg>
     void emplace ( const Arg& arg )
@@ -975,6 +1003,11 @@ class optional : public optional_detail::optional_base<T>
      {
        this->emplace_assign( arg );
      }
+     
+    void emplace ()
+     {
+       this->emplace_assign();
+     }
 #endif
 
     void swap( optional & arg )
@@ -1004,16 +1037,16 @@ class optional : public optional_detail::optional_base<T>
     // Returns a reference to the value if this is initialized, otherwise,
     // the behaviour is UNDEFINED
     // No-throw
-#ifndef BOOST_NO_CXX11_REF_QUALIFIERS
+#if (!defined BOOST_NO_CXX11_REF_QUALIFIERS) && (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) 
     reference_const_type operator *() const& { return this->get() ; }
     reference_type       operator *() &      { return this->get() ; }
-    reference_type_of_temporary_wrapper operator *() && { return boost::move(this->get()) ; }
+    reference_type_of_temporary_wrapper operator *() && { return base::types::move(this->get()) ; }
 #else
     reference_const_type operator *() const { return this->get() ; }
     reference_type       operator *()       { return this->get() ; }
 #endif // !defined BOOST_NO_CXX11_REF_QUALIFIERS
 
-#ifndef BOOST_NO_CXX11_REF_QUALIFIERS
+#if (!defined BOOST_NO_CXX11_REF_QUALIFIERS) && (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) 
     reference_const_type value() const&
       { 
         if (this->is_initialized())
@@ -1033,7 +1066,7 @@ class optional : public optional_detail::optional_base<T>
     reference_type_of_temporary_wrapper value() &&
       { 
         if (this->is_initialized())
-          return boost::move(this->get()) ;
+          return base::types::move(this->get()) ;
         else
           throw_exception(bad_optional_access());
       }
@@ -1071,11 +1104,11 @@ class optional : public optional_detail::optional_base<T>
     value_type value_or ( U&& v ) && 
       { 
         if (this->is_initialized())
-          return boost::move(get());
+          return base::types::move(get());
         else
           return boost::forward<U>(v);
       }
-#elif !defined BOOST_NO_CXX11_RVALUE_REFERENCES
+#elif !defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     template <class U>
     value_type value_or ( U&& v ) const 
       {
@@ -1093,6 +1126,15 @@ class optional : public optional_detail::optional_base<T>
         else
           return v;
       }
+      
+    template <class U>
+    value_type value_or ( U& v ) const 
+      { 
+        if (this->is_initialized())
+          return get();
+        else
+          return v;
+      }
 #endif
 
 
@@ -1110,7 +1152,7 @@ class optional : public optional_detail::optional_base<T>
     value_type value_or_eval ( F f ) &&
       {
         if (this->is_initialized())
-          return boost::move(get());
+          return base::types::move(get());
         else
           return f();
       }
@@ -1130,7 +1172,7 @@ class optional : public optional_detail::optional_base<T>
     BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()
 } ;
 
-#ifndef  BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
 template<class T>
 class optional<T&&>
 {
@@ -1226,10 +1268,14 @@ get_pointer ( optional<T>& opt )
   return opt.get_ptr() ;
 }
 
-// Forward declaration to prevent operator safe-bool from being used.
-template<class CharType, class CharTrait, class T>
+// The following declaration prevents a bug where operator safe-bool is used upon streaming optional object if you forget the IO header.
+template<class CharType, class CharTrait>
 std::basic_ostream<CharType, CharTrait>&
-operator<<(std::basic_ostream<CharType, CharTrait>& out, optional<T> const& v);
+operator<<(std::basic_ostream<CharType, CharTrait>& os, optional_detail::optional_tag const&)
+{
+  BOOST_STATIC_ASSERT_MSG(sizeof(CharType) == 0, "If you want to output boost::optional, include header <boost/optional/optional_io.hpp>");
+  return os;  
+}
 
 // optional's relational operators ( ==, !=, <, >, <=, >= ) have deep-semantics (compare values).
 // WARNING: This is UNLIKE pointers. Use equal_pointees()/less_pointess() in generic code instead.
@@ -1423,9 +1469,9 @@ struct swap_selector<true>
             return;
 
         if( !hasX )
-            x = boost::in_place();
+            x.emplace();
         else if ( !hasY )
-            y = boost::in_place();
+            y.emplace();
 
         // Boost.Utility.Swap will take care of ADL and workarounds for broken compilers
         boost::swap(x.get(),y.get());
@@ -1437,7 +1483,7 @@ struct swap_selector<true>
     }
 };
 
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
 template<>
 struct swap_selector<false>
 {
@@ -1494,13 +1540,22 @@ struct swap_selector<false>
         }
     }
 };
-#endif // !defined BOOST_NO_CXX11_RVALUE_REFERENCES
+#endif // !defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
 
 } // namespace optional_detail
 
+#if (!defined BOOST_NO_CXX11_RVALUE_REFERENCES) && (!defined BOOST_CONFIG_RESTORE_OBSOLETE_SWAP_IMPLEMENTATION)
+
+template<class T>
+struct optional_swap_should_use_default_constructor : boost::false_type {} ;
+
+#else
+
 template<class T>
 struct optional_swap_should_use_default_constructor : has_nothrow_default_constructor<T> {} ;
 
+#endif //BOOST_NO_CXX11_RVALUE_REFERENCES
+
 template<class T> inline void swap ( optional<T>& x, optional<T>& y )
   //BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value && BOOST_NOEXCEPT_EXPR(boost::swap(*x, *y)))
 {

include/boost/optional/optional_io.hpp

@@ -15,22 +15,34 @@
 #include <istream>
 #include <ostream>
 
-#include <boost/none.hpp>
-#include <boost/assert.hpp>
+#include "boost/none.hpp"
 #include "boost/optional/optional.hpp"
-#include "boost/utility/value_init.hpp"
+
 
 namespace boost
 {
 
+template<class CharType, class CharTrait>
+inline
+std::basic_ostream<CharType, CharTrait>&
+operator<<(std::basic_ostream<CharType, CharTrait>& out, none_t)
+{
+  if (out.good())
+  {
+    out << "--";
+  }
+   
+  return out;
+}
+
 template<class CharType, class CharTrait, class T>
 inline
 std::basic_ostream<CharType, CharTrait>&
 operator<<(std::basic_ostream<CharType, CharTrait>& out, optional<T> const& v)
 {
-  if ( out.good() )
+  if (out.good())
   {
-    if ( !v )
+    if (!v)
          out << "--" ;
     else out << ' ' << *v ;
   }
@@ -50,7 +62,11 @@ operator>>(std::basic_istream<CharType, CharTrait>& in, optional<T>& v)
     {
       T x;
       in >> x;
+#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+      v = boost::move(x);
+#else
       v = x;
+#endif
     }
     else
     {

meta/libraries.json

@@ -0,0 +1,16 @@
+{
+    "key": "optional",
+    "boost-version": "1.30.0",
+    "name": "Optional",
+    "authors": [
+        "Fernando Cacciola"
+    ],
+    "description": "A value-semantic, type-safe wrapper for representing 'optional' (or 'nullable') objects of a given type. An optional object may or may not contain a value of the underlying type.",
+    "category": [
+        "Data structures"
+    ],
+    "maintainers": [
+        "Fernando Cacciola <fernando_cacciola -at- ciudad.com.ar>",
+        "Andrzej Krzemienski <akrzemi1 -at- gmail.com>"
+    ]
+}

test/Jamfile.v2

@@ -1,15 +1,16 @@
-#  Boost.Optional Library test Jamfile
+# Boost.Optional Library test Jamfile
 #
-#  Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+# Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+# Copyright (C) 2014, 2015 Andrzej Krzemienski
 #
-#  This material is provided "as is", with absolutely no warranty expressed
-#  or implied. Any use is at your own risk.
+# 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)
 #
-#  Permission to use or copy this software for any purpose is hereby granted
-#  without fee, provided the above notices are retained on all copies.
-#  Permission to modify the code and to distribute modified code is granted,
-#  provided the above notices are retained, and a notice that the code was
-#  modified is included with the above copyright notice.
+# See http://www.boost.org/libs/optional for documentation.
+#
+# You are welcome to contact the author at:
+#  akrzemi1@gmail.com
 #
 
 import testing ;
@@ -17,15 +18,27 @@ import testing ;
 {
   test-suite optional :
     [ run optional_test.cpp ]
+    [ run optional_test_swap.cpp ]
+    [ run optional_test_conversions_from_U.cpp ]
     [ run optional_test_tie.cpp ]
-    [ run optional_test_ref.cpp ]
-    [ run optional_test_inplace.cpp ]
+    [ run optional_test_ref_assign_portable_minimum.cpp ]
+    [ run optional_test_ref_assign_mutable_int.cpp ]
+    [ run optional_test_ref_assign_const_int.cpp ]
+    [ run optional_test_ref_converting_ctor.cpp ]
+    [ run optional_test_ref_convert_assign_non_int.cpp ]
+    [ run optional_test_ref_convert_assign_mutable_int.cpp ]
+    [ run optional_test_ref_convert_assign_const_int.cpp ]
+    [ run optional_test_ref_portable_minimum.cpp ]
+    [ run optional_test_ref_move.cpp ]
+    [ run optional_test_inplace_factory.cpp ]
     [ run optional_test_io.cpp ]
     [ run optional_test_move.cpp ]
+    [ run optional_test_noexcept_move.cpp ]
     [ run optional_test_equals_none.cpp ]
     [ run optional_test_value_access.cpp ]
     [ run optional_test_emplace.cpp ]
     [ run optional_test_minimum_requirements.cpp ]
+    [ run optional_test_msvc_bug_workaround.cpp ]
     [ compile-fail optional_test_fail1.cpp ]
     [ compile-fail optional_test_fail3a.cpp ]
     [ compile-fail optional_test_fail3b.cpp ]
@@ -41,7 +54,11 @@ import testing ;
     [ compile-fail optional_test_ref_fail_init_from_Urefref.cpp ]
     [ compile-fail optional_test_ref_fail_assign_from_Trefref.cpp ]
     [ compile-fail optional_test_ref_fail_assign_from_Urefref.cpp ]
+    [ compile-fail optional_test_fail_convert_from_null.cpp ]
     [ compile-fail optional_test_fail_explicit_convert_in_value_or.cpp ]
     [ compile-fail optional_test_fail_explicit_convert_in_value_or_call.cpp ]
+    [ compile-fail optional_test_fail_io_without_io.cpp ]
+    [ compile-fail optional_test_fail_none_io_without_io.cpp ]
+    [ compile-fail optional_test_fail_convert_assign_of_enums.cpp ]
   ;
 }

test/optional_ref_assign_test_defs.hpp

@@ -0,0 +1,197 @@
+// 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
+
+#ifndef BOOST_OPTIONAL_TEST_OPTIONAL_REF_ASSIGN_TEST_DEFS_AK_07JAN2015_HPP
+#define BOOST_OPTIONAL_TEST_OPTIONAL_REF_ASSIGN_TEST_DEFS_AK_07JAN2015_HPP
+
+#include "boost/optional/optional.hpp"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#include "boost/core/addressof.hpp"
+#include "testable_classes.hpp"
+
+using boost::optional;
+using boost::none;
+using boost::addressof;
+
+template <typename T>
+void test_copy_assignment_for_const()
+{
+  const typename concrete_type_of<T>::type v(2);
+  optional<const T&> o;
+  o = optional<const T&>(v);
+  
+  BOOST_TEST(o);
+  BOOST_TEST(o != none);
+  BOOST_TEST(addressof(*o) == addressof(v));
+  BOOST_TEST(val(*o) == val(v));
+  BOOST_TEST(val(*o) == 2);
+}
+
+template <typename T>
+void test_copy_assignment_for_noconst_const()
+{
+  typename concrete_type_of<T>::type v(2);
+  optional<const T&> o;
+  o = optional<const T&>(v);
+  
+  BOOST_TEST(o);
+  BOOST_TEST(o != none);
+  BOOST_TEST(addressof(*o) == addressof(v));
+  BOOST_TEST(val(*o) == val(v));
+  BOOST_TEST(val(*o) == 2);
+  
+  val(v) = 9;
+  BOOST_TEST(addressof(*o) == addressof(v));
+  BOOST_TEST_EQ(val(*o), val(v));
+  BOOST_TEST_EQ(val(*o), 9);
+  BOOST_TEST_EQ(val(v), 9);
+}
+
+template <typename T>
+void test_copy_assignment_for()
+{
+  typename concrete_type_of<T>::type v(2);
+  optional<T&> o;
+  o = optional<T&>(v);
+  
+  BOOST_TEST(o);
+  BOOST_TEST(o != none);
+  BOOST_TEST(addressof(*o) == addressof(v));
+  BOOST_TEST(val(*o) == val(v));
+  BOOST_TEST(val(*o) == 2);
+  
+  val(v) = 9;
+  BOOST_TEST(addressof(*o) == addressof(v));
+  BOOST_TEST_EQ(val(*o), val(v));
+  BOOST_TEST_EQ(val(*o), 9);
+  BOOST_TEST_EQ(val(v), 9);
+  
+  val(*o) = 7;
+  BOOST_TEST(addressof(*o) == addressof(v));
+  BOOST_TEST_EQ(val(*o), val(v));
+  BOOST_TEST_EQ(val(*o), 7);
+  BOOST_TEST_EQ(val(v), 7);
+}
+
+template <typename T>
+void test_rebinding_assignment_semantics_const()
+{
+  const typename concrete_type_of<T>::type v(2), w(7);
+  optional<const T&> o(v);
+  
+  BOOST_TEST(o);
+  BOOST_TEST(addressof(*o) == addressof(v));
+  BOOST_TEST_EQ(val(*o), val(v));
+  BOOST_TEST_EQ(val(*o), 2);
+  
+  o = optional<const T&>(w);
+  BOOST_TEST_EQ(val(v), 2);
+  
+  BOOST_TEST(o);
+  BOOST_TEST(addressof(*o) != addressof(v));
+  BOOST_TEST_NE(val(*o), val(v));
+  BOOST_TEST_NE(val(*o), 2);
+  
+  BOOST_TEST(addressof(*o) == addressof(w));
+  BOOST_TEST_EQ(val(*o), val(w));
+  BOOST_TEST_EQ(val(*o), 7);
+}
+
+template <typename T>
+void test_rebinding_assignment_semantics_noconst_const()
+{
+  typename concrete_type_of<T>::type v(2), w(7);
+  optional<const T&> o(v);
+  
+  BOOST_TEST(o);
+  BOOST_TEST(addressof(*o) == addressof(v));
+  BOOST_TEST_EQ(val(*o), val(v));
+  BOOST_TEST_EQ(val(*o), 2);
+  
+  o = optional<const T&>(w);
+  BOOST_TEST_EQ(val(v), 2);
+  
+  BOOST_TEST(o);
+  BOOST_TEST(addressof(*o) != addressof(v));
+  BOOST_TEST_NE(val(*o), val(v));
+  BOOST_TEST_NE(val(*o), 2);
+  
+  BOOST_TEST(addressof(*o) == addressof(w));
+  BOOST_TEST_EQ(val(*o), val(w));
+  BOOST_TEST_EQ(val(*o), 7);
+}
+
+template <typename T>
+void test_rebinding_assignment_semantics()
+{
+  typename concrete_type_of<T>::type v(2), w(7);
+  optional<T&> o(v);
+  
+  BOOST_TEST(o);
+  BOOST_TEST(addressof(*o) == addressof(v));
+  BOOST_TEST_EQ(val(*o), val(v));
+  BOOST_TEST_EQ(val(*o), 2);
+  
+  o = optional<T&>(w);
+  BOOST_TEST_EQ(val(v), 2);
+  
+  BOOST_TEST(o);
+  BOOST_TEST(addressof(*o) != addressof(v));
+  BOOST_TEST_NE(val(*o), val(v));
+  BOOST_TEST_NE(val(*o), 2);
+  
+  BOOST_TEST(addressof(*o) == addressof(w));
+  BOOST_TEST_EQ(val(*o), val(w));
+  BOOST_TEST_EQ(val(*o), 7);
+  
+  val(*o) = 8;
+  BOOST_TEST(addressof(*o) == addressof(w));
+  BOOST_TEST_EQ(val(*o), val(w));
+  BOOST_TEST_EQ(val(*o), 8);
+  BOOST_TEST_EQ(val(w), 8);
+  BOOST_TEST_EQ(val(v), 2);
+}
+
+template <typename T>
+void test_converting_assignment()
+{
+  typename concrete_type_of<T>::type v1(1), v2(2), v3(3);
+  optional<T&> oA(v1), oB(none);
+  
+  oA = v2;
+  BOOST_TEST(oA);
+  BOOST_TEST(addressof(*oA) == addressof(v2));
+  
+  oB = v3;
+  BOOST_TEST(oB);
+  BOOST_TEST(addressof(*oB) == addressof(v3));
+}
+
+template <typename T>
+void test_converting_assignment_for_noconst_const()
+{
+  typename concrete_type_of<T>::type v1(1), v2(2), v3(3);
+  optional<const T&> oA(v1), oB(none);
+  
+  oA = v2;
+  BOOST_TEST(oA);
+  BOOST_TEST(addressof(*oA) == addressof(v2));
+  
+  oB = v3;
+  BOOST_TEST(oB);
+  BOOST_TEST(addressof(*oB) == addressof(v3));
+}
+
+#endif //BOOST_OPTIONAL_TEST_OPTIONAL_REF_ASSIGN_TEST_DEFS_AK_07JAN2015_HPP
+

test/optional_test.cpp

@@ -30,7 +30,7 @@
 
 #include "boost/none.hpp"
 
-#include "boost/test/minimal.hpp"
+#include "boost/core/lightweight_test.hpp"
 
 #include "optional_test_common.cpp"
 
@@ -46,12 +46,12 @@ void test_implicit_construction ( optional<X> opt, X const& v, X const& z )
 
 void test_default_implicit_construction ( double, optional<double> opt )
 {
-  BOOST_CHECK(!opt);
+  BOOST_TEST(!opt);
 }
 
 void test_default_implicit_construction ( X const&, optional<X> opt )
 {
-  BOOST_CHECK(!opt);
+  BOOST_TEST(!opt);
 }
 
 //
@@ -188,65 +188,65 @@ void test_conditional_ctor_and_get_valur_or ( T const* )
   check_value(o1,a,z);
 
   T b = def0.get_value_or(z);
-  BOOST_CHECK( b == z ) ;
+  BOOST_TEST( b == z ) ;
 
   b = get_optional_value_or(def0,z);
-  BOOST_CHECK( b == z ) ;
+  BOOST_TEST( b == z ) ;
 
   b = o0.get_value_or(z);
-  BOOST_CHECK( b == a ) ;
+  BOOST_TEST( b == a ) ;
 
   b = get_optional_value_or(o0,z);
-  BOOST_CHECK( b == a ) ;
+  BOOST_TEST( b == a ) ;
 
 
   T const& crz = z ;
   T&        rz = z ;
 
   T const& crzz = def0.get_value_or(crz);
-  BOOST_CHECK( crzz == crz ) ;
+  BOOST_TEST( crzz == crz ) ;
 
   T& rzz = def0.get_value_or(rz);
-  BOOST_CHECK( rzz == rz ) ;
+  BOOST_TEST( rzz == rz ) ;
 
   T const& crzzz = get_optional_value_or(cdef0,crz);
-  BOOST_CHECK( crzzz == crz ) ;
+  BOOST_TEST( crzzz == crz ) ;
 
   T& rzzz = get_optional_value_or(def0,rz);
-  BOOST_CHECK( rzzz == rz ) ;
+  BOOST_TEST( rzzz == rz ) ;
 
   T const& crb = o0.get_value_or(crz);
-  BOOST_CHECK( crb == a ) ;
+  BOOST_TEST( crb == a ) ;
 
   T& rb = o0.get_value_or(rz);
-  BOOST_CHECK( rb == b ) ;
+  BOOST_TEST( rb == b ) ;
 
   T const& crbb = get_optional_value_or(co0,crz);
-  BOOST_CHECK( crbb == b ) ;
+  BOOST_TEST( crbb == b ) ;
 
   T const& crbbb = get_optional_value_or(o0,crz);
-  BOOST_CHECK( crbbb == b ) ;
+  BOOST_TEST( crbbb == b ) ;
 
   T& rbb = get_optional_value_or(o0,rz);
-  BOOST_CHECK( rbb == b ) ;
+  BOOST_TEST( rbb == b ) ;
 
   T& ra = a ;
 
   optional<T&> defref(false,ra);
-  BOOST_CHECK(!defref);
+  BOOST_TEST(!defref);
 
   optional<T&> ref(true,ra);
-  BOOST_CHECK(!!ref);
+  BOOST_TEST(!!ref);
 
   a = T(432);
 
-  BOOST_CHECK( *ref == a ) ;
+  BOOST_TEST( *ref == a ) ;
 
   T& r1 = defref.get_value_or(z);
-  BOOST_CHECK( r1 == z ) ;
+  BOOST_TEST( r1 == z ) ;
 
   T& r2 = ref.get_value_or(z);
-  BOOST_CHECK( r2 == a ) ;
+  BOOST_TEST( r2 == a ) ;
 }
 
 //
@@ -262,18 +262,18 @@ void test_direct_value_manip( T const* )
   optional<T> const c_opt0(x) ;
   optional<T>         opt0(x);
 
-  BOOST_CHECK( c_opt0.get().V() == x.V() ) ;
-  BOOST_CHECK(   opt0.get().V() == x.V() ) ;
+  BOOST_TEST( c_opt0.get().V() == x.V() ) ;
+  BOOST_TEST(   opt0.get().V() == x.V() ) ;
 
-  BOOST_CHECK( c_opt0->V() == x.V() ) ;
-  BOOST_CHECK(   opt0->V() == x.V() ) ;
+  BOOST_TEST( c_opt0->V() == x.V() ) ;
+  BOOST_TEST(   opt0->V() == x.V() ) ;
 
-  BOOST_CHECK( (*c_opt0).V() == x.V() ) ;
-  BOOST_CHECK( (*  opt0).V() == x.V() ) ;
+  BOOST_TEST( (*c_opt0).V() == x.V() ) ;
+  BOOST_TEST( (*  opt0).V() == x.V() ) ;
 
   T y(4);
   opt0 = y ;
-  BOOST_CHECK( get(opt0).V() == y.V() ) ;
+  BOOST_TEST( get(opt0).V() == y.V() ) ;
 }
 
 //
@@ -295,7 +295,7 @@ void test_uninitialized_access( T const* )
     passed = true ;
   }
   catch (...) {}
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);
 
   passed = false ;
   try
@@ -306,7 +306,7 @@ void test_uninitialized_access( T const* )
     passed = true ;
   }
   catch (...) {}
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);
 
   passed = false ;
   try
@@ -318,7 +318,7 @@ void test_uninitialized_access( T const* )
     passed = true ;
   }
   catch (...) {}
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);
 
   passed = false ;
   try
@@ -329,7 +329,7 @@ void test_uninitialized_access( T const* )
     passed = true ;
   }
   catch (...) {}
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);
 }
 
 #if BOOST_WORKAROUND( BOOST_INTEL_CXX_VERSION, <= 700) // Intel C++ 7.0
@@ -374,7 +374,7 @@ void test_throwing_direct_init( T const* )
   }
   catch ( ... ){}
 
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);
   check_is_not_pending_copy( ARG(T) );
   check_instance_count(count, ARG(T) );
 
@@ -410,7 +410,7 @@ void test_throwing_val_assign_on_uninitialized( T const* )
   }
   catch ( ... ) {}
 
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);
 
   check_is_not_pending_copy( ARG(T) );
   check_instance_count(count, ARG(T) );
@@ -456,7 +456,7 @@ void test_throwing_val_assign_on_initialized( T const* )
   }
   catch ( ... ) {}
 
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);
 
   check_is_not_pending_assign( ARG(T) );
   check_instance_count(count, ARG(T) );
@@ -495,7 +495,7 @@ void test_throwing_copy_initialization( T const* )
   }
   catch ( ... ) {}
 
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);
 
   check_is_not_pending_copy( ARG(T) );
   check_instance_count(count, ARG(T) );
@@ -538,7 +538,7 @@ void test_throwing_assign_to_uninitialized( T const* )
   }
   catch ( ... ) {}
 
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);
 
   check_is_not_pending_copy( ARG(T) );
   check_instance_count(count, ARG(T) );
@@ -581,7 +581,7 @@ void test_throwing_assign_to_initialized( T const* )
   }
   catch ( ... ) {}
 
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);
 
   // opt0 was left uninitialized
   check_is_not_pending_assign( ARG(T) );
@@ -661,7 +661,7 @@ void test_throwing_swap( T const* )
   }
   catch ( ... ) {}
 
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);
 
   // optional's swap doesn't affect the initialized states of the arguments. Therefore,
   // the following must hold:
@@ -692,7 +692,7 @@ void test_throwing_swap( T const* )
   }
   catch ( ... ) {}
 
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);
 
   check_uninitialized(opt0);
   check_initialized(opt1);
@@ -720,69 +720,69 @@ void test_relops( T const* )
   optional<T> opt2(v2);
 
   // Check identity
-  BOOST_CHECK ( def0 == def0 ) ;
-  BOOST_CHECK ( opt0 == opt0 ) ;
-  BOOST_CHECK ( !(def0 != def0) ) ;
-  BOOST_CHECK ( !(opt0 != opt0) ) ;
+  BOOST_TEST ( def0 == def0 ) ;
+  BOOST_TEST ( opt0 == opt0 ) ;
+  BOOST_TEST ( !(def0 != def0) ) ;
+  BOOST_TEST ( !(opt0 != opt0) ) ;
 
   // Check when both are uininitalized.
-  BOOST_CHECK (   def0 == def1  ) ; // both uninitialized compare equal
-  BOOST_CHECK ( !(def0 <  def1) ) ; // uninitialized is never less    than uninitialized
-  BOOST_CHECK ( !(def0 >  def1) ) ; // uninitialized is never greater than uninitialized
-  BOOST_CHECK ( !(def0 != def1) ) ;
-  BOOST_CHECK (   def0 <= def1  ) ;
-  BOOST_CHECK (   def0 >= def1  ) ;
+  BOOST_TEST (   def0 == def1  ) ; // both uninitialized compare equal
+  BOOST_TEST ( !(def0 <  def1) ) ; // uninitialized is never less    than uninitialized
+  BOOST_TEST ( !(def0 >  def1) ) ; // uninitialized is never greater than uninitialized
+  BOOST_TEST ( !(def0 != def1) ) ;
+  BOOST_TEST (   def0 <= def1  ) ;
+  BOOST_TEST (   def0 >= def1  ) ;
 
   // Check when only lhs is uninitialized.
-  BOOST_CHECK (   def0 != opt0  ) ; // uninitialized is never equal to initialized
-  BOOST_CHECK ( !(def0 == opt0) ) ;
-  BOOST_CHECK (   def0 <  opt0  ) ; // uninitialized is always less than initialized
-  BOOST_CHECK ( !(def0 >  opt0) ) ;
-  BOOST_CHECK (   def0 <= opt0  ) ;
-  BOOST_CHECK ( !(def0 >= opt0) ) ;
+  BOOST_TEST (   def0 != opt0  ) ; // uninitialized is never equal to initialized
+  BOOST_TEST ( !(def0 == opt0) ) ;
+  BOOST_TEST (   def0 <  opt0  ) ; // uninitialized is always less than initialized
+  BOOST_TEST ( !(def0 >  opt0) ) ;
+  BOOST_TEST (   def0 <= opt0  ) ;
+  BOOST_TEST ( !(def0 >= opt0) ) ;
 
   // Check when only rhs is uninitialized.
-  BOOST_CHECK (   opt0 != def0  ) ; // initialized is never equal to uninitialized
-  BOOST_CHECK ( !(opt0 == def0) ) ;
-  BOOST_CHECK ( !(opt0 <  def0) ) ; // initialized is never less than uninitialized
-  BOOST_CHECK (   opt0 >  def0  ) ;
-  BOOST_CHECK ( !(opt0 <= def0) ) ;
-  BOOST_CHECK (   opt0 >= opt0  ) ;
+  BOOST_TEST (   opt0 != def0  ) ; // initialized is never equal to uninitialized
+  BOOST_TEST ( !(opt0 == def0) ) ;
+  BOOST_TEST ( !(opt0 <  def0) ) ; // initialized is never less than uninitialized
+  BOOST_TEST (   opt0 >  def0  ) ;
+  BOOST_TEST ( !(opt0 <= def0) ) ;
+  BOOST_TEST (   opt0 >= opt0  ) ;
 
   // If both are initialized, values are compared
-  BOOST_CHECK ( opt0 != opt1 ) ;
-  BOOST_CHECK ( opt1 == opt2 ) ;
-  BOOST_CHECK ( opt0 <  opt1 ) ;
-  BOOST_CHECK ( opt1 >  opt0 ) ;
-  BOOST_CHECK ( opt1 <= opt2 ) ;
-  BOOST_CHECK ( opt1 >= opt0 ) ;
+  BOOST_TEST ( opt0 != opt1 ) ;
+  BOOST_TEST ( opt1 == opt2 ) ;
+  BOOST_TEST ( opt0 <  opt1 ) ;
+  BOOST_TEST ( opt1 >  opt0 ) ;
+  BOOST_TEST ( opt1 <= opt2 ) ;
+  BOOST_TEST ( opt1 >= opt0 ) ;
 
   // Compare against a value directly
-  BOOST_CHECK ( opt0 == v0 ) ;
-  BOOST_CHECK ( opt0 != v1 ) ;
-  BOOST_CHECK ( opt1 == v2 ) ;
-  BOOST_CHECK ( opt0 <  v1 ) ;
-  BOOST_CHECK ( opt1 >  v0 ) ;
-  BOOST_CHECK ( opt1 <= v2 ) ;
-  BOOST_CHECK ( opt1 >= v0 ) ;
-  BOOST_CHECK ( v0 != opt1 ) ;
-  BOOST_CHECK ( v1 == opt2 ) ;
-  BOOST_CHECK ( v0 <  opt1 ) ;
-  BOOST_CHECK ( v1 >  opt0 ) ;
-  BOOST_CHECK ( v1 <= opt2 ) ;
-  BOOST_CHECK ( v1 >= opt0 ) ;
-  BOOST_CHECK (   def0 != v0  ) ;
-  BOOST_CHECK ( !(def0 == v0) ) ;
-  BOOST_CHECK (   def0 <  v0  ) ;
-  BOOST_CHECK ( !(def0 >  v0) ) ;
-  BOOST_CHECK (   def0 <= v0  ) ;
-  BOOST_CHECK ( !(def0 >= v0) ) ;
-  BOOST_CHECK (   v0 != def0  ) ;
-  BOOST_CHECK ( !(v0 == def0) ) ;
-  BOOST_CHECK ( !(v0 <  def0) ) ;
-  BOOST_CHECK (   v0 >  def0  ) ;
-  BOOST_CHECK ( !(v0 <= def0) ) ;
-  BOOST_CHECK (   v0 >= opt0  ) ;
+  BOOST_TEST ( opt0 == v0 ) ;
+  BOOST_TEST ( opt0 != v1 ) ;
+  BOOST_TEST ( opt1 == v2 ) ;
+  BOOST_TEST ( opt0 <  v1 ) ;
+  BOOST_TEST ( opt1 >  v0 ) ;
+  BOOST_TEST ( opt1 <= v2 ) ;
+  BOOST_TEST ( opt1 >= v0 ) ;
+  BOOST_TEST ( v0 != opt1 ) ;
+  BOOST_TEST ( v1 == opt2 ) ;
+  BOOST_TEST ( v0 <  opt1 ) ;
+  BOOST_TEST ( v1 >  opt0 ) ;
+  BOOST_TEST ( v1 <= opt2 ) ;
+  BOOST_TEST ( v1 >= opt0 ) ;
+  BOOST_TEST (   def0 != v0  ) ;
+  BOOST_TEST ( !(def0 == v0) ) ;
+  BOOST_TEST (   def0 <  v0  ) ;
+  BOOST_TEST ( !(def0 >  v0) ) ;
+  BOOST_TEST (   def0 <= v0  ) ;
+  BOOST_TEST ( !(def0 >= v0) ) ;
+  BOOST_TEST (   v0 != def0  ) ;
+  BOOST_TEST ( !(v0 == def0) ) ;
+  BOOST_TEST ( !(v0 <  def0) ) ;
+  BOOST_TEST (   v0 >  def0  ) ;
+  BOOST_TEST ( !(v0 <= def0) ) ;
+  BOOST_TEST (   v0 >= opt0  ) ;
 }
 
 template<class T>
@@ -796,16 +796,16 @@ void test_none( T const* )
   optional<T> def1(none) ;
   optional<T> non_def( T(1234) ) ;
 
-  BOOST_CHECK ( def0    == none ) ;
-  BOOST_CHECK ( non_def != none ) ;
-  BOOST_CHECK ( !def1           ) ;
-  BOOST_CHECK ( !(non_def <  none) ) ;
-  BOOST_CHECK (   non_def >  none  ) ;
-  BOOST_CHECK ( !(non_def <= none) ) ;
-  BOOST_CHECK (   non_def >= none  ) ;
+  BOOST_TEST ( def0    == none ) ;
+  BOOST_TEST ( non_def != none ) ;
+  BOOST_TEST ( !def1           ) ;
+  BOOST_TEST ( !(non_def <  none) ) ;
+  BOOST_TEST (   non_def >  none  ) ;
+  BOOST_TEST ( !(non_def <= none) ) ;
+  BOOST_TEST (   non_def >= none  ) ;
 
   non_def = none ;
-  BOOST_CHECK ( !non_def ) ;
+  BOOST_TEST ( !non_def ) ;
 
   test_default_implicit_construction(T(1),none);
 }
@@ -820,12 +820,12 @@ void test_arrow( T const* )
   optional<T>        oa(a) ;
   optional<T> const coa(a) ;
 
-  BOOST_CHECK ( coa->V() == 1234 ) ;
+  BOOST_TEST ( coa->V() == 1234 ) ;
 
   oa->V() = 4321 ;
 
-  BOOST_CHECK (     a.V() = 1234 ) ;
-  BOOST_CHECK ( (*oa).V() = 4321 ) ;
+  BOOST_TEST (     a.V() = 1234 ) ;
+  BOOST_TEST ( (*oa).V() = 4321 ) ;
 }
 
 void test_with_builtin_types()
@@ -869,7 +869,7 @@ void test_with_class_type()
   test_relops( ARG(X) ) ;
   test_none( ARG(X) ) ;
   test_arrow( ARG(X) ) ;
-  BOOST_CHECK ( X::count == 0 ) ;
+  BOOST_TEST ( X::count == 0 ) ;
 }
 
 int eat ( bool ) { return 1 ; }
@@ -888,7 +888,7 @@ void test_no_implicit_conversions_impl( T const& )
   TRACE( std::endl << BOOST_CURRENT_FUNCTION   );
 
   optional<T> def ;
-  BOOST_CHECK ( eat(def) == 0 ) ;
+  BOOST_TEST ( eat(def) == 0 ) ;
 }
 
 void test_no_implicit_conversions()
@@ -906,375 +906,9 @@ void test_no_implicit_conversions()
   test_no_implicit_conversions_impl(p);
 }
 
-struct A {} ;
-void test_conversions1()
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION );
-
-#ifndef BOOST_OPTIONAL_NO_CONVERTING_COPY_CTOR
-  char c = 20 ;
-  optional<char> opt0(c);
-  optional<int> opt1(opt0);
-  BOOST_CHECK(*opt1 == static_cast<int>(c));
-#endif
-
-#ifndef BOOST_OPTIONAL_NO_CONVERTING_ASSIGNMENT
-  float f = 21.22f ;
-  double d = f ;
-  optional<float> opt2(f) ;
-  optional<double> opt3 ;
-  opt3 = opt2 ;
-  BOOST_CHECK(*opt3 == d);
-#endif
-}
-
-void test_conversions2()
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION );
-
-  char c = 20 ;
-  optional<int> opt(c);
-  BOOST_CHECK( get(opt) == static_cast<int>(c));
-
-  float f = 21.22f ;
-  optional<double> opt1;
-  opt1 = f ;
-  BOOST_CHECK(*get(&opt1) == static_cast<double>(f));
-}
-
-
-namespace optional_swap_test
-{
-  class default_ctor_exception : public std::exception {} ;
-  class copy_ctor_exception : public std::exception {} ;
-  class assignment_exception : public std::exception {} ;
-
-  //
-  // Base class for swap test classes.  Its assignment should not be called, when swapping
-  // optional<T> objects.  (The default std::swap would do so.)
-  //
-  class base_class_with_forbidden_assignment
-  {
-  public:
-    base_class_with_forbidden_assignment & operator=(const base_class_with_forbidden_assignment &)
-    {
-      BOOST_CHECK(!"The assignment should not be used while swapping!");
-      throw assignment_exception();
-    }
-
-    virtual ~base_class_with_forbidden_assignment() {}
-  };
-
-  //
-  // Class without default constructor
-  //
-  class class_without_default_ctor : public base_class_with_forbidden_assignment
-  {
-  public:
-    char data;
-    explicit class_without_default_ctor(char arg) : data(arg) {}
-  };
-
-  //
-  // Class whose default constructor should not be used by optional::swap!
-  //
-  class class_whose_default_ctor_should_not_be_used : public base_class_with_forbidden_assignment
-  {
-  public:
-    char data;
-    explicit class_whose_default_ctor_should_not_be_used(char arg) : data(arg) {}
-
-    class_whose_default_ctor_should_not_be_used()
-    {
-      BOOST_CHECK(!"This default constructor should not be used while swapping!");
-      throw default_ctor_exception();
-    }
-  };
-
-  //
-  // Class whose default constructor should be used by optional::swap.
-  // Its copy constructor should be avoided!
-  //
-  class class_whose_default_ctor_should_be_used : public base_class_with_forbidden_assignment
-  {
-  public:
-    char data;
-    explicit class_whose_default_ctor_should_be_used(char arg) : data(arg) { }
-
-    class_whose_default_ctor_should_be_used() : data('\0') { }
-
-    class_whose_default_ctor_should_be_used(const class_whose_default_ctor_should_be_used &)
-    {
-      BOOST_CHECK(!"This copy constructor should not be used while swapping!");
-      throw copy_ctor_exception();
-    }
-  };
-
-  //
-  // Class template whose default constructor should be used by optional::swap.
-  // Its copy constructor should be avoided!
-  //
-  template <class T>
-  class template_whose_default_ctor_should_be_used : public base_class_with_forbidden_assignment
-  {
-  public:
-    T data;
-    explicit template_whose_default_ctor_should_be_used(T arg) : data(arg) { }
-
-    template_whose_default_ctor_should_be_used() : data('\0') { }
-
-    template_whose_default_ctor_should_be_used(const template_whose_default_ctor_should_be_used &)
-    {
-      BOOST_CHECK(!"This copy constructor should not be used while swapping!");
-      throw copy_ctor_exception();
-    }
-  };
-
-  //
-  // Class whose explicit constructor should be used by optional::swap.
-  // Its other constructors should be avoided!
-  //
-  class class_whose_explicit_ctor_should_be_used : public base_class_with_forbidden_assignment
-  {
-  public:
-    char data;
-    explicit class_whose_explicit_ctor_should_be_used(char arg) : data(arg) { }
-
-    class_whose_explicit_ctor_should_be_used()
-    {
-      BOOST_CHECK(!"This default constructor should not be used while swapping!");
-      throw default_ctor_exception();
-    }
-
-    class_whose_explicit_ctor_should_be_used(const class_whose_explicit_ctor_should_be_used &)
-    {
-      BOOST_CHECK(!"This copy constructor should not be used while swapping!");
-      throw copy_ctor_exception();
-    }
-  };
-
-  void swap(class_whose_default_ctor_should_not_be_used & lhs, class_whose_default_ctor_should_not_be_used & rhs)
-  {
-    std::swap(lhs.data, rhs.data);
-  }
-
-  void swap(class_whose_default_ctor_should_be_used & lhs, class_whose_default_ctor_should_be_used & rhs)
-  {
-    std::swap(lhs.data, rhs.data);
-  }
-
-  void swap(class_without_default_ctor & lhs, class_without_default_ctor & rhs)
-  {
-    std::swap(lhs.data, rhs.data);
-  }
-
-  void swap(class_whose_explicit_ctor_should_be_used & lhs, class_whose_explicit_ctor_should_be_used & rhs)
-  {
-    std::swap(lhs.data, rhs.data);
-  }
-
-  template <class T>
-  void swap(template_whose_default_ctor_should_be_used<T> & lhs, template_whose_default_ctor_should_be_used<T> & rhs)
-  {
-    std::swap(lhs.data, rhs.data);
-  }
-
-  //
-  // optional<T>::swap should be customized when neither the copy constructor
-  // nor the default constructor of T are supposed to be used when swapping, e.g.,
-  // for the following type T = class_whose_explicit_ctor_should_be_used.
-  //
-  void swap(boost::optional<class_whose_explicit_ctor_should_be_used> & x, boost::optional<class_whose_explicit_ctor_should_be_used> & y)
-  {
-    bool hasX(x);
-    bool hasY(y);
-
-    if ( !hasX && !hasY )
-     return;
-
-    if( !hasX )
-       x = boost::in_place('\0');
-    else if ( !hasY )
-       y = boost::in_place('\0');
-
-    optional_swap_test::swap(*x,*y);
-
-     if( !hasX )
-         y = boost::none ;
-     else if( !hasY )
-         x = boost::none ;
-  }
-
-
-} // End of namespace optional_swap_test.
-
-
-namespace boost {
-
-//
-// Compile time tweaking on whether or not swap should use the default constructor:
-//
-
-template <> struct optional_swap_should_use_default_constructor<
-  optional_swap_test::class_whose_default_ctor_should_be_used> : mpl::true_ {} ;
-
-template <> struct optional_swap_should_use_default_constructor<
-  optional_swap_test::class_whose_default_ctor_should_not_be_used> : mpl::false_ {} ;
-
-template <class T> struct optional_swap_should_use_default_constructor<
-  optional_swap_test::template_whose_default_ctor_should_be_used<T> > : mpl::true_ {} ;
-
-
-//
-// Specialization of boost::swap:
-//
-template <>
-void swap(optional<optional_swap_test::class_whose_explicit_ctor_should_be_used> & x, optional<optional_swap_test::class_whose_explicit_ctor_should_be_used> & y)
-{
-  optional_swap_test::swap(x, y);
-}
-
-} // namespace boost
-
-
-namespace std {
-
-//
-// Specializations of std::swap:
-//
-
-template <>
-void swap(optional_swap_test::class_whose_default_ctor_should_be_used & x, optional_swap_test::class_whose_default_ctor_should_be_used & y)
-{
-  optional_swap_test::swap(x, y);
-}
-
-template <>
-void swap(optional_swap_test::class_whose_default_ctor_should_not_be_used & x, optional_swap_test::class_whose_default_ctor_should_not_be_used & y)
-{
-  optional_swap_test::swap(x, y);
-}
-
-template <>
-void swap(optional_swap_test::class_without_default_ctor & x, optional_swap_test::class_without_default_ctor & y)
-{
-  optional_swap_test::swap(x, y);
-}
-
-template <>
-void swap(optional_swap_test::class_whose_explicit_ctor_should_be_used & x, optional_swap_test::class_whose_explicit_ctor_should_be_used & y)
-{
-  optional_swap_test::swap(x, y);
-}
-
-} // namespace std
-
-
-//
-// Tests whether the swap function works properly for optional<T>.
-// Assumes that T has one data member, of type char.
-// Returns true iff the test is passed.
-//
-template <class T>
-bool test_swap_function( T const* )
-{
-  const boost::unit_test::counter_t counter_before_test = boost::minimal_test::errors_counter();
-  try
-  {
-    optional<T> obj1;
-    optional<T> obj2('a');
-
-    // Self-swap should not have any effect.
-    swap(obj1, obj1);
-    swap(obj2, obj2);
-    BOOST_CHECK(!obj1);
-    BOOST_CHECK(!!obj2 && obj2->data == 'a');
-
-    // Call non-member swap.
-    swap(obj1, obj2);
-
-    // Test if obj1 and obj2 are really swapped.
-    BOOST_CHECK(!!obj1 && obj1->data == 'a');
-    BOOST_CHECK(!obj2);
-
-    // Call non-member swap one more time.
-    swap(obj1, obj2);
-
-    // Test if obj1 and obj2 are swapped back.
-    BOOST_CHECK(!obj1);
-    BOOST_CHECK(!!obj2 && obj2->data == 'a');
-  }
-  catch(const std::exception &)
-  {
-    // The swap function should not throw, for our test cases.
-    return false ;
-  }
-  return boost::minimal_test::errors_counter() == counter_before_test ;
-}
-
-//
-// Tests whether the optional<T>::swap member function works properly.
-// Assumes that T has one data member, of type char.
-// Returns true iff the test is passed.
-//
-template <class T>
-bool test_swap_member_function( T const* )
-{
-  const boost::unit_test::counter_t counter_before_test = boost::minimal_test::errors_counter();
-  try
-  {
-    optional<T> obj1;
-    optional<T> obj2('a');
-
-    // Self-swap should not have any effect.
-    obj1.swap(obj1);
-    obj2.swap(obj2);
-    BOOST_CHECK(!obj1);
-    BOOST_CHECK(!!obj2 && obj2->data == 'a');
-
-    // Call member swap.
-    obj1.swap(obj2);
-
-    // Test if obj1 and obj2 are really swapped.
-    BOOST_CHECK(!!obj1 && obj1->data == 'a');
-    BOOST_CHECK(!obj2);
-
-    // Call member swap one more time.
-    obj1.swap(obj2);
-
-    // Test if obj1 and obj2 are swapped back.
-    BOOST_CHECK(!obj1);
-    BOOST_CHECK(!!obj2 && obj2->data == 'a');
-  }
-  catch(const std::exception &)
-  {
-    // The optional<T>::swap member function should not throw, for our test cases.
-    return false ;
-  }
-  return boost::minimal_test::errors_counter() == counter_before_test ;
-}
-
-
-//
-// Tests compile time tweaking of swap, by means of
-// optional_swap_should_use_default_constructor.
-//
-void test_swap_tweaking()
-{
-  BOOST_CHECK( test_swap_function( ARG(optional_swap_test::class_without_default_ctor) ) );
-  BOOST_CHECK( test_swap_function( ARG(optional_swap_test::class_whose_default_ctor_should_be_used) ) );
-  BOOST_CHECK( test_swap_function( ARG(optional_swap_test::class_whose_default_ctor_should_not_be_used) ) );
-  BOOST_CHECK( test_swap_function( ARG(optional_swap_test::class_whose_explicit_ctor_should_be_used) ) );
-  BOOST_CHECK( test_swap_function( ARG(optional_swap_test::template_whose_default_ctor_should_be_used<char>) ) );
-  BOOST_CHECK( test_swap_member_function( ARG(optional_swap_test::class_without_default_ctor) ) );
-  BOOST_CHECK( test_swap_member_function( ARG(optional_swap_test::class_whose_default_ctor_should_be_used) ) );
-  BOOST_CHECK( test_swap_member_function( ARG(optional_swap_test::class_whose_default_ctor_should_not_be_used) ) );
-  BOOST_CHECK( test_swap_member_function( ARG(optional_swap_test::class_whose_explicit_ctor_should_be_used) ) );
-  BOOST_CHECK( test_swap_member_function( ARG(optional_swap_test::template_whose_default_ctor_should_be_used<char>) ) );
-}
 
 // Test for support for classes with overridden operator&
-class CustomAddressOfClass
+class CustomAddressOfClass  
 {
     int n;
 
@@ -1289,27 +923,24 @@ public:
 void test_custom_addressof_operator()
 {
     boost::optional< CustomAddressOfClass > o1(CustomAddressOfClass(10));
-    BOOST_CHECK(!!o1);
-    BOOST_CHECK(o1.get() == CustomAddressOfClass(10));
+    BOOST_TEST(!!o1);
+    BOOST_TEST(o1.get() == CustomAddressOfClass(10));
 
     o1 = CustomAddressOfClass(20);
-    BOOST_CHECK(!!o1);
-    BOOST_CHECK(o1.get() == CustomAddressOfClass(20));
+    BOOST_TEST(!!o1);
+    BOOST_TEST(o1.get() == CustomAddressOfClass(20));
 
     o1 = boost::none;
-    BOOST_CHECK(!o1);
+    BOOST_TEST(!o1);
 }
 
-int test_main( int, char* [] )
+int main()
 {
   try
   {
     test_with_class_type();
     test_with_builtin_types();
     test_no_implicit_conversions();
-    test_conversions1();
-    test_conversions2();
-    test_swap_tweaking();
     test_custom_addressof_operator();
   }
   catch ( ... )
@@ -1317,7 +948,7 @@ int test_main( int, char* [] )
     BOOST_ERROR("Unexpected Exception caught!");
   }
 
-  return 0;
+  return boost::report_errors();
 }
 
 

test/optional_test_common.cpp

@@ -51,6 +51,8 @@ using boost::get_pointer ;
 // via the safe_bool operator.
 #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1300) ) // 1300 == VC++ 7.1
 #define BOOST_OPTIONAL_NO_NULL_COMPARE
+#else
+#define BOOST_OPTIONAL_NO_NULL_COMPARE  // Andrzej: I also disable 0 comparison everywhere
 #endif
 
 #define ARG(T) (static_cast< T const* >(0))
@@ -157,13 +159,13 @@ inline void set_throw_on_copy          ( X const* x ) { X::throw_on_copy = true
 inline void set_throw_on_assign        ( X const* x ) { X::throw_on_assign = true  ; }
 inline void reset_throw_on_copy        ( X const* x ) { X::throw_on_copy = false ; }
 inline void reset_throw_on_assign      ( X const* x ) { X::throw_on_assign = false ; }
-inline void check_is_pending_copy      ( X const* x ) { BOOST_CHECK( X::pending_copy ) ; }
-inline void check_is_pending_dtor      ( X const* x ) { BOOST_CHECK( X::pending_dtor ) ; }
-inline void check_is_pending_assign    ( X const* x ) { BOOST_CHECK( X::pending_assign ) ; }
-inline void check_is_not_pending_copy  ( X const* x ) { BOOST_CHECK( !X::pending_copy ) ; }
-inline void check_is_not_pending_dtor  ( X const* x ) { BOOST_CHECK( !X::pending_dtor ) ; }
-inline void check_is_not_pending_assign( X const* x ) { BOOST_CHECK( !X::pending_assign ) ; }
-inline void check_instance_count       ( int c, X const* x ) { BOOST_CHECK( X::count == c ) ; }
+inline void check_is_pending_copy      ( X const* x ) { BOOST_TEST( X::pending_copy ) ; }
+inline void check_is_pending_dtor      ( X const* x ) { BOOST_TEST( X::pending_dtor ) ; }
+inline void check_is_pending_assign    ( X const* x ) { BOOST_TEST( X::pending_assign ) ; }
+inline void check_is_not_pending_copy  ( X const* x ) { BOOST_TEST( !X::pending_copy ) ; }
+inline void check_is_not_pending_dtor  ( X const* x ) { BOOST_TEST( !X::pending_dtor ) ; }
+inline void check_is_not_pending_assign( X const* x ) { BOOST_TEST( !X::pending_assign ) ; }
+inline void check_instance_count       ( int c, X const* x ) { BOOST_TEST( X::count == c ) ; }
 inline int  get_instance_count         ( X const* x ) { return X::count ; }
 
 inline void set_pending_copy           (...) {}
@@ -187,21 +189,21 @@ template<class T>
 inline void check_uninitialized_const ( optional<T> const& opt )
 {
 #ifndef BOOST_OPTIONAL_NO_NULL_COMPARE
-  BOOST_CHECK( opt == 0 ) ;
+  BOOST_TEST( opt == 0 ) ;
 #endif
-  BOOST_CHECK( !opt ) ;
-  BOOST_CHECK( !get_pointer(opt) ) ;
-  BOOST_CHECK( !opt.get_ptr() ) ;
+  BOOST_TEST( !opt ) ;
+  BOOST_TEST( !get_pointer(opt) ) ;
+  BOOST_TEST( !opt.get_ptr() ) ;
 }
 template<class T>
 inline void check_uninitialized ( optional<T>& opt )
 {
 #ifndef BOOST_OPTIONAL_NO_NULL_COMPARE
-  BOOST_CHECK( opt == 0 ) ;
+  BOOST_TEST( opt == 0 ) ;
 #endif
-  BOOST_CHECK( !opt ) ;
-  BOOST_CHECK( !get_pointer(opt) ) ;
-  BOOST_CHECK( !opt.get_ptr() ) ;
+  BOOST_TEST( !opt ) ;
+  BOOST_TEST( !get_pointer(opt) ) ;
+  BOOST_TEST( !opt.get_ptr() ) ;
 
   check_uninitialized_const(opt);
 }
@@ -209,29 +211,29 @@ inline void check_uninitialized ( optional<T>& opt )
 template<class T>
 inline void check_initialized_const ( optional<T> const& opt )
 {
-  BOOST_CHECK( opt ) ;
+  BOOST_TEST( opt ) ;
 
 #ifndef BOOST_OPTIONAL_NO_NULL_COMPARE
-  BOOST_CHECK( opt != 0 ) ;
+  BOOST_TEST( opt != 0 ) ;
 #endif
 
-  BOOST_CHECK ( !!opt ) ;
-  BOOST_CHECK ( get_pointer(opt) ) ;
-  BOOST_CHECK ( opt.get_ptr() ) ;
+  BOOST_TEST ( !!opt ) ;
+  BOOST_TEST ( get_pointer(opt) ) ;
+  BOOST_TEST ( opt.get_ptr() ) ;
 }
 
 template<class T>
 inline void check_initialized ( optional<T>& opt )
 {
-  BOOST_CHECK( opt ) ;
+  BOOST_TEST( opt ) ;
 
 #ifndef BOOST_OPTIONAL_NO_NULL_COMPARE
-  BOOST_CHECK( opt != 0 ) ;
+  BOOST_TEST( opt != 0 ) ;
 #endif
 
-  BOOST_CHECK ( !!opt ) ;
-  BOOST_CHECK ( get_pointer(opt) ) ;
-  BOOST_CHECK ( opt.get_ptr() ) ;
+  BOOST_TEST ( !!opt ) ;
+  BOOST_TEST ( get_pointer(opt) ) ;
+  BOOST_TEST ( opt.get_ptr() ) ;
 
   check_initialized_const(opt);
 }
@@ -239,12 +241,12 @@ inline void check_initialized ( optional<T>& opt )
 template<class T>
 inline void check_value_const ( optional<T> const& opt, T const& v, T const& z )
 {
-  BOOST_CHECK( *opt == v ) ;
-  BOOST_CHECK( *opt != z ) ;
-  BOOST_CHECK( opt.get() == v ) ;
-  BOOST_CHECK( opt.get() != z ) ;
-  BOOST_CHECK( (*(opt.operator->()) == v) ) ;
-  BOOST_CHECK( *get_pointer(opt) == v ) ;
+  BOOST_TEST( *opt == v ) ;
+  BOOST_TEST( *opt != z ) ;
+  BOOST_TEST( opt.get() == v ) ;
+  BOOST_TEST( opt.get() != z ) ;
+  BOOST_TEST( (*(opt.operator->()) == v) ) ;
+  BOOST_TEST( *get_pointer(opt) == v ) ;
 }
 
 template<class T>
@@ -256,12 +258,12 @@ inline void check_value ( optional<T>& opt, T const& v, T const& z )
   reset_throw_on_copy( ARG(T) ) ;
 #endif
 
-  BOOST_CHECK( *opt == v ) ;
-  BOOST_CHECK( *opt != z ) ;
-  BOOST_CHECK( opt.get() == v ) ;
-  BOOST_CHECK( opt.get() != z ) ;
-  BOOST_CHECK( (*(opt.operator->()) == v) ) ;
-  BOOST_CHECK( *get_pointer(opt) == v ) ;
+  BOOST_TEST( *opt == v ) ;
+  BOOST_TEST( *opt != z ) ;
+  BOOST_TEST( opt.get() == v ) ;
+  BOOST_TEST( opt.get() != z ) ;
+  BOOST_TEST( (*(opt.operator->()) == v) ) ;
+  BOOST_TEST( *get_pointer(opt) == v ) ;
 
   check_value_const(opt,v,z);
 }

test/optional_test_conversions_from_U.cpp

@@ -0,0 +1,111 @@
+// 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"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#include "boost/core/lightweight_test.hpp"
+
+using boost::optional;
+
+
+// testing types:
+// X is convertible to Y
+// ADeriv is convertible to ABase
+struct X
+{
+  int val;
+  explicit X(int v) : val(v) {}
+};
+
+struct Y
+{
+  int yval;
+  Y(X const& x) : yval(x.val) {}
+  friend bool operator==(Y const& l, Y const& r) { return l.yval == r.yval; }
+};
+
+struct ABase
+{
+  int val;
+  explicit ABase(int v) : val(v) {}
+  friend bool operator==(ABase const& l, ABase const& r) { return l.val == r.val; }
+};
+
+struct ADeriv : ABase
+{
+    explicit ADeriv(int v) : ABase(v) {}
+};
+
+
+template <typename T, typename U>
+void test_convert_optional_U_to_optional_T_for()
+{
+#ifndef BOOST_OPTIONAL_NO_CONVERTING_COPY_CTOR
+  {
+    optional<U> ou(U(8));
+    optional<T> ot1(ou);
+    BOOST_TEST(ot1);
+    BOOST_TEST(*ot1 == T(*ou));
+  }
+#endif
+
+#ifndef BOOST_OPTIONAL_NO_CONVERTING_ASSIGNMENT
+  {
+    optional<U> ou(U(8));
+    optional<T> ot2;
+    ot2 = ou;
+    BOOST_TEST(ot2);
+    BOOST_TEST(*ot2 == T(*ou));
+  }
+#endif
+}
+
+void test_convert_optional_U_to_optional_T()
+{
+  test_convert_optional_U_to_optional_T_for<Y, X>();
+  test_convert_optional_U_to_optional_T_for<ABase, ADeriv>();
+  test_convert_optional_U_to_optional_T_for<long, short>();
+  test_convert_optional_U_to_optional_T_for<double, float>();
+}
+
+template <typename T, typename U>
+void test_convert_U_to_optional_T_for()
+{
+  U u(8);
+  optional<T> ot1(u);
+  BOOST_TEST(ot1);
+  BOOST_TEST(*ot1 == T(u));
+  
+  optional<T> ot2;
+  ot2 = u;
+  BOOST_TEST(ot2);
+  BOOST_TEST(*ot2 == T(u));
+}
+
+void test_convert_U_to_optional_T()
+{
+  test_convert_U_to_optional_T_for<Y, X>();
+  test_convert_U_to_optional_T_for<ABase, ADeriv>();
+  test_convert_U_to_optional_T_for<long, short>();
+  test_convert_U_to_optional_T_for<double, float>();
+}
+
+int main()
+{
+  test_convert_optional_U_to_optional_T();
+  test_convert_U_to_optional_T();
+  
+  return boost::report_errors();
+}

test/optional_test_emplace.cpp

@@ -8,19 +8,6 @@
 //
 // 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/static_assert.hpp"
 
 #include "boost/optional/optional.hpp"
 
@@ -28,15 +15,15 @@
 #pragma hdrstop
 #endif
 
+#include "boost/core/lightweight_test.hpp"
 #include "boost/none.hpp"
 
-#include "boost/test/minimal.hpp"
-
-#include "optional_test_common.cpp"
-
 //#ifndef BOOST_OPTIONAL_NO_CONVERTING_ASSIGNMENT
 //#ifndef BOOST_OPTIONAL_NO_CONVERTING_COPY_CTOR
 
+using boost::optional;
+using boost::none;
+
 #if (!defined BOOST_NO_CXX11_RVALUE_REFERENCES) && (!defined BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
 class Guard
@@ -68,36 +55,36 @@ void test_emplace()
     optional<Guard> o;
     
     o.emplace();
-    BOOST_CHECK(o);
-    BOOST_CHECK(0 == o->which_ctor);
+    BOOST_TEST(o);
+    BOOST_TEST(0 == o->which_ctor);
     
     o.emplace(i, 2.0);
-    BOOST_CHECK(o);
-    BOOST_CHECK(1 == o->which_ctor);
+    BOOST_TEST(o);
+    BOOST_TEST(1 == o->which_ctor);
     
     o.emplace(1, d);
-    BOOST_CHECK(o);
-    BOOST_CHECK(2 == o->which_ctor);
+    BOOST_TEST(o);
+    BOOST_TEST(2 == o->which_ctor);
     
     o.emplace(1, 2.0);
-    BOOST_CHECK(o);
-    BOOST_CHECK(3 == o->which_ctor);
+    BOOST_TEST(o);
+    BOOST_TEST(3 == o->which_ctor);
     
     o.emplace(i, d);
-    BOOST_CHECK(o);
-    BOOST_CHECK(4 == o->which_ctor);
+    BOOST_TEST(o);
+    BOOST_TEST(4 == o->which_ctor);
     
     o.emplace(cs);
-    BOOST_CHECK(o);
-    BOOST_CHECK(5 == o->which_ctor);
+    BOOST_TEST(o);
+    BOOST_TEST(5 == o->which_ctor);
     
     o.emplace(ms);
-    BOOST_CHECK(o);
-    BOOST_CHECK(6 == o->which_ctor);
+    BOOST_TEST(o);
+    BOOST_TEST(6 == o->which_ctor);
     
     o.emplace(std::string());
-    BOOST_CHECK(o);
-    BOOST_CHECK(7 == o->which_ctor);
+    BOOST_TEST(o);
+    BOOST_TEST(7 == o->which_ctor);
 }
 
 
@@ -119,10 +106,10 @@ void test_no_moves_on_emplacement()
     try {
         optional<ThrowOnMove> o;
         o.emplace(1);
-        BOOST_CHECK(o);
+        BOOST_TEST(o);
     } 
     catch (...) {
-        BOOST_CHECK(false);
+        BOOST_TEST(false);
     }
 }
 #endif
@@ -143,32 +130,68 @@ void test_clear_on_throw()
     optional<Thrower> ot;
     try {
         ot.emplace(false);
-        BOOST_CHECK(ot);
+        BOOST_TEST(ot);
     } catch(...) {
-        BOOST_CHECK(false);
+        BOOST_TEST(false);
     }
     
     try {
         ot.emplace(true);
-        BOOST_CHECK(false);
+        BOOST_TEST(false);
     } catch(...) {
-        BOOST_CHECK(!ot);
+        BOOST_TEST(!ot);
     }
 }
 
 void test_no_assignment_on_emplacement()
 {
-    optional<const std::string> os;
-    BOOST_CHECK(!os);
+    optional<const std::string> os, ot;
+    BOOST_TEST(!os);
     os.emplace("wow");
-    BOOST_CHECK(os);
-    BOOST_CHECK(*os == "wow");
+    BOOST_TEST(os);
+    BOOST_TEST_EQ(*os, "wow");
+    
+    BOOST_TEST(!ot);
+    ot.emplace();
+    BOOST_TEST(ot);
+    BOOST_TEST_EQ(*ot, "");
 }
 
-int test_main( int, char* [] )
+namespace no_rvalue_refs {
+class Guard
+{
+public:
+    int which_ctor;
+    Guard () : which_ctor(0) { }
+    Guard (std::string const&) : which_ctor(5) { }
+    Guard (std::string &) : which_ctor(6) { }
+private:
+    Guard(Guard const&);
+    void operator=(Guard const&);
+};
+
+void test_emplace()
+{
+    const std::string cs;
+    std::string ms;
+    optional<Guard> o;
+    
+    o.emplace();
+    BOOST_TEST(o);
+    BOOST_TEST(0 == o->which_ctor);
+    
+    o.emplace(cs);
+    BOOST_TEST(o);
+    BOOST_TEST(5 == o->which_ctor);
+    
+    o.emplace(ms);
+    BOOST_TEST(o);
+    BOOST_TEST(6 == o->which_ctor);
+}
+} 
+
+int main()
 {
-  try
-  {
 #if (!defined BOOST_NO_CXX11_RVALUE_REFERENCES) && (!defined BOOST_NO_CXX11_VARIADIC_TEMPLATES)
     test_emplace();
 #endif
@@ -177,13 +200,7 @@ int test_main( int, char* [] )
 #endif
     test_clear_on_throw();
     test_no_assignment_on_emplacement();
-  }
-  catch ( ... )
-  {
-    BOOST_ERROR("Unexpected Exception caught!");
-  }
-
-  return 0;
+    no_rvalue_refs::test_emplace();
+  
+    return boost::report_errors();
 }
-
-

test/optional_test_equals_none.cpp

@@ -8,18 +8,6 @@
 //
 // 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"
 
@@ -27,11 +15,9 @@
 #pragma hdrstop
 #endif
 
+#include "boost/core/lightweight_test.hpp"
 #include "boost/none.hpp"
 
-#include "boost/test/minimal.hpp"
-
-#include "optional_test_common.cpp"
 
 struct SemiRegular // no operator==
 { 
@@ -41,28 +27,17 @@ 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);
+  boost::optional<SemiRegular> i = SemiRegular();
+  boost::optional<SemiRegular> o;
+  
+  BOOST_TEST(i != boost::none);
+  BOOST_TEST(boost::none != i);
+  BOOST_TEST(o == boost::none);
+  BOOST_TEST(boost::none == o);
 }
 
-int test_main( int, char* [] )
+int main()
 {
-  try
-  {
-    test_equal_to_none_of_noncomparable_T();
-
-  }
-  catch ( ... )
-  {
-    BOOST_ERROR("Unexpected Exception caught!");
-  }
-
-  return 0;
+  test_equal_to_none_of_noncomparable_T();
+  return boost::report_errors();
 }
-
-

test/optional_test_fail_convert_assign_of_enums.cpp

@@ -0,0 +1,26 @@
+// Copyright (C) 2015, 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.hpp"
+
+// THIS TEST SHOULD FAIL TO COMPILE
+
+enum E1 {e1};
+enum E2 {e2};
+
+void test_converitng_assignment_of_different_enums()
+{
+  boost::optional<E2> o2(e2);
+  boost::optional<E1> o1;
+  o1 = o2;
+}
+
+int main() {}

test/optional_test_fail_convert_from_null.cpp

@@ -0,0 +1,25 @@
+// 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.hpp"
+
+//
+// THIS TEST SHOULD FAIL TO COMPILE
+//
+
+struct NoInitFromNull{};
+
+void test_conversion_from_null()
+{
+  boost::optional<NoInitFromNull> opt = 0;
+}
+
+

test/optional_test_fail_io_without_io.cpp

@@ -0,0 +1,24 @@
+// Copyright (C) 2015, 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 <iostream>
+#include "boost/optional.hpp"
+// but no boost/optional/optional_io.hpp
+
+// THIS TEST SHOULD FAIL TO COMPILE
+// Unless one includes header boost/optional/optional_io.hpp, it should not be possible
+// to stream out an optional object.
+
+void test_streaming_out_optional()
+{
+  boost::optional<int> opt;
+  std::cout << opt;
+}

test/optional_test_fail_none_io_without_io.cpp

@@ -0,0 +1,23 @@
+// Copyright (C) 2015, 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 <iostream>
+#include "boost/none.hpp"
+// but no boost/optional/optional_io.hpp
+
+// THIS TEST SHOULD FAIL TO COMPILE
+// Unless one includes header boost/optional/optional_io.hpp, it should not be possible
+// to stream out boost::none.
+
+void test_streaming_out_none()
+{
+  std::cout << boost::none;
+}

test/optional_test_inplace.cpp

@@ -1,84 +0,0 @@
-// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
-//
-// 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:
-//  fernando_cacciola@hotmail.com
-//
-#include<iostream>
-#include<stdexcept>
-#include<string>
-
-#define BOOST_ENABLE_ASSERT_HANDLER
-
-#include "boost/optional/optional.hpp"
-
-#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
-#include "boost/utility/in_place_factory.hpp"
-#include "boost/utility/typed_in_place_factory.hpp"
-#endif
-
-#ifdef __BORLANDC__
-#pragma hdrstop
-#endif
-
-#include "boost/test/minimal.hpp"
-
-#include "optional_test_common.cpp"
-
-#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
-struct A
-{
-  A ( double a0, std::string a1 ) : m_a0(a0), m_a1(a1) {}
-
-  friend bool operator == ( A const& x, A const& y )
-    { return x.m_a0 == y.m_a0 && x.m_a1 == y.m_a1 ; }
-
-  double      m_a0 ;
-  std::string m_a1 ;
-} ;
-
-int test_main( int, char* [] )
-{
-  double a00 = 3.14, a10 = 6.02e-23;
-  std::string a01("pi"), a11("mol");
-
-  A a0(a00,a01);
-  A a1(a10,a11);
-
-  boost::optional<A> opt1(a0);
-
-  boost::optional<A> opt2 ( boost::in_place(a00,a01) ) ;
-
-  boost::optional<A> opt3 ( boost::in_place<A>(a00,a01) ) ;
-
-  BOOST_CHECK( opt1 == opt2 ) ;
-  BOOST_CHECK( opt2 == opt2 ) ;
-  BOOST_CHECK( *opt2 == a0 ) ;
-
-#ifndef BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION
-
-  opt2 = boost::in_place(a10,a11);
-  BOOST_CHECK( *opt2 == a1 ) ;
-
-  opt3 = boost::in_place<A>(a10,a11);
-  BOOST_CHECK( *opt3 == a1 ) ;
-
-#endif
-
-  return 0;
-}
-#else
-int test_main( int, char* [] )
-{
-  // If in-place factories are not supported there is nothing to test
-  return 0 ;
-}
-#endif
-
-
-

test/optional_test_inplace_factory.cpp

@@ -0,0 +1,104 @@
+// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+// Copyright (C) 2015 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:
+//  fernando_cacciola@hotmail.com
+
+#include<string>
+#include "boost/optional/optional.hpp"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
+#include "boost/utility/in_place_factory.hpp"
+#include "boost/utility/typed_in_place_factory.hpp"
+#endif
+
+#include "boost/core/lightweight_test.hpp"
+#include "boost/none.hpp"
+
+struct Guard
+{
+  double num;
+  std::string str;
+  Guard() : num() {}
+  Guard(double num_, std::string str_) : num(num_), str(str_) {}
+  
+  friend bool operator==(const Guard& lhs, const Guard& rhs) { return lhs.num == rhs.num && lhs.str == rhs.str; }
+  friend bool operator!=(const Guard& lhs, const Guard& rhs) { return !(lhs == rhs); }
+  
+private:
+  Guard(const Guard&);
+  Guard& operator=(const Guard&);
+};
+
+void test_ctor()
+{
+#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
+  Guard g0, g1(1.0, "one"), g2(2.0, "two");
+  
+  boost::optional<Guard> og0 ( boost::in_place() );
+  boost::optional<Guard> og1 ( boost::in_place(1.0, "one") );
+  boost::optional<Guard> og1_( boost::in_place(1.0, "one") );
+  boost::optional<Guard> og2 ( boost::in_place<Guard>(2.0, "two") );
+  
+  BOOST_TEST(og0);
+  BOOST_TEST(og1);
+  BOOST_TEST(og1_);
+  BOOST_TEST(og2);
+  
+  BOOST_TEST(*og0  == g0);
+  BOOST_TEST(*og1  == g1);
+  BOOST_TEST(*og1_ == g1);
+  BOOST_TEST(*og2  == g2);
+  
+  BOOST_TEST(og1_ == og1);
+  BOOST_TEST(og1_ != og2);
+  BOOST_TEST(og1_ != og0);
+#endif 
+}
+
+void test_assign()
+{
+#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
+#ifndef BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION
+  Guard g0, g1(1.0, "one"), g2(2.0, "two");
+  
+  boost::optional<Guard> og0, og1, og1_, og2;
+  
+  og0  = boost::in_place();
+  og1  = boost::in_place(1.0, "one");
+  og1_ = boost::in_place(1.0, "one");
+  og2  = boost::in_place<Guard>(2.0, "two");
+  
+  BOOST_TEST(og0);
+  BOOST_TEST(og1);
+  BOOST_TEST(og1_);
+  BOOST_TEST(og2);
+  
+  BOOST_TEST(*og0  == g0);
+  BOOST_TEST(*og1  == g1);
+  BOOST_TEST(*og1_ == g1);
+  BOOST_TEST(*og2  == g2);
+  
+  BOOST_TEST(og1_ == og1);
+  BOOST_TEST(og1_ != og2);
+  BOOST_TEST(og1_ != og0);
+#endif
+#endif
+}
+
+int main()
+{
+  test_ctor();
+  test_assign();
+  return boost::report_errors();
+}

test/optional_test_inplace_fail.cpp

@@ -1,4 +1,5 @@
 // Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+// Copyright (C) 2015 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
@@ -8,53 +9,45 @@
 //
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com
-//
-#include<iostream>
-#include<stdexcept>
+
 #include<string>
-
-#define BOOST_ENABLE_ASSERT_HANDLER
-
 #include "boost/optional/optional.hpp"
 
-#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
-#include "boost/utility/in_place_factory.hpp"
-#endif
-
 #ifdef __BORLANDC__
 #pragma hdrstop
 #endif
 
-#include "boost/test/minimal.hpp"
-
-#include "optional_test_common.cpp"
-
 #ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
-struct A
-{
-  A ( double a0, std::string a1 ) : m_a0(a0), m_a1(a1) {}
-
-  friend bool operator == ( A const& x, A const& y )
-    { return x.m_a0 == y.m_a0 && x.m_a1 == y.m_a1 ; }
-
-  double      m_a0 ;
-  std::string m_a1 ;
-} ;
-
-int test_main( int, char* [] )
-{
-  int invalid_extra_parameter ;
-  boost::optional<A> opt2 ( boost::in_place(3.14,"pi",invalid_extra_parameter) ) ;
-
-  return 0;
-}
-#else
-int test_main( int, char* [] )
-{
-  int invalid_extra_parameter ;
-  boost::optional<A> opt2 ( A(3.14,"pi",invalid_extra_parameter) ) ;
-
-  return 0;
-}
+#include "boost/utility/in_place_factory.hpp"
+#include "boost/utility/typed_in_place_factory.hpp"
 #endif
 
+#include "boost/core/lightweight_test.hpp"
+#include "boost/none.hpp"
+
+struct Guard
+{
+  double num;
+  std::string str;
+  Guard() : num() {}
+  Guard(double num_, std::string str_) : num(num_), str(str_) {}
+  
+  friend bool operator==(const Guard& lhs, const Guard& rhs) { return lhs.num == rhs.num && lhs.str == rhs.str; }
+  friend bool operator!=(const Guard& lhs, const Guard& rhs) { return !(lhs == rhs); }
+  
+private:
+  Guard(const Guard&);
+  Guard& operator=(const Guard&);
+};
+
+
+int main()
+{
+#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
+  int excessive_param = 2;
+  boost::optional<Guard> og1 ( boost::in_place(1.0, "one", excessive_param) );
+#else
+  NOTHING_TO_TEST_SO_JUST_FAIL
+#endif
+  return 0;
+}

test/optional_test_inplace_fail2.cpp

@@ -1,4 +1,5 @@
 // Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+// Copyright (C) 2015 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
@@ -8,55 +9,45 @@
 //
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com
-//
-#include<iostream>
-#include<stdexcept>
+
 #include<string>
-
-#define BOOST_ENABLE_ASSERT_HANDLER
-
 #include "boost/optional/optional.hpp"
 
-#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
-#include "boost/utility/typed_in_place_factory.hpp"
-#endif
-
 #ifdef __BORLANDC__
 #pragma hdrstop
 #endif
 
-#include "boost/test/minimal.hpp"
-
-#include "optional_test_common.cpp"
-
 #ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
-struct A
-{
-  A ( double a0, std::string a1 ) : m_a0(a0), m_a1(a1) {}
-
-  friend bool operator == ( A const& x, A const& y )
-    { return x.m_a0 == y.m_a0 && x.m_a1 == y.m_a1 ; }
-
-  double      m_a0 ;
-  std::string m_a1 ;
-} ;
-
-int test_main( int, char* [] )
-{
-  // This must fail to compile.
-  // The first template argument to in_place<> is the target-type,
-  // not the first constructor parameter type.
-  boost::optional<A> opt2 ( boost::in_place<int>(3.14,"pi") ) ;
-
-  return 0;
-}
-#else
-int test_main( int, char* [] )
-{
-  boost::optional<A> opt2 ( int(3.14) ) ;
-
-  return 0;
-}
+#include "boost/utility/in_place_factory.hpp"
+#include "boost/utility/typed_in_place_factory.hpp"
 #endif
 
+#include "boost/core/lightweight_test.hpp"
+#include "boost/none.hpp"
 
+struct Guard
+{
+  double num;
+  std::string str;
+  Guard() : num() {}
+  Guard(double num_, std::string str_) : num(num_), str(str_) {}
+  
+  friend bool operator==(const Guard& lhs, const Guard& rhs) { return lhs.num == rhs.num && lhs.str == rhs.str; }
+  friend bool operator!=(const Guard& lhs, const Guard& rhs) { return !(lhs == rhs); }
+  
+private:
+  Guard(const Guard&);
+  Guard& operator=(const Guard&);
+};
+
+
+int main()
+{
+#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
+  typedef int BAD_TARGET_TYPE;
+  boost::optional<Guard> og1 ( boost::in_place<BAD_TARGET_TYPE>(1.0, "one") );
+#else
+  NOTHING_TO_TEST_SO_JUST_FAIL
+#endif
+  return 0;
+}

test/optional_test_io.cpp

@@ -1,4 +1,5 @@
 // Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+// 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
@@ -8,52 +9,24 @@
 //
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com
-//
-#include<stdexcept>
-#include<string>
-#include<sstream>
-
-#define BOOST_ENABLE_ASSERT_HANDLER
 
+#include <sstream>
 #include "boost/optional/optional.hpp"
 #include "boost/optional/optional_io.hpp"
-#include "boost/none.hpp"
 
-#include "boost/test/minimal.hpp"
-
-#ifdef ENABLE_TRACE
-#define TRACE(msg) std::cout << msg << std::endl ;
-#else
-#define TRACE(msg)
+#ifdef __BORLANDC__
+#pragma hdrstop
 #endif
 
-namespace boost {
+#include "boost/core/lightweight_test.hpp"
 
-void assertion_failed (char const * expr, char const * func, char const * file, long )
-{
-  using std::string ;
-  string msg =  string("Boost assertion failure for \"")
-               + string(expr)
-               + string("\" at file \"")
-               + string(file)
-               + string("\" function \"")
-               + string(func)
-               + string("\"") ;
-
-  TRACE(msg);
-
-  throw std::logic_error(msg);
-}
-
-}
-
-using namespace std ;
-using namespace boost ;
+using boost::optional;
+using boost::make_optional;
 
 template<class Opt>
 void test2( Opt o, Opt buff )
 {
-  stringstream s ;
+  std::stringstream s ;
 
   const int markv = 123 ;
   int mark = 0 ;
@@ -61,8 +34,8 @@ void test2( Opt o, Opt buff )
   s << o << " " << markv ;
   s >> buff >> mark ;
 
-  BOOST_ASSERT( buff == o ) ;
-  BOOST_ASSERT( mark == markv ) ;
+  BOOST_TEST( buff == o ) ;
+  BOOST_TEST( mark == markv ) ;
 }
 
 
@@ -75,18 +48,41 @@ void test( T v, T w )
   test2( optional<T>  () , make_optional(w));
 }
 
-int test_main( int, char* [] )
-{
-  try
-  {
-    test(1,2);
-    test(string("hello"),string("buffer"));
-  }
-  catch ( ... )
-  {
-    BOOST_ERROR("Unexpected Exception caught!");
-  }
 
-  return 0;
+template <class T>
+void subtest_tag_none_reversibility_with_optional(optional<T> ov)
+{
+  std::stringstream s;
+  s << boost::none;
+  s >> ov;
+  BOOST_TEST(!ov);
 }
 
+template <class T>
+void subtest_tag_none_equivalence_with_optional()
+{
+  std::stringstream s, r;
+  optional<T> ov;
+  s << boost::none;
+  r << ov;
+  BOOST_TEST_EQ(s.str(), r.str());
+}
+
+template <class T>
+void test_tag_none(T v)
+{
+  subtest_tag_none_reversibility_with_optional(optional<T>(v));
+  subtest_tag_none_reversibility_with_optional(optional<T>());
+  subtest_tag_none_equivalence_with_optional<T>();
+}
+
+
+int main()
+{
+  test(1,2);
+  test(std::string("hello"), std::string("buffer"));
+  test_tag_none(10);
+  test_tag_none(std::string("text"));
+
+  return boost::report_errors();
+}

test/optional_test_minimum_requirements.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2014 Andrzej Krzemienski.
+// Copyright (C) 2014-2015 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
@@ -8,19 +8,6 @@
 //
 // 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/static_assert.hpp"
 
 #include "boost/optional/optional.hpp"
 
@@ -28,12 +15,9 @@
 #pragma hdrstop
 #endif
 
+#include "boost/core/lightweight_test.hpp"
 #include "boost/none.hpp"
 
-#include "boost/test/minimal.hpp"
-
-#include "optional_test_common.cpp"
-
 class NonConstructible
 {
 private:
@@ -46,16 +30,10 @@ private:
 
 void test_non_constructible()
 {
-    optional<NonConstructible> o;
-    BOOST_CHECK(!o);
-    BOOST_CHECK(o == boost::none);
-    try { 
-        o.value();
-        BOOST_CHECK(false);
-    }
-    catch(...) {
-        BOOST_CHECK(true);
-    }
+  boost::optional<NonConstructible> o;
+  BOOST_TEST(!o);
+  BOOST_TEST(o == boost::none);
+  BOOST_TEST_THROWS(o.value(), boost::bad_optional_access);
 }
 
 class Guard
@@ -72,33 +50,26 @@ private:
 
 void test_guard()
 {
-    optional<Guard> o;
+    boost::optional<Guard> o;
     o.emplace(1);
-    BOOST_CHECK(o);
+    BOOST_TEST(o);
+    BOOST_TEST(o != boost::none);
 }
 
 void test_non_assignable()
 {
-    optional<const std::string> o;
+    boost::optional<const std::string> o;
     o.emplace("cat");
-    BOOST_CHECK(o);
-    BOOST_CHECK(*o == "cat");
+    BOOST_TEST(o);
+    BOOST_TEST(o != boost::none);
+    BOOST_TEST_EQ(*o, std::string("cat"));
 }
 
-int test_main( int, char* [] )
+int main()
 {
-  try
-  {
-    test_non_constructible();
-    test_guard();
-    test_non_assignable();
-  }
-  catch ( ... )
-  {
-    BOOST_ERROR("Unexpected Exception caught!");
-  }
-
-  return 0;
-}
-
+  test_non_constructible();
+  test_guard();
+  test_non_assignable();
 
+  return boost::report_errors();
+}

test/optional_test_move.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2014 Andrzej Krzemienski.
+// Copyright (C) 2014 - 2015 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
@@ -8,19 +8,7 @@
 //
 // 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/static_assert.hpp"
 
 #include "boost/optional/optional.hpp"
 
@@ -28,11 +16,10 @@
 #pragma hdrstop
 #endif
 
-#include "boost/none.hpp"
+#include "boost/core/lightweight_test.hpp"
 
-#include "boost/test/minimal.hpp"
-
-#include "optional_test_common.cpp"
+using boost::optional;
+using boost::none;
 
 //#ifndef BOOST_OPTIONAL_NO_CONVERTING_ASSIGNMENT
 //#ifndef BOOST_OPTIONAL_NO_CONVERTING_COPY_CTOR
@@ -86,37 +73,37 @@ bool operator!=( Oracle const& a, Oracle const& b ) { return a.val.i != b.val.i;
 void test_move_ctor_from_U()
 {
   optional<Oracle> o1 ((OracleVal()));
-  BOOST_CHECK(o1);
-  BOOST_CHECK(o1->s == sValueMoveConstructed || o1->s == sMoveConstructed);
+  BOOST_TEST(o1);
+  BOOST_TEST(o1->s == sValueMoveConstructed || o1->s == sMoveConstructed);
     
   OracleVal v1;
   optional<Oracle> o2 (v1);
-  BOOST_CHECK(o2);
-  BOOST_CHECK(o2->s == sValueCopyConstructed || o2->s == sCopyConstructed || o2->s == sMoveConstructed );
-  BOOST_CHECK(v1.s == sIntConstructed);
+  BOOST_TEST(o2);
+  BOOST_TEST(o2->s == sValueCopyConstructed || o2->s == sCopyConstructed || o2->s == sMoveConstructed );
+  BOOST_TEST(v1.s == sIntConstructed);
     
   optional<Oracle> o3 (boost::move(v1));
-  BOOST_CHECK(o3);
-  BOOST_CHECK(o3->s == sValueMoveConstructed || o3->s == sMoveConstructed);
-  BOOST_CHECK(v1.s == sMovedFrom);
+  BOOST_TEST(o3);
+  BOOST_TEST(o3->s == sValueMoveConstructed || o3->s == sMoveConstructed);
+  BOOST_TEST(v1.s == sMovedFrom);
 }
 
 void test_move_ctor_form_T()
 {
   optional<Oracle> o1 ((Oracle()));
-  BOOST_CHECK(o1);
-  BOOST_CHECK(o1->s == sMoveConstructed);
+  BOOST_TEST(o1);
+  BOOST_TEST(o1->s == sMoveConstructed);
   
   Oracle v1;
   optional<Oracle> o2 (v1);
-  BOOST_CHECK(o2);
-  BOOST_CHECK(o2->s == sCopyConstructed);
-  BOOST_CHECK(v1.s == sDefaultConstructed);
+  BOOST_TEST(o2);
+  BOOST_TEST(o2->s == sCopyConstructed);
+  BOOST_TEST(v1.s == sDefaultConstructed);
     
   optional<Oracle> o3 (boost::move(v1));
-  BOOST_CHECK(o3);
-  BOOST_CHECK(o3->s == sMoveConstructed);
-  BOOST_CHECK(v1.s == sMovedFrom);
+  BOOST_TEST(o3);
+  BOOST_TEST(o3->s == sMoveConstructed);
+  BOOST_TEST(v1.s == sMovedFrom);
 }
 
 void test_move_ctor_from_optional_T()
@@ -124,22 +111,22 @@ void test_move_ctor_from_optional_T()
   optional<Oracle> o1;
   optional<Oracle> o2(boost::move(o1));
   
-  BOOST_CHECK(!o1);
-  BOOST_CHECK(!o2);
+  BOOST_TEST(!o1);
+  BOOST_TEST(!o2);
   
   optional<Oracle> o3((Oracle()));
   optional<Oracle> o4(boost::move(o3));
-  BOOST_CHECK(o3);
-  BOOST_CHECK(o4);
-  BOOST_CHECK(o3->s == sMovedFrom);
-  BOOST_CHECK(o4->s == sMoveConstructed);
+  BOOST_TEST(o3);
+  BOOST_TEST(o4);
+  BOOST_TEST(o3->s == sMovedFrom);
+  BOOST_TEST(o4->s == sMoveConstructed);
   
   optional<Oracle> o5((optional<Oracle>()));
-  BOOST_CHECK(!o5);
+  BOOST_TEST(!o5);
   
   optional<Oracle> o6((optional<Oracle>(Oracle())));
-  BOOST_CHECK(o6);
-  BOOST_CHECK(o6->s == sMoveConstructed);
+  BOOST_TEST(o6);
+  BOOST_TEST(o6->s == sMoveConstructed);
   
   optional<Oracle> o7(o6); // does copy ctor from non-const lvalue compile?
 }
@@ -149,59 +136,59 @@ void test_move_assign_from_U()
   optional<Oracle> o1 = boost::none; // test if additional ctors didn't break it
   o1 = boost::none;                  // test if additional assignments didn't break it
   o1 = OracleVal();
-  BOOST_CHECK(o1);
+  BOOST_TEST(o1);
   
-  BOOST_CHECK(o1->s == sValueMoveConstructed);  
+  BOOST_TEST(o1->s == sValueMoveConstructed);  
   
   o1 = OracleVal();
-  BOOST_CHECK(o1);
-  BOOST_CHECK(o1->s == sMoveAssigned); 
+  BOOST_TEST(o1);
+  BOOST_TEST(o1->s == sMoveAssigned); 
     
   OracleVal v1;
   optional<Oracle> o2;
   o2 = v1;
-  BOOST_CHECK(o2);
-  BOOST_CHECK(o2->s == sValueCopyConstructed);
-  BOOST_CHECK(v1.s == sIntConstructed);
+  BOOST_TEST(o2);
+  BOOST_TEST(o2->s == sValueCopyConstructed);
+  BOOST_TEST(v1.s == sIntConstructed);
   o2 = v1;
-  BOOST_CHECK(o2);
-  BOOST_CHECK(o2->s == sCopyAssigned || o2->s == sMoveAssigned);
-  BOOST_CHECK(v1.s == sIntConstructed);
+  BOOST_TEST(o2);
+  BOOST_TEST(o2->s == sCopyAssigned || o2->s == sMoveAssigned);
+  BOOST_TEST(v1.s == sIntConstructed);
     
   optional<Oracle> o3;
   o3 = boost::move(v1);
-  BOOST_CHECK(o3);
-  BOOST_CHECK(o3->s == sValueMoveConstructed);
-  BOOST_CHECK(v1.s == sMovedFrom);
+  BOOST_TEST(o3);
+  BOOST_TEST(o3->s == sValueMoveConstructed);
+  BOOST_TEST(v1.s == sMovedFrom);
 }
 
 void test_move_assign_from_T()
 {
   optional<Oracle> o1;
   o1 = Oracle();
-  BOOST_CHECK(o1);
-  BOOST_CHECK(o1->s == sMoveConstructed);  
+  BOOST_TEST(o1);
+  BOOST_TEST(o1->s == sMoveConstructed);  
   
   o1 = Oracle();
-  BOOST_CHECK(o1);
-  BOOST_CHECK(o1->s == sMoveAssigned); 
+  BOOST_TEST(o1);
+  BOOST_TEST(o1->s == sMoveAssigned); 
     
   Oracle v1;
   optional<Oracle> o2;
   o2 = v1;
-  BOOST_CHECK(o2);
-  BOOST_CHECK(o2->s == sCopyConstructed);
-  BOOST_CHECK(v1.s == sDefaultConstructed);
+  BOOST_TEST(o2);
+  BOOST_TEST(o2->s == sCopyConstructed);
+  BOOST_TEST(v1.s == sDefaultConstructed);
   o2 = v1;
-  BOOST_CHECK(o2);
-  BOOST_CHECK(o2->s == sCopyAssigned);
-  BOOST_CHECK(v1.s == sDefaultConstructed);
+  BOOST_TEST(o2);
+  BOOST_TEST(o2->s == sCopyAssigned);
+  BOOST_TEST(v1.s == sDefaultConstructed);
     
   optional<Oracle> o3;
   o3 = boost::move(v1);
-  BOOST_CHECK(o3);
-  BOOST_CHECK(o3->s == sMoveConstructed);
-  BOOST_CHECK(v1.s == sMovedFrom);
+  BOOST_TEST(o3);
+  BOOST_TEST(o3->s == sMoveConstructed);
+  BOOST_TEST(v1.s == sMovedFrom);
 }
 
 void test_move_assign_from_optional_T()
@@ -209,23 +196,23 @@ void test_move_assign_from_optional_T()
     optional<Oracle> o1;
     optional<Oracle> o2;
     o1 = optional<Oracle>();
-    BOOST_CHECK(!o1);
+    BOOST_TEST(!o1);
     optional<Oracle> o3((Oracle()));
     o1 = o3;
-    BOOST_CHECK(o3);
-    BOOST_CHECK(o3->s == sMoveConstructed);
-    BOOST_CHECK(o1);
-    BOOST_CHECK(o1->s == sCopyConstructed);
+    BOOST_TEST(o3);
+    BOOST_TEST(o3->s == sMoveConstructed);
+    BOOST_TEST(o1);
+    BOOST_TEST(o1->s == sCopyConstructed);
     
     o2 = boost::move(o3);
-    BOOST_CHECK(o3);
-    BOOST_CHECK(o3->s == sMovedFrom);
-    BOOST_CHECK(o2);
-    BOOST_CHECK(o2->s == sMoveConstructed);
+    BOOST_TEST(o3);
+    BOOST_TEST(o3->s == sMovedFrom);
+    BOOST_TEST(o2);
+    BOOST_TEST(o2->s == sMoveConstructed);
     
     o2 = optional<Oracle>((Oracle()));
-    BOOST_CHECK(o2);
-    BOOST_CHECK(o2->s == sMoveAssigned);
+    BOOST_TEST(o2);
+    BOOST_TEST(o2->s == sMoveAssigned);
 }
 
 class MoveOnly
@@ -247,21 +234,21 @@ void test_with_move_only()
 {
     optional<MoveOnly> o1;
     optional<MoveOnly> o2((MoveOnly(1)));
-    BOOST_CHECK(o2);
-    BOOST_CHECK(o2->val == 1);
+    BOOST_TEST(o2);
+    BOOST_TEST(o2->val == 1);
     optional<MoveOnly> o3 (boost::move(o1));
-    BOOST_CHECK(!o3);
+    BOOST_TEST(!o3);
     optional<MoveOnly> o4 (boost::move(o2));
-    BOOST_CHECK(o4);
-    BOOST_CHECK(o4->val == 1);
-    BOOST_CHECK(o2);
-    BOOST_CHECK(o2->val == 0);
+    BOOST_TEST(o4);
+    BOOST_TEST(o4->val == 1);
+    BOOST_TEST(o2);
+    BOOST_TEST(o2->val == 0);
     
     o3 = boost::move(o4);
-    BOOST_CHECK(o3);
-    BOOST_CHECK(o3->val == 1);
-    BOOST_CHECK(o4);
-    BOOST_CHECK(o4->val == 0);
+    BOOST_TEST(o3);
+    BOOST_TEST(o3->val == 1);
+    BOOST_TEST(o4);
+    BOOST_TEST(o4->val == 0);
 }
 
 class MoveOnlyB
@@ -287,15 +274,15 @@ void test_move_assign_from_optional_U()
     optional<MoveOnlyB> b1;
     b1 = boost::move(a);
     
-    BOOST_CHECK(b1);
-    BOOST_CHECK(b1->val == 2);
-    BOOST_CHECK(a);
-    BOOST_CHECK(a->val == 0);
+    BOOST_TEST(b1);
+    BOOST_TEST(b1->val == 2);
+    BOOST_TEST(a);
+    BOOST_TEST(a->val == 0);
     
     b1 = MoveOnly(4);
     
-    BOOST_CHECK(b1);
-    BOOST_CHECK(b1->val == 4);
+    BOOST_TEST(b1);
+    BOOST_TEST(b1->val == 4);
 }
 
 void test_move_ctor_from_optional_U()
@@ -303,15 +290,15 @@ void test_move_ctor_from_optional_U()
     optional<MoveOnly> a((MoveOnly(2)));
     optional<MoveOnlyB> b1(boost::move(a));
     
-    BOOST_CHECK(b1);
-    BOOST_CHECK(b1->val == 2);
-    BOOST_CHECK(a);
-    BOOST_CHECK(a->val == 0);
+    BOOST_TEST(b1);
+    BOOST_TEST(b1->val == 2);
+    BOOST_TEST(a);
+    BOOST_TEST(a->val == 0);
     
     optional<MoveOnlyB> b2(( optional<MoveOnly>(( MoveOnly(4) )) ));
     
-    BOOST_CHECK(b2);
-    BOOST_CHECK(b2->val == 4);
+    BOOST_TEST(b2);
+    BOOST_TEST(b2->val == 4);
 }
 
 void test_swap()
@@ -320,8 +307,8 @@ void test_swap()
     optional<MoveOnly> b((MoveOnly(3)));
     swap(a, b);
     
-    BOOST_CHECK(a->val == 3);
-    BOOST_CHECK(b->val == 2);
+    BOOST_TEST(a->val == 3);
+    BOOST_TEST(b->val == 2);
 }
 
 void test_optional_ref_to_movables()
@@ -329,66 +316,24 @@ void test_optional_ref_to_movables()
     MoveOnly m(3);
     optional<MoveOnly&> orm = m;
     orm->val = 2;
-    BOOST_CHECK(m.val == 2);
+    BOOST_TEST(m.val == 2);
     
     optional<MoveOnly&> orm2 = orm;
     orm2->val = 1;
-    BOOST_CHECK(m.val == 1);
-    BOOST_CHECK(orm->val == 1);
+    BOOST_TEST(m.val == 1);
+    BOOST_TEST(orm->val == 1);
     
     optional<MoveOnly&> orm3 = boost::move(orm);
     orm3->val = 4;
-    BOOST_CHECK(m.val == 4);
-    BOOST_CHECK(orm->val == 4);
-    BOOST_CHECK(orm2->val == 4);
+    BOOST_TEST(m.val == 4);
+    BOOST_TEST(orm->val == 4);
+    BOOST_TEST(orm2->val == 4);
 }
 
-// these 4 classes have different noexcept signatures in move operations
-struct NothrowBoth {
-  NothrowBoth(NothrowBoth&&) BOOST_NOEXCEPT_IF(true) {};
-  void operator=(NothrowBoth&&) BOOST_NOEXCEPT_IF(true) {};
-};
-struct NothrowCtor {
-  NothrowCtor(NothrowCtor&&) BOOST_NOEXCEPT_IF(true) {};
-  void operator=(NothrowCtor&&) BOOST_NOEXCEPT_IF(false) {};
-};
-struct NothrowAssign {
-  NothrowAssign(NothrowAssign&&) BOOST_NOEXCEPT_IF(false) {};
-  void operator=(NothrowAssign&&) BOOST_NOEXCEPT_IF(true) {};
-};
-struct NothrowNone {
-  NothrowNone(NothrowNone&&) BOOST_NOEXCEPT_IF(false) {};
-  void operator=(NothrowNone&&) BOOST_NOEXCEPT_IF(false) {};
-};
-
-#ifndef BOOST_NO_NOEXCEPT
-
-void test_noexcept() // this is a compile-time test
-{
-    BOOST_STATIC_ASSERT(::boost::is_nothrow_move_constructible<optional<NothrowBoth> >::value);
-    BOOST_STATIC_ASSERT(::boost::is_nothrow_move_assignable<optional<NothrowBoth> >::value);
-    BOOST_STATIC_ASSERT(BOOST_NOEXCEPT_EXPR(optional<NothrowBoth>()));
-    
-    BOOST_STATIC_ASSERT(::boost::is_nothrow_move_constructible<optional<NothrowCtor> >::value);
-    BOOST_STATIC_ASSERT(!::boost::is_nothrow_move_assignable<optional<NothrowCtor> >::value);
-    BOOST_STATIC_ASSERT(BOOST_NOEXCEPT_EXPR(optional<NothrowCtor>()));
-    
-    BOOST_STATIC_ASSERT(!::boost::is_nothrow_move_constructible<optional<NothrowAssign> >::value);
-    BOOST_STATIC_ASSERT(!::boost::is_nothrow_move_assignable<optional<NothrowAssign> >::value);
-    BOOST_STATIC_ASSERT(BOOST_NOEXCEPT_EXPR(optional<NothrowAssign>()));
-    
-    BOOST_STATIC_ASSERT(!::boost::is_nothrow_move_constructible<optional<NothrowNone> >::value);
-    BOOST_STATIC_ASSERT(!::boost::is_nothrow_move_assignable<optional<NothrowNone> >::value);
-    BOOST_STATIC_ASSERT(BOOST_NOEXCEPT_EXPR(optional<NothrowNone>()));
-}
-#endif // !defned BOOST_NO_NOEXCEPT
-
 #endif
 
-int test_main( int, char* [] )
+int main()
 {
-  try
-  {
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
     test_move_ctor_from_U();
     test_move_ctor_form_T();
@@ -402,13 +347,6 @@ int test_main( int, char* [] )
     test_optional_ref_to_movables();
     test_swap();
 #endif
-  }
-  catch ( ... )
-  {
-    BOOST_ERROR("Unexpected Exception caught!");
-  }
 
-  return 0;
+  return boost::report_errors();
 }
-
-

test/optional_test_msvc_bug_workaround.cpp

@@ -0,0 +1,41 @@
+// Copyright (C) 2015 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
+
+#define BOOST_OPTIONAL_CONFIG_NO_RVALUE_REFERENCES
+#include "boost/optional/optional.hpp"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#include "boost/core/lightweight_test.hpp"
+
+
+struct Wrapper
+{
+  operator int () { return 9; }
+  operator boost::optional<int> () { return 7; }
+};
+
+void test()
+{
+#if (!defined BOOST_NO_CXX11_RVALUE_REFERENCES)
+  boost::optional<int> v = Wrapper();
+  BOOST_TEST(v);
+  BOOST_TEST_EQ(*v, 7);
+#endif
+} 
+
+int main()
+{
+  test();
+  return boost::report_errors();
+}

test/optional_test_noexcept_move.cpp

@@ -0,0 +1,116 @@
+// 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/static_assert.hpp"
+#include "boost/optional/optional.hpp"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+
+using boost::optional;
+
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef BOOST_NO_CXX11_NOEXCEPT
+
+// these 4 classes have different noexcept signatures in move operations
+struct NothrowBoth {
+  NothrowBoth(NothrowBoth&&) BOOST_NOEXCEPT_IF(true) {};
+  void operator=(NothrowBoth&&) BOOST_NOEXCEPT_IF(true) {};
+};
+struct NothrowCtor {
+  NothrowCtor(NothrowCtor&&) BOOST_NOEXCEPT_IF(true) {};
+  void operator=(NothrowCtor&&) BOOST_NOEXCEPT_IF(false) {};
+};
+struct NothrowAssign {
+  NothrowAssign(NothrowAssign&&) BOOST_NOEXCEPT_IF(false) {};
+  void operator=(NothrowAssign&&) BOOST_NOEXCEPT_IF(true) {};
+};
+struct NothrowNone {
+  NothrowNone(NothrowNone&&) BOOST_NOEXCEPT_IF(false) {};
+  void operator=(NothrowNone&&) BOOST_NOEXCEPT_IF(false) {};
+};
+
+#if 0 // these also test type_traits, which are wrong
+void test_noexcept_as_defined() // this is a compile-time test
+{
+  BOOST_STATIC_ASSERT(::boost::is_nothrow_move_constructible<NothrowBoth>::value);
+  BOOST_STATIC_ASSERT(::boost::is_nothrow_move_assignable<NothrowBoth>::value);
+  
+  BOOST_STATIC_ASSERT(::boost::is_nothrow_move_constructible<NothrowCtor>::value);
+  BOOST_STATIC_ASSERT(!::boost::is_nothrow_move_assignable<NothrowCtor>::value);
+  
+  BOOST_STATIC_ASSERT(!::boost::is_nothrow_move_constructible<NothrowAssign>::value);
+  BOOST_STATIC_ASSERT(::boost::is_nothrow_move_assignable<NothrowAssign>::value);
+  
+  BOOST_STATIC_ASSERT(!::boost::is_nothrow_move_constructible<NothrowNone>::value);
+  BOOST_STATIC_ASSERT(!::boost::is_nothrow_move_assignable<NothrowNone>::value);
+}
+
+void test_noexcept_on_optional_with_type_traits() // this is a compile-time test
+{
+  BOOST_STATIC_ASSERT(::boost::is_nothrow_move_constructible<optional<NothrowBoth> >::value);
+  BOOST_STATIC_ASSERT(::boost::is_nothrow_move_assignable<optional<NothrowBoth> >::value);
+  BOOST_STATIC_ASSERT(BOOST_NOEXCEPT_EXPR(optional<NothrowBoth>()));
+    
+  BOOST_STATIC_ASSERT(::boost::is_nothrow_move_constructible<optional<NothrowCtor> >::value);
+  BOOST_STATIC_ASSERT(!::boost::is_nothrow_move_assignable<optional<NothrowCtor> >::value);
+  BOOST_STATIC_ASSERT(BOOST_NOEXCEPT_EXPR(optional<NothrowCtor>()));
+    
+  BOOST_STATIC_ASSERT(!::boost::is_nothrow_move_constructible<optional<NothrowAssign> >::value);
+  BOOST_STATIC_ASSERT(!::boost::is_nothrow_move_assignable<optional<NothrowAssign> >::value);
+  BOOST_STATIC_ASSERT(BOOST_NOEXCEPT_EXPR(optional<NothrowAssign>()));
+    
+  BOOST_STATIC_ASSERT(!::boost::is_nothrow_move_constructible<optional<NothrowNone> >::value);
+  BOOST_STATIC_ASSERT(!::boost::is_nothrow_move_assignable<optional<NothrowNone> >::value);
+  BOOST_STATIC_ASSERT(BOOST_NOEXCEPT_EXPR(optional<NothrowNone>()));
+}
+#endif
+
+void test_noexcept_optional_with_operator() // compile-time test
+{
+  typedef optional<NothrowBoth>   ONx2;
+  typedef optional<NothrowCtor>   ONxC;
+  typedef optional<NothrowAssign> ONxA;
+  typedef optional<NothrowNone>   ONx0;
+  ONx2 onx2;
+  ONxC onxC;
+  ONxA onxA;
+  ONx0 onx0;
+  
+  BOOST_STATIC_ASSERT( BOOST_NOEXCEPT_EXPR( ONx2() ));
+  BOOST_STATIC_ASSERT( BOOST_NOEXCEPT_EXPR( ONx2(boost::move(onx2)) ));
+  BOOST_STATIC_ASSERT( BOOST_NOEXCEPT_EXPR( onx2 = ONx2() )); 
+  
+  BOOST_STATIC_ASSERT( BOOST_NOEXCEPT_EXPR( ONxC() ));
+  BOOST_STATIC_ASSERT( BOOST_NOEXCEPT_EXPR( ONxC(boost::move(onxC)) ));
+  BOOST_STATIC_ASSERT(!BOOST_NOEXCEPT_EXPR( onxC = ONxC() ));
+  
+  BOOST_STATIC_ASSERT( BOOST_NOEXCEPT_EXPR( ONxA() ));
+  BOOST_STATIC_ASSERT(!BOOST_NOEXCEPT_EXPR( ONxA(boost::move(onxA)) ));
+  BOOST_STATIC_ASSERT(!BOOST_NOEXCEPT_EXPR( onxA = ONxA() ));
+  
+  BOOST_STATIC_ASSERT( BOOST_NOEXCEPT_EXPR( ONx0() ));
+  BOOST_STATIC_ASSERT(!BOOST_NOEXCEPT_EXPR( ONx0(boost::move(onx0)) ));
+  BOOST_STATIC_ASSERT(!BOOST_NOEXCEPT_EXPR( onx0 = ONx0() ));
+}
+
+#endif // !defned BOOST_NO_CXX11_NOEXCEPT
+#endif // !defined BOOST_NO_CXX11_RVALUE_REFERENCES
+
+int main()
+{
+  return 0;
+}
+
+

test/optional_test_ref.cpp

@@ -1,373 +0,0 @@
-// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
-//
-// 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:
-//  fernando_cacciola@hotmail.com
-//
-#include<iostream>
-#include<stdexcept>
-#include<string>
-
-#define BOOST_ENABLE_ASSERT_HANDLER
-
-#include "boost/optional.hpp"
-
-#ifdef __BORLANDC__
-#pragma hdrstop
-#endif
-
-#include "boost/none.hpp"
-
-#include "boost/test/minimal.hpp"
-
-#include "optional_test_common.cpp"
-
-template<class T>
-inline void check_ref_uninitialized_const ( optional<T&> const& opt )
-{
-#ifndef BOOST_OPTIONAL_NO_NULL_COMPARE
-  BOOST_CHECK( opt == 0 ) ;
-#endif
-  BOOST_CHECK( !opt ) ;
-}
-template<class T>
-inline void check_ref_uninitialized ( optional<T&>& opt )
-{
-#ifndef BOOST_OPTIONAL_NO_NULL_COMPARE
-  BOOST_CHECK( opt == 0 ) ;
-#endif
-  BOOST_CHECK( !opt ) ;
-
-  check_ref_uninitialized_const(opt);
-}
-
-template<class T>
-inline void check_ref_initialized_const ( optional<T&> const& opt )
-{
-  BOOST_CHECK( opt ) ;
-
-#ifndef BOOST_OPTIONAL_NO_NULL_COMPARE
-  BOOST_CHECK( opt != 0 ) ;
-#endif
-
-  BOOST_CHECK ( !!opt ) ;
-}
-
-template<class T>
-inline void check_ref_initialized ( optional<T&>& opt )
-{
-  BOOST_CHECK( opt ) ;
-
-#ifndef BOOST_OPTIONAL_NO_NULL_COMPARE
-  BOOST_CHECK( opt != 0 ) ;
-#endif
-
-  BOOST_CHECK ( !!opt ) ;
-
-  check_ref_initialized_const(opt);
-}
-
-template<class T>
-inline void check_ref_value_const ( optional<T&> const& opt, T const& v, T const& z )
-{
-  BOOST_CHECK( *opt == v ) ;
-  BOOST_CHECK( *opt != z ) ;
-  BOOST_CHECK( opt.get() == v ) ;
-  BOOST_CHECK( opt.get() != z ) ;
-}
-
-template<class T>
-inline void check_ref_value ( optional<T&>& opt, T const& v, T const& z )
-{
-  BOOST_CHECK( *opt == v ) ;
-  BOOST_CHECK( *opt != z ) ;
-  BOOST_CHECK( opt.get() == v ) ;
-  BOOST_CHECK( opt.get() != z ) ;
-
-  check_ref_value_const(opt,v,z);
-}
-
-//
-// Basic test.
-// Check ordinary functionality:
-//   Initialization, assignment, comparison and value-accessing.
-//
-template<class T>
-void test_basics( T const* )
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION  );
-
-  T z(0);
-
-  T original_a(1);
-
-  T a(1);
-
-  T b(2);
-
-  T c(10);
-
-  T& aref = a ;
-  T& bref = b ;
-
-  // Default construction.
-  // 'def' state is Uninitialized.
-  // T::T() is not called
-  optional<T&> def ;
-  check_ref_uninitialized(def);
-
-  // Direct initialization.
-  // 'oa' state is Initialized and binds to 'a'
-  // T::T( T const& x ) is NOT used becasue the optional holds a reference.
-  set_pending_copy( ARG(T) ) ;
-  optional<T&> oa ( aref ) ;
-  check_is_pending_copy( ARG(T) );
-  check_ref_initialized(oa);
-  check_ref_value(oa,a,z);
-  *oa = b ; // changes the value of 'a' through the reference
-  BOOST_CHECK( a == b ) ;
-
-
-  // Copy initialization.
-  // T::T ( T const& x ) is NOT used becasue the optional holds a reference.
-  set_pending_copy( ARG(T) ) ;
-  optional<T&>  const oa2 ( oa ) ;
-  check_is_pending_copy( ARG(T) ) ;
-  check_ref_initialized_const(oa2);
-  check_ref_value_const(oa2,a,z);
-  *oa2 = original_a ; // restores the value of 'a' through the reference
-  BOOST_CHECK( a == original_a ) ;
-
-  optional<T&> ob ;
-
-  // Value-Assignment upon Uninitialized optional.
-  // T::T ( T const& x ) is NOT used becasue the optional holds a reference.
-  set_pending_copy( ARG(T) ) ;
-  ob = a ; // Binds ob to a temporary non-const refererence to 'a'
-  check_is_pending_copy( ARG(T) ) ;
-  check_ref_initialized(ob);
-  check_ref_value(ob,a,z);
-  a = c;
-  check_ref_value(ob,a,z);
-
-  // Value-Assignment upon Initialized optional.
-  // T::operator= ( T const& x ) is used.
-  set_pending_assign( ARG(T) ) ;
-  ob = b ; // Rebinds 'ob' to 'b' (without changing 'a')
-  check_is_pending_assign( ARG(T) ) ;
-  check_ref_initialized(ob);
-  check_ref_value(ob,b,z);
-  BOOST_CHECK(a == c); // From a=c in previous test
-  b = c;
-  check_ref_value(ob,b,z);
-
-
-  // Assignment initialization.
-  // T::T ( T const& x ) is NOT used becasue the optional holds a reference.
-  set_pending_copy( ARG(T) ) ;
-  optional<T&> const oa3 = b ;
-  check_is_pending_copy( ARG(T) ) ;
-  check_ref_initialized_const(oa3);
-  check_ref_value_const(oa3,b,z);
-
-
-  // Assignment
-  // T::operator=( T const& x ) is used.
-  set_pending_assign( ARG(T) ) ;
-  oa = ob ; // Rebinds 'a' to 'b'
-  check_is_pending_assign( ARG(T) ) ;
-  check_ref_initialized(oa);
-  a = original_a ;
-  check_ref_value(oa,b,z);
-
-  // Uninitializing Assignment upon Initialized Optional
-  // T::~T() is NOT used becasue the optional holds a reference.
-  set_pending_dtor( ARG(T) ) ;
-  set_pending_copy( ARG(T) ) ;
-  oa = def ;
-  check_is_pending_dtor( ARG(T) ) ;
-  check_is_pending_copy( ARG(T) ) ;
-  check_ref_uninitialized(oa);
-
-  // Uninitializing Assignment upon Uninitialized Optional
-  // (Dtor is not called this time)
-  set_pending_dtor( ARG(T) ) ;
-  set_pending_copy( ARG(T) ) ;
-  oa = def ;
-  check_is_pending_dtor( ARG(T) ) ;
-  check_is_pending_copy( ARG(T) ) ;
-  check_ref_uninitialized(oa);
-
-
-  // Deinitialization of Initialized Optional
-  // T::~T() is NOT used becasue the optional holds a reference.
-  set_pending_dtor( ARG(T) ) ;
-  ob.reset();
-  check_is_pending_dtor( ARG(T) ) ;
-  check_ref_uninitialized(ob);
-
-  // Deinitialization of Uninitialized Optional
-  // T::~T() is not called this time
-  set_pending_dtor( ARG(T) ) ;
-  ob.reset();
-  check_is_pending_dtor( ARG(T) ) ;
-  check_ref_uninitialized(ob);
-}
-
-//
-// This verifies relational operators.
-//
-template<class T>
-void test_relops( T const* )
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );
-
-  reset_throw_on_copy( ARG(T) ) ;
-
-  T v0(18);
-  T v1(19);
-  T v2(19);
-
-  optional<T&> def0 ;
-  optional<T&> def1 ;
-  optional<T&> opt0(v0);
-  optional<T&> opt1(v1);
-  optional<T&> opt2(v2);
-
-  // Check identity
-  BOOST_CHECK ( def0 == def0 ) ;
-  BOOST_CHECK ( opt0 == opt0 ) ;
-  BOOST_CHECK ( !(def0 != def0) ) ;
-  BOOST_CHECK ( !(opt0 != opt0) ) ;
-
-  // Check when both are uininitalized.
-  BOOST_CHECK (   def0 == def1  ) ; // both uninitialized compare equal
-  BOOST_CHECK ( !(def0 <  def1) ) ; // uninitialized is never less    than uninitialized
-  BOOST_CHECK ( !(def0 >  def1) ) ; // uninitialized is never greater than uninitialized
-  BOOST_CHECK ( !(def0 != def1) ) ;
-  BOOST_CHECK (   def0 <= def1  ) ;
-  BOOST_CHECK (   def0 >= def1  ) ;
-
-  // Check when only lhs is uninitialized.
-  BOOST_CHECK (   def0 != opt0  ) ; // uninitialized is never equal to initialized
-  BOOST_CHECK ( !(def0 == opt0) ) ;
-  BOOST_CHECK (   def0 <  opt0  ) ; // uninitialized is always less than initialized
-  BOOST_CHECK ( !(def0 >  opt0) ) ;
-  BOOST_CHECK (   def0 <= opt0  ) ;
-  BOOST_CHECK ( !(def0 >= opt0) ) ;
-
-  // Check when only rhs is uninitialized.
-  BOOST_CHECK (   opt0 != def0  ) ; // initialized is never equal to uninitialized
-  BOOST_CHECK ( !(opt0 == def0) ) ;
-  BOOST_CHECK ( !(opt0 <  def0) ) ; // initialized is never less than uninitialized
-  BOOST_CHECK (   opt0 >  def0  ) ;
-  BOOST_CHECK ( !(opt0 <= def0) ) ;
-  BOOST_CHECK (   opt0 >= opt0  ) ;
-
-  // If both are initialized, values are compared
-  BOOST_CHECK ( opt0 != opt1 ) ;
-  BOOST_CHECK ( opt1 == opt2 ) ;
-  BOOST_CHECK ( opt0 <  opt1 ) ;
-  BOOST_CHECK ( opt1 >  opt0 ) ;
-  BOOST_CHECK ( opt1 <= opt2 ) ;
-  BOOST_CHECK ( opt1 >= opt0 ) ;
-}
-
-template<class T>
-void test_none( T const* )
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );
-
-  using boost::none ;
-
-  T a(1234);
-
-  optional<T&> def0 ;
-  optional<T&> def1(none) ;
-  optional<T&> non_def(a) ;
-
-  BOOST_CHECK ( def0    == none ) ;
-  BOOST_CHECK ( non_def != none ) ;
-  BOOST_CHECK ( !def1           ) ;
-
-  non_def = none ;
-  BOOST_CHECK ( !non_def ) ;
-}
-
-template<class T>
-void test_arrow( T const* )
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );
-
-  T a(1234);
-
-  optional<T&>        oa(a) ;
-  optional<T&> const coa(a) ;
-  
-  BOOST_CHECK ( coa->V() == 1234 ) ;
-  
-  oa->V() = 4321 ;
-  
-  BOOST_CHECK ( a.V() = 4321 ) ;
-}
-
-void test_with_builtin_types()
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );
-
-  test_basics( ARG(double) );
-  test_relops( ARG(double) ) ;
-  test_none  ( ARG(double) ) ;
-}
-
-void test_with_class_type()
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );
-
-  test_basics( ARG(X) );
-  test_relops( ARG(X) ) ;
-  test_none  ( ARG(X) ) ;
-  test_arrow ( ARG(X) ) ;
-
-  BOOST_CHECK ( X::count == 0 ) ;
-}
-
-void test_binding()
-{
-  int i = 0 ;
-  optional<int&> ori1 = i ;
-  BOOST_CHECK(  &(*ori1) == &i ) ;
-
-  optional<int&> ori2(i) ;
-  BOOST_CHECK(  &(*ori2) == &i ) ;
-
-  int const ci = 0 ;
-  optional<int const&> orci1 = ci ;
-  BOOST_CHECK(  &(*orci1) == &ci ) ;
-
-  optional<int const&> orci2(ci) ;
-  BOOST_CHECK(  &(*orci2) == &ci ) ;
-}
-
-int test_main( int, char* [] )
-{
-  try
-  {
-    test_with_class_type();
-    test_with_builtin_types();
-    test_binding();
-  }
-  catch ( ... )
-  {
-    BOOST_ERROR("Unexpected Exception caught!");
-  }
-
-  return 0;
-}
-
-

test/optional_test_ref_assign_const_int.cpp

@@ -0,0 +1,34 @@
+// 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"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#include "boost/core/lightweight_test.hpp"
+#include "testable_classes.hpp"
+#include "optional_ref_assign_test_defs.hpp"
+
+using boost::optional;
+using boost::none;
+
+
+int main()
+{
+  test_copy_assignment_for_const<int>();
+  test_copy_assignment_for_noconst_const<int>();
+  test_rebinding_assignment_semantics_const<int>();
+  test_rebinding_assignment_semantics_noconst_const<int>();
+  
+  return boost::report_errors();
+}

test/optional_test_ref_assign_mutable_int.cpp

@@ -0,0 +1,31 @@
+// 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"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#include "boost/core/lightweight_test.hpp"
+#include "testable_classes.hpp"
+#include "optional_ref_assign_test_defs.hpp"
+
+using boost::optional;
+using boost::none;
+
+int main()
+{
+  test_copy_assignment_for<int>();
+  test_rebinding_assignment_semantics<int>();
+  
+  return boost::report_errors();
+}

test/optional_test_ref_assign_portable_minimum.cpp

@@ -0,0 +1,44 @@
+// 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"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#include "boost/core/lightweight_test.hpp"
+#include "testable_classes.hpp"
+#include "optional_ref_assign_test_defs.hpp"
+
+using boost::optional;
+using boost::none;
+
+
+template <typename T>
+void test_optional_ref_assignment()
+{
+  test_copy_assignment_for<T>();
+  test_rebinding_assignment_semantics<T>();
+  
+  test_copy_assignment_for_const<T>();
+  test_copy_assignment_for_noconst_const<T>();
+  test_rebinding_assignment_semantics_const<T>();
+  test_rebinding_assignment_semantics_noconst_const<T>();
+}
+
+int main()
+{
+  test_optional_ref_assignment<ScopeGuard>();
+  //test_optional_ref_assignment<Abstract>();
+  
+  return boost::report_errors();
+}

test/optional_test_ref_convert_assign_const_int.cpp

@@ -0,0 +1,30 @@
+// Copyright (C) 2015 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"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#include "boost/core/addressof.hpp"
+#include "boost/core/enable_if.hpp"
+#include "boost/core/lightweight_test.hpp"
+#include "testable_classes.hpp"
+#include "optional_ref_assign_test_defs.hpp"
+
+int main()
+{
+  test_converting_assignment<const int>();
+  test_converting_assignment_for_noconst_const<int>();
+  
+  return boost::report_errors();
+}

test/optional_test_ref_convert_assign_mutable_int.cpp

@@ -0,0 +1,29 @@
+// Copyright (C) 2015 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"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#include "boost/core/addressof.hpp"
+#include "boost/core/enable_if.hpp"
+#include "boost/core/lightweight_test.hpp"
+#include "testable_classes.hpp"
+#include "optional_ref_assign_test_defs.hpp"
+
+int main()
+{
+  test_converting_assignment<int>();
+  
+  return boost::report_errors();
+}

test/optional_test_ref_convert_assign_non_int.cpp

@@ -0,0 +1,39 @@
+// Copyright (C) 2015 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"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#include "boost/core/addressof.hpp"
+#include "boost/core/enable_if.hpp"
+#include "boost/core/lightweight_test.hpp"
+#include "testable_classes.hpp"
+#include "optional_ref_assign_test_defs.hpp"
+
+
+template <typename T>
+void test_all_const_cases()
+{
+  test_converting_assignment<T>();
+  test_converting_assignment<const T>();
+  test_converting_assignment_for_noconst_const<T>();
+}
+
+int main()
+{
+  test_all_const_cases<ScopeGuard>();
+  //test_all_const_cases<Abstract>();
+  
+  return boost::report_errors();
+}

test/optional_test_ref_converting_ctor.cpp

@@ -0,0 +1,107 @@
+// 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"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#include "boost/core/addressof.hpp"
+#include "boost/core/enable_if.hpp"
+#include "boost/core/lightweight_test.hpp"
+#include "testable_classes.hpp"
+
+using boost::optional;
+using boost::none;
+
+template <typename T>
+void test_converting_ctor()
+{
+  typename concrete_type_of<T>::type v1(1), v2(2);
+  
+  {
+    optional<T&> o1 = v1, o1_ = v1, o2 = v2;
+    
+    BOOST_TEST(o1);
+    BOOST_TEST(boost::addressof(*o1) == boost::addressof(v1));
+    BOOST_TEST(o1_);
+    BOOST_TEST(boost::addressof(*o1_) == boost::addressof(v1));
+    BOOST_TEST(boost::addressof(*o1_) == boost::addressof(*o1));
+    
+    BOOST_TEST(o2);
+    BOOST_TEST(boost::addressof(*o2) == boost::addressof(v2));
+    BOOST_TEST(boost::addressof(*o2) != boost::addressof(*o1));
+  }
+  {
+    const optional<T&> o1 = v1, o1_ = v1, o2 = v2;
+    
+    BOOST_TEST(o1);
+    BOOST_TEST(boost::addressof(*o1) == boost::addressof(v1));
+    BOOST_TEST(o1_);
+    BOOST_TEST(boost::addressof(*o1_) == boost::addressof(v1));
+    BOOST_TEST(boost::addressof(*o1_) == boost::addressof(*o1));
+    
+    BOOST_TEST(o2);
+    BOOST_TEST(boost::addressof(*o2) == boost::addressof(v2));
+    BOOST_TEST(boost::addressof(*o2) != boost::addressof(*o1));
+  }
+}
+
+template <typename T>
+void test_converting_ctor_for_noconst_const()
+{
+  typename concrete_type_of<T>::type v1(1), v2(2);
+  
+  {
+    optional<const T&> o1 = v1, o1_ = v1, o2 = v2;
+    
+    BOOST_TEST(o1);
+    BOOST_TEST(boost::addressof(*o1) == boost::addressof(v1));
+    BOOST_TEST(o1_);
+    BOOST_TEST(boost::addressof(*o1_) == boost::addressof(v1));
+    BOOST_TEST(boost::addressof(*o1_) == boost::addressof(*o1));
+    
+    BOOST_TEST(o2);
+    BOOST_TEST(boost::addressof(*o2) == boost::addressof(v2));
+    BOOST_TEST(boost::addressof(*o2) != boost::addressof(*o1));
+  }
+  {
+    const optional<const T&> o1 = v1, o1_ = v1, o2 = v2;
+    
+    BOOST_TEST(o1);
+    BOOST_TEST(boost::addressof(*o1) == boost::addressof(v1));
+    BOOST_TEST(o1_);
+    BOOST_TEST(boost::addressof(*o1_) == boost::addressof(v1));
+    BOOST_TEST(boost::addressof(*o1_) == boost::addressof(*o1));
+    
+    BOOST_TEST(o2);
+    BOOST_TEST(boost::addressof(*o2) == boost::addressof(v2));
+    BOOST_TEST(boost::addressof(*o2) != boost::addressof(*o1));
+  }
+}
+
+template <typename T>
+void test_all_const_cases()
+{
+  test_converting_ctor<T>();
+  test_converting_ctor<const T>();
+  test_converting_ctor_for_noconst_const<T>();
+}
+
+int main()
+{
+  test_all_const_cases<int>();
+  test_all_const_cases<ScopeGuard>();
+  //test_all_const_cases<Abstract>();
+  
+  return boost::report_errors();
+}

test/optional_test_ref_move.cpp

@@ -0,0 +1,69 @@
+// 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"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#include <string>
+#include "boost/core/addressof.hpp"
+#include "boost/core/lightweight_test.hpp"
+
+using boost::optional;
+
+std::string global("text"); 
+
+optional<std::string&> make_optional_string_ref()
+{
+  return optional<std::string&>(global);
+}
+
+std::string& return_global()
+{
+  return global;
+}
+
+int main()
+{
+  optional<std::string&> opt;
+  opt = make_optional_string_ref();
+  BOOST_TEST(bool(opt));
+  BOOST_TEST(*opt == global);
+  BOOST_TEST(boost::addressof(*opt) == boost::addressof(global));
+  
+  {
+    std::string& str = *make_optional_string_ref();
+    BOOST_TEST(str == global);
+    BOOST_TEST(boost::addressof(str) == boost::addressof(global));
+  }
+  
+  {
+    std::string& str = make_optional_string_ref().value();
+    BOOST_TEST(str == global);
+    BOOST_TEST(boost::addressof(str) == boost::addressof(global));
+  }
+  
+  {
+    std::string& str = make_optional_string_ref().value_or(global);
+    BOOST_TEST(str == global);
+    BOOST_TEST(boost::addressof(str) == boost::addressof(global));
+  }
+  
+  {
+    std::string& str = make_optional_string_ref().value_or_eval(&return_global);
+    BOOST_TEST(str == global);
+    BOOST_TEST(boost::addressof(str) == boost::addressof(global));
+  }
+  
+  return boost::report_errors();
+}

test/optional_test_ref_portable_minimum.cpp

@@ -0,0 +1,448 @@
+// 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"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#include "boost/core/addressof.hpp"
+#include "boost/core/enable_if.hpp"
+#include "boost/core/lightweight_test.hpp"
+#include "testable_classes.hpp"
+
+using boost::optional;
+using boost::none;
+
+struct CountingClass
+{
+  static int count;
+  static int assign_count;
+  CountingClass() { ++count; }
+  CountingClass(const CountingClass&) { ++count; }
+  CountingClass& operator=(const CountingClass&) { ++assign_count; return *this; }
+  ~CountingClass() { ++count; }
+};
+
+int CountingClass::count = 0;
+int CountingClass::assign_count = 0;
+
+void test_no_object_creation()
+{
+  BOOST_TEST_EQ(0, CountingClass::count);
+  BOOST_TEST_EQ(0, CountingClass::assign_count);
+  {
+    CountingClass v1, v2;
+    optional<CountingClass&> oA(v1);
+    optional<CountingClass&> oB;
+    optional<CountingClass&> oC = oA;
+    oB = oA;
+    *oB = v2;
+    oC = none;
+    oC = optional<CountingClass&>(v2);
+    oB = none;
+    oA = oB;
+  }
+  BOOST_TEST_EQ(4, CountingClass::count);
+  BOOST_TEST_EQ(1, CountingClass::assign_count);
+}
+
+template <typename T>
+typename boost::enable_if< has_arrow<T> >::type
+test_arrow_const()
+{
+  const typename concrete_type_of<T>::type v(2);
+  optional<const T&> o(v);
+  BOOST_TEST(o);
+  BOOST_TEST_EQ(o->val(), 2);
+  BOOST_TEST(boost::addressof(o->val()) == boost::addressof(v.val()));
+}
+
+template <typename T>
+typename boost::disable_if< has_arrow<T> >::type
+test_arrow_const()
+{
+}
+
+template <typename T>
+typename boost::enable_if< has_arrow<T> >::type
+test_arrow_noconst_const()
+{
+  typename concrete_type_of<T>::type v(2);
+  optional<const T&> o(v);
+  BOOST_TEST(o);
+  BOOST_TEST_EQ(o->val(), 2);
+  BOOST_TEST(boost::addressof(o->val()) == boost::addressof(v.val()));
+  
+  v.val() = 1;
+  BOOST_TEST(o);
+  BOOST_TEST_EQ(o->val(), 1);
+  BOOST_TEST_EQ(v.val(), 1);
+  BOOST_TEST(boost::addressof(o->val()) == boost::addressof(v.val()));
+}
+
+template <typename T>
+typename boost::disable_if< has_arrow<T> >::type
+test_arrow_noconst_const()
+{
+}
+
+template <typename T>
+typename boost::enable_if< has_arrow<T> >::type
+test_arrow()
+{
+  typename concrete_type_of<T>::type v(2);
+  optional<T&> o(v);
+  BOOST_TEST(o);
+  BOOST_TEST_EQ(o->val(), 2);
+  BOOST_TEST(boost::addressof(o->val()) == boost::addressof(v.val()));
+  
+  v.val() = 1;
+  BOOST_TEST(o);
+  BOOST_TEST_EQ(o->val(), 1);
+  BOOST_TEST_EQ(v.val(), 1);
+  BOOST_TEST(boost::addressof(o->val()) == boost::addressof(v.val()));
+  
+  o->val() = 3;
+  BOOST_TEST(o);
+  BOOST_TEST_EQ(o->val(), 3);
+  BOOST_TEST_EQ(v.val(), 3);
+  BOOST_TEST(boost::addressof(o->val()) == boost::addressof(v.val()));
+  
+}
+
+template <typename T>
+typename boost::disable_if< has_arrow<T> >::type
+test_arrow()
+{
+}
+
+template <typename T>
+void test_not_containing_value_for()
+{
+  optional<T&> o1;
+  optional<T&> o2 = none;
+  optional<T&> o3 = o1;
+  
+  BOOST_TEST(!o1);
+  BOOST_TEST(!o2);
+  BOOST_TEST(!o3);
+  
+  BOOST_TEST(o1 == none);
+  BOOST_TEST(o2 == none);
+  BOOST_TEST(o3 == none);
+}
+
+template <typename T>
+void test_direct_init_for_const()
+{
+  const typename concrete_type_of<T>::type v(2);
+  optional<const T&> o(v);
+  
+  BOOST_TEST(o);
+  BOOST_TEST(o != none);
+  BOOST_TEST(boost::addressof(*o) == boost::addressof(v));
+  BOOST_TEST_EQ(val(*o), val(v));
+  BOOST_TEST_EQ(val(*o), 2);
+}
+
+template <typename T>
+void test_direct_init_for_noconst_const()
+{
+  typename concrete_type_of<T>::type v(2);
+  optional<const T&> o(v);
+  
+  BOOST_TEST(o);
+  BOOST_TEST(o != none);
+  BOOST_TEST(boost::addressof(*o) == boost::addressof(v));
+  BOOST_TEST_EQ(val(*o), val(v));
+  BOOST_TEST_EQ(val(*o), 2);
+   
+  val(v) = 9;
+  BOOST_TEST(boost::addressof(*o) == boost::addressof(v));
+  BOOST_TEST_EQ(val(*o), val(v));
+  BOOST_TEST_EQ(val(*o), 9);
+  BOOST_TEST_EQ(val(v), 9);
+}
+
+template <typename T>
+void test_direct_init_for()
+{
+  typename concrete_type_of<T>::type v(2);
+  optional<T&> o(v);
+  
+  BOOST_TEST(o);
+  BOOST_TEST(o != none);
+  BOOST_TEST(boost::addressof(*o) == boost::addressof(v));
+  BOOST_TEST_EQ(val(*o), val(v));
+  BOOST_TEST_EQ(val(*o), 2);
+   
+  val(v) = 9;
+  BOOST_TEST(boost::addressof(*o) == boost::addressof(v));
+  BOOST_TEST_EQ(val(*o), val(v));
+  BOOST_TEST_EQ(val(*o), 9);
+  BOOST_TEST_EQ(val(v), 9);
+  
+  val(*o) = 7;
+  BOOST_TEST(boost::addressof(*o) == boost::addressof(v));
+  BOOST_TEST_EQ(val(*o), val(v));
+  BOOST_TEST_EQ(val(*o), 7);
+  BOOST_TEST_EQ(val(v), 7);
+}
+
+template <typename T>
+void test_clearing_the_value()
+{
+  typename concrete_type_of<T>::type v(2);
+  optional<T&> o1(v), o2(v);
+  
+  BOOST_TEST(o1);
+  BOOST_TEST(o1 != none);
+  BOOST_TEST(o2);
+  BOOST_TEST(o2 != none);
+  
+  o1 = none;
+  BOOST_TEST(!o1);
+  BOOST_TEST(o1 == none);
+  BOOST_TEST(o2);
+  BOOST_TEST(o2 != none);
+  BOOST_TEST_EQ(val(*o2), 2);
+  BOOST_TEST(boost::addressof(*o2) == boost::addressof(v));
+  BOOST_TEST_EQ(val(v), 2);
+}
+
+template <typename T>
+void test_equality()
+{
+  typename concrete_type_of<T>::type v1(1), v2(2), v2_(2), v3(3);
+  optional<T&> o1(v1), o2(v2), o2_(v2_), o3(v3), o3_(v3), oN, oN_;
+  // o2 and o2_ point to different objects; o3 and o3_ point to the same object
+  
+  BOOST_TEST(oN  == oN);
+  BOOST_TEST(oN  == oN_);
+  BOOST_TEST(oN_ == oN);
+  BOOST_TEST(o1  == o1);
+  BOOST_TEST(o2  == o2);
+  BOOST_TEST(o2  == o2_);
+  BOOST_TEST(o2_ == o2);
+  BOOST_TEST(o3  == o3);
+  BOOST_TEST(o3  == o3_);
+  BOOST_TEST(!(oN == o1));
+  BOOST_TEST(!(o1 == oN));
+  BOOST_TEST(!(o2 == o1));
+  BOOST_TEST(!(o2 == oN));
+  
+  BOOST_TEST(!(oN  != oN));
+  BOOST_TEST(!(oN  != oN_));
+  BOOST_TEST(!(oN_ != oN));
+  BOOST_TEST(!(o1  != o1));
+  BOOST_TEST(!(o2  != o2));
+  BOOST_TEST(!(o2  != o2_));
+  BOOST_TEST(!(o2_ != o2));
+  BOOST_TEST(!(o3  != o3));
+  BOOST_TEST(!(o3  != o3_));
+  BOOST_TEST( (oN  != o1));
+  BOOST_TEST( (o1  != oN));
+  BOOST_TEST( (o2  != o1));
+  BOOST_TEST( (o2  != oN));
+}
+
+template <typename T>
+void test_order()
+{
+  typename concrete_type_of<T>::type v1(1), v2(2), v2_(2), v3(3);
+  optional<T&> o1(v1), o2(v2), o2_(v2_), o3(v3), o3_(v3), oN, oN_;
+  // o2 and o2_ point to different objects; o3 and o3_ point to the same object
+  
+  BOOST_TEST(!(oN  < oN));
+  BOOST_TEST(!(oN  < oN_));
+  BOOST_TEST(!(oN_ < oN));
+  BOOST_TEST(!(o1  < o1));
+  BOOST_TEST(!(o2  < o2));
+  BOOST_TEST(!(o2  < o2_));
+  BOOST_TEST(!(o2_ < o2));
+  BOOST_TEST(!(o3  < o3));
+  BOOST_TEST(!(o3  < o3_));
+  
+  BOOST_TEST( (oN  <= oN));
+  BOOST_TEST( (oN  <= oN_));
+  BOOST_TEST( (oN_ <= oN));
+  BOOST_TEST( (o1  <= o1));
+  BOOST_TEST( (o2  <= o2));
+  BOOST_TEST( (o2  <= o2_));
+  BOOST_TEST( (o2_ <= o2));
+  BOOST_TEST( (o3  <= o3));
+  BOOST_TEST( (o3  <= o3_));
+  
+  BOOST_TEST(!(oN  > oN));
+  BOOST_TEST(!(oN  > oN_));
+  BOOST_TEST(!(oN_ > oN));
+  BOOST_TEST(!(o1  > o1));
+  BOOST_TEST(!(o2  > o2));
+  BOOST_TEST(!(o2  > o2_));
+  BOOST_TEST(!(o2_ > o2));
+  BOOST_TEST(!(o3  > o3));
+  BOOST_TEST(!(o3  > o3_));
+  
+  BOOST_TEST( (oN  >= oN));
+  BOOST_TEST( (oN  >= oN_));
+  BOOST_TEST( (oN_ >= oN));
+  BOOST_TEST( (o1  >= o1));
+  BOOST_TEST( (o2  >= o2));
+  BOOST_TEST( (o2  >= o2_));
+  BOOST_TEST( (o2_ >= o2));
+  BOOST_TEST( (o3  >= o3));
+  BOOST_TEST( (o3  >= o3_));
+  
+  BOOST_TEST( (oN  < o1));
+  BOOST_TEST( (oN_ < o1));
+  BOOST_TEST( (oN  < o2));
+  BOOST_TEST( (oN_ < o2));
+  BOOST_TEST( (oN  < o2_));
+  BOOST_TEST( (oN_ < o2_));
+  BOOST_TEST( (oN  < o3));
+  BOOST_TEST( (oN_ < o3));
+  BOOST_TEST( (oN  < o3_));
+  BOOST_TEST( (oN_ < o3_));
+  BOOST_TEST( (o1  < o2));
+  BOOST_TEST( (o1  < o2_));
+  BOOST_TEST( (o1  < o3));
+  BOOST_TEST( (o1  < o3_));
+  BOOST_TEST( (o2  < o3));
+  BOOST_TEST( (o2_ < o3));
+  BOOST_TEST( (o2  < o3_));
+  BOOST_TEST( (o2_ < o3_));
+  
+  BOOST_TEST( (oN  <= o1));
+  BOOST_TEST( (oN_ <= o1));
+  BOOST_TEST( (oN  <= o2));
+  BOOST_TEST( (oN_ <= o2));
+  BOOST_TEST( (oN  <= o2_));
+  BOOST_TEST( (oN_ <= o2_));
+  BOOST_TEST( (oN  <= o3));
+  BOOST_TEST( (oN_ <= o3));
+  BOOST_TEST( (oN  <= o3_));
+  BOOST_TEST( (oN_ <= o3_));
+  BOOST_TEST( (o1  <= o2));
+  BOOST_TEST( (o1  <= o2_));
+  BOOST_TEST( (o1  <= o3));
+  BOOST_TEST( (o1  <= o3_));
+  BOOST_TEST( (o2  <= o3));
+  BOOST_TEST( (o2_ <= o3));
+  BOOST_TEST( (o2  <= o3_));
+  BOOST_TEST( (o2_ <= o3_));
+  
+  BOOST_TEST(!(oN  > o1));
+  BOOST_TEST(!(oN_ > o1));
+  BOOST_TEST(!(oN  > o2));
+  BOOST_TEST(!(oN_ > o2));
+  BOOST_TEST(!(oN  > o2_));
+  BOOST_TEST(!(oN_ > o2_));
+  BOOST_TEST(!(oN  > o3));
+  BOOST_TEST(!(oN_ > o3));
+  BOOST_TEST(!(oN  > o3_));
+  BOOST_TEST(!(oN_ > o3_));
+  BOOST_TEST(!(o1  > o2));
+  BOOST_TEST(!(o1  > o2_));
+  BOOST_TEST(!(o1  > o3));
+  BOOST_TEST(!(o1  > o3_));
+  BOOST_TEST(!(o2  > o3));
+  BOOST_TEST(!(o2_ > o3));
+  BOOST_TEST(!(o2  > o3_));
+  BOOST_TEST(!(o2_ > o3_));
+  
+  BOOST_TEST(!(oN  >= o1));
+  BOOST_TEST(!(oN_ >= o1));
+  BOOST_TEST(!(oN  >= o2));
+  BOOST_TEST(!(oN_ >= o2));
+  BOOST_TEST(!(oN  >= o2_));
+  BOOST_TEST(!(oN_ >= o2_));
+  BOOST_TEST(!(oN  >= o3));
+  BOOST_TEST(!(oN_ >= o3));
+  BOOST_TEST(!(oN  >= o3_));
+  BOOST_TEST(!(oN_ >= o3_));
+  BOOST_TEST(!(o1  >= o2));
+  BOOST_TEST(!(o1  >= o2_));
+  BOOST_TEST(!(o1  >= o3));
+  BOOST_TEST(!(o1  >= o3_));
+  BOOST_TEST(!(o2  >= o3));
+  BOOST_TEST(!(o2_ >= o3));
+  BOOST_TEST(!(o2  >= o3_));
+  BOOST_TEST(!(o2_ >= o3_));
+  
+  BOOST_TEST(!(o1  < oN));
+  BOOST_TEST(!(o1  < oN_));
+  BOOST_TEST(!(o2  < oN));
+  BOOST_TEST(!(o2  < oN_));
+  BOOST_TEST(!(o2_ < oN));
+  BOOST_TEST(!(o2_ < oN_));
+  BOOST_TEST(!(o3  < oN));
+  BOOST_TEST(!(o3  < oN_));
+  BOOST_TEST(!(o3_ < oN));
+  BOOST_TEST(!(o3_ < oN_));
+  BOOST_TEST(!(o2  < oN));
+  BOOST_TEST(!(o2_ < oN_));
+  BOOST_TEST(!(o3  < oN));
+  BOOST_TEST(!(o3_ < oN_));
+  BOOST_TEST(!(o3  < oN));
+  BOOST_TEST(!(o3  < oN_));
+  BOOST_TEST(!(o3_ < oN));
+  BOOST_TEST(!(o3_ < oN_));
+}
+
+template <typename T>
+void test_swap()
+{
+  typename concrete_type_of<T>::type v1(1), v2(2);
+  optional<T&> o1(v1), o1_(v1), o2(v2), o2_(v2), oN, oN_;
+  
+  // swap(o1, o1); DOESN'T WORK
+}
+
+template <typename T>
+void test_optional_ref()
+{
+  test_not_containing_value_for<T>();
+  test_direct_init_for<T>();
+  test_clearing_the_value<T>();
+  test_arrow<T>();
+  test_equality<T>();
+  test_order<T>();
+  test_swap<T>();
+}
+
+template <typename T>
+void test_optional_const_ref()
+{
+  test_not_containing_value_for<const T>();
+  test_direct_init_for_const<T>();
+  test_direct_init_for_noconst_const<T>();
+  test_clearing_the_value<const T>();
+  test_arrow_const<T>();
+  test_arrow_noconst_const<T>();
+  test_equality<const T>();
+  test_order<const T>();
+  //test_swap<T>();
+}
+
+int main()
+{
+  test_optional_ref<int>();
+  test_optional_ref<ScopeGuard>();
+  //test_optional_ref<Abstract>();
+  
+  test_optional_const_ref<int>();
+  test_optional_const_ref<ScopeGuard>();
+  //test_optional_const_ref<Abstract>();
+  
+  return boost::report_errors();
+}

test/optional_test_swap.cpp

@@ -0,0 +1,361 @@
+// Copyright (C) 2003, 2008 Fernando Luis Cacciola Carballal.
+// Copyright (C) 2015 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:
+//  fernando_cacciola@hotmail.com
+//
+// Revisions:
+// 12 May 2008 (added more swap tests)
+//
+
+#include "boost/optional/optional.hpp"
+#include "boost/utility/in_place_factory.hpp"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#include "boost/core/lightweight_test.hpp"
+
+
+using boost::optional;
+using boost::none;
+
+#define ARG(T) (static_cast< T const* >(0))
+
+namespace optional_swap_test
+{
+  class default_ctor_exception : public std::exception {} ;
+  class copy_ctor_exception : public std::exception {} ;
+  class assignment_exception : public std::exception {} ;
+
+  //
+  // Base class for swap test classes.  Its assignment should not be called, when swapping
+  // optional<T> objects.  (The default std::swap would do so.)
+  //
+  class base_class_with_forbidden_assignment
+  {
+  public:
+    base_class_with_forbidden_assignment & operator=(const base_class_with_forbidden_assignment &)
+    {
+      BOOST_TEST(!"The assignment should not be used while swapping!");
+      throw assignment_exception();
+    }
+
+    virtual ~base_class_with_forbidden_assignment() {}
+  };
+
+  //
+  // Class without default constructor
+  //
+  class class_without_default_ctor : public base_class_with_forbidden_assignment
+  {
+  public:
+    char data;
+    explicit class_without_default_ctor(char arg) : data(arg) {}
+  };
+
+  //
+  // Class whose default constructor should not be used by optional::swap!
+  //
+  class class_whose_default_ctor_should_not_be_used : public base_class_with_forbidden_assignment
+  {
+  public:
+    char data;
+    explicit class_whose_default_ctor_should_not_be_used(char arg) : data(arg) {}
+
+    class_whose_default_ctor_should_not_be_used()
+    {
+      BOOST_TEST(!"This default constructor should not be used while swapping!");
+      throw default_ctor_exception();
+    }
+  };
+
+  //
+  // Class whose default constructor should be used by optional::swap.
+  // Its copy constructor should be avoided!
+  //
+  class class_whose_default_ctor_should_be_used : public base_class_with_forbidden_assignment
+  {
+  public:
+    char data;
+    explicit class_whose_default_ctor_should_be_used(char arg) : data(arg) { }
+
+    class_whose_default_ctor_should_be_used() : data('\0') { }
+
+    class_whose_default_ctor_should_be_used(const class_whose_default_ctor_should_be_used &)
+    {
+      BOOST_TEST(!"This copy constructor should not be used while swapping!");
+      throw copy_ctor_exception();
+    }
+  };
+
+  //
+  // Class template whose default constructor should be used by optional::swap.
+  // Its copy constructor should be avoided!
+  //
+  template <class T>
+  class template_whose_default_ctor_should_be_used : public base_class_with_forbidden_assignment
+  {
+  public:
+    T data;
+    explicit template_whose_default_ctor_should_be_used(T arg) : data(arg) { }
+
+    template_whose_default_ctor_should_be_used() : data('\0') { }
+
+    template_whose_default_ctor_should_be_used(const template_whose_default_ctor_should_be_used &)
+    {
+      BOOST_TEST(!"This copy constructor should not be used while swapping!");
+      throw copy_ctor_exception();
+    }
+  };
+
+  //
+  // Class whose explicit constructor should be used by optional::swap.
+  // Its other constructors should be avoided!
+  //
+  class class_whose_explicit_ctor_should_be_used : public base_class_with_forbidden_assignment
+  {
+  public:
+    char data;
+    explicit class_whose_explicit_ctor_should_be_used(char arg) : data(arg) { }
+
+    class_whose_explicit_ctor_should_be_used()
+    {
+      BOOST_TEST(!"This default constructor should not be used while swapping!");
+      throw default_ctor_exception();
+    }
+
+    class_whose_explicit_ctor_should_be_used(const class_whose_explicit_ctor_should_be_used &)
+    {
+      BOOST_TEST(!"This copy constructor should not be used while swapping!");
+      throw copy_ctor_exception();
+    }
+  };
+
+  void swap(class_whose_default_ctor_should_not_be_used & lhs, class_whose_default_ctor_should_not_be_used & rhs)
+  {
+    std::swap(lhs.data, rhs.data);
+  }
+
+  void swap(class_whose_default_ctor_should_be_used & lhs, class_whose_default_ctor_should_be_used & rhs)
+  {
+    std::swap(lhs.data, rhs.data);
+  }
+
+  void swap(class_without_default_ctor & lhs, class_without_default_ctor & rhs)
+  {
+    std::swap(lhs.data, rhs.data);
+  }
+
+  void swap(class_whose_explicit_ctor_should_be_used & lhs, class_whose_explicit_ctor_should_be_used & rhs)
+  {
+    std::swap(lhs.data, rhs.data);
+  }
+
+  template <class T>
+  void swap(template_whose_default_ctor_should_be_used<T> & lhs, template_whose_default_ctor_should_be_used<T> & rhs)
+  {
+    std::swap(lhs.data, rhs.data);
+  }
+
+  //
+  // optional<T>::swap should be customized when neither the copy constructor
+  // nor the default constructor of T are supposed to be used when swapping, e.g.,
+  // for the following type T = class_whose_explicit_ctor_should_be_used.
+  //
+  void swap(boost::optional<class_whose_explicit_ctor_should_be_used> & x, boost::optional<class_whose_explicit_ctor_should_be_used> & y)
+  {
+    bool hasX(x);
+    bool hasY(y);
+
+    if ( !hasX && !hasY )
+     return;
+
+    if( !hasX )
+       x = boost::in_place('\0');
+    else if ( !hasY )
+       y = boost::in_place('\0');
+
+    optional_swap_test::swap(*x,*y);
+
+     if( !hasX )
+         y = boost::none ;
+     else if( !hasY )
+         x = boost::none ;
+  }
+
+
+} // End of namespace optional_swap_test.
+
+
+namespace boost {
+
+//
+// Compile time tweaking on whether or not swap should use the default constructor:
+//
+
+template <> struct optional_swap_should_use_default_constructor<
+  optional_swap_test::class_whose_default_ctor_should_be_used> : mpl::true_ {} ;
+
+template <> struct optional_swap_should_use_default_constructor<
+  optional_swap_test::class_whose_default_ctor_should_not_be_used> : mpl::false_ {} ;
+
+template <class T> struct optional_swap_should_use_default_constructor<
+  optional_swap_test::template_whose_default_ctor_should_be_used<T> > : mpl::true_ {} ;
+
+
+//
+// Specialization of boost::swap:
+//
+template <>
+void swap(optional<optional_swap_test::class_whose_explicit_ctor_should_be_used> & x, optional<optional_swap_test::class_whose_explicit_ctor_should_be_used> & y)
+{
+  optional_swap_test::swap(x, y);
+}
+
+} // namespace boost
+
+
+namespace std {
+
+//
+// Specializations of std::swap:
+//
+
+template <>
+void swap(optional_swap_test::class_whose_default_ctor_should_be_used & x, optional_swap_test::class_whose_default_ctor_should_be_used & y)
+{
+  optional_swap_test::swap(x, y);
+}
+
+template <>
+void swap(optional_swap_test::class_whose_default_ctor_should_not_be_used & x, optional_swap_test::class_whose_default_ctor_should_not_be_used & y)
+{
+  optional_swap_test::swap(x, y);
+}
+
+template <>
+void swap(optional_swap_test::class_without_default_ctor & x, optional_swap_test::class_without_default_ctor & y)
+{
+  optional_swap_test::swap(x, y);
+}
+
+template <>
+void swap(optional_swap_test::class_whose_explicit_ctor_should_be_used & x, optional_swap_test::class_whose_explicit_ctor_should_be_used & y)
+{
+  optional_swap_test::swap(x, y);
+}
+
+} // namespace std
+
+
+//
+// Tests whether the swap function works properly for optional<T>.
+// Assumes that T has one data member, of type char.
+// Returns true iff the test is passed.
+//
+template <class T>
+void test_swap_function( T const* )
+{
+  try
+  {
+    optional<T> obj1;
+    optional<T> obj2('a');
+
+    // Self-swap should not have any effect.
+    swap(obj1, obj1);
+    swap(obj2, obj2);
+    BOOST_TEST(!obj1);
+    BOOST_TEST(!!obj2 && obj2->data == 'a');
+
+    // Call non-member swap.
+    swap(obj1, obj2);
+
+    // Test if obj1 and obj2 are really swapped.
+    BOOST_TEST(!!obj1 && obj1->data == 'a');
+    BOOST_TEST(!obj2);
+
+    // Call non-member swap one more time.
+    swap(obj1, obj2);
+
+    // Test if obj1 and obj2 are swapped back.
+    BOOST_TEST(!obj1);
+    BOOST_TEST(!!obj2 && obj2->data == 'a');
+  }
+  catch(const std::exception &)
+  {
+    // The swap function should not throw, for our test cases.
+    BOOST_TEST(!"throw in swap");
+  }
+}
+
+//
+// Tests whether the optional<T>::swap member function works properly.
+// Assumes that T has one data member, of type char.
+// Returns true iff the test is passed.
+//
+template <class T>
+void test_swap_member_function( T const* )
+{
+  try
+  {
+    optional<T> obj1;
+    optional<T> obj2('a');
+
+    // Self-swap should not have any effect.
+    obj1.swap(obj1);
+    obj2.swap(obj2);
+    BOOST_TEST(!obj1);
+    BOOST_TEST(!!obj2 && obj2->data == 'a');
+
+    // Call member swap.
+    obj1.swap(obj2);
+
+    // Test if obj1 and obj2 are really swapped.
+    BOOST_TEST(!!obj1 && obj1->data == 'a');
+    BOOST_TEST(!obj2);
+
+    // Call member swap one more time.
+    obj1.swap(obj2);
+
+    // Test if obj1 and obj2 are swapped back.
+    BOOST_TEST(!obj1);
+    BOOST_TEST(!!obj2 && obj2->data == 'a');
+  }
+  catch(const std::exception &)
+  {
+    BOOST_TEST(!"throw in swap");
+  }
+}
+
+
+//
+// Tests compile time tweaking of swap, by means of
+// optional_swap_should_use_default_constructor.
+//
+void test_swap_tweaking()
+{
+  ( test_swap_function( ARG(optional_swap_test::class_without_default_ctor) ) );
+  ( test_swap_function( ARG(optional_swap_test::class_whose_default_ctor_should_be_used) ) );
+  ( test_swap_function( ARG(optional_swap_test::class_whose_default_ctor_should_not_be_used) ) );
+  ( test_swap_function( ARG(optional_swap_test::class_whose_explicit_ctor_should_be_used) ) );
+  ( test_swap_function( ARG(optional_swap_test::template_whose_default_ctor_should_be_used<char>) ) );
+  ( test_swap_member_function( ARG(optional_swap_test::class_without_default_ctor) ) );
+  ( test_swap_member_function( ARG(optional_swap_test::class_whose_default_ctor_should_be_used) ) );
+  ( test_swap_member_function( ARG(optional_swap_test::class_whose_default_ctor_should_not_be_used) ) );
+  ( test_swap_member_function( ARG(optional_swap_test::class_whose_explicit_ctor_should_be_used) ) );
+  ( test_swap_member_function( ARG(optional_swap_test::template_whose_default_ctor_should_be_used<char>) ) );
+}
+
+int main()
+{
+  test_swap_tweaking();
+  return boost::report_errors();
+}