diff --git a/doc/00_optional.qbk b/doc/00_optional.qbk index d1a2275..14f4d4a 100644 --- a/doc/00_optional.qbk +++ b/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-2015 Andrzej Krzemieński] + [copyright 2014-2016 Andrzej Krzemieński] [category miscellaneous] [id optional] [dirname optional] diff --git a/doc/11_development.qbk b/doc/11_development.qbk index 9e3ef44..de5d00d 100644 --- a/doc/11_development.qbk +++ b/doc/11_development.qbk @@ -228,7 +228,7 @@ For value access operations `optional<>` uses operators `*` and `->` to lexically warn about the possibly uninitialized state appealing to the familiar pointer semantics w.r.t. to null pointers. -[warning +[caution However, it is particularly important to note that `optional<>` objects are not pointers. [_`optional<>` is not, and does not model, a pointer]. ] diff --git a/doc/15_optional_references.qbk b/doc/15_optional_references.qbk index 2f8b3c6..acb1226 100644 --- a/doc/15_optional_references.qbk +++ b/doc/15_optional_references.qbk @@ -1,6 +1,8 @@  [section Optional references] +[section Overview] + This library allows the template parameter `T` to be of reference type: `T&`, and to some extent, `T const&`. @@ -21,7 +23,7 @@ will nonetheless refer to the same object. * Value-access will actually provide access to the referenced object rather than the reference itself. -[warning On compilers that do not conform to Standard C++ rules of reference binding, operations on optional references might give adverse results: rather than binding a reference to a designated object they may create an unexpected temporary and bind to it. For more details see [link boost_optional.dependencies_and_portability.optional_reference_binding Dependencies and Portability section].] +[caution On compilers that do not conform to Standard C++ rules of reference binding, some operations on optional references are disabled in order to prevent subtle bugs. For more details see [link boost_optional.dependencies_and_portability.optional_reference_binding Dependencies and Portability section].] [heading Rvalue references] @@ -118,3 +120,4 @@ In such a scenario, you can assign the value itself directly, as in: *opt=value; [endsect] +[endsect] diff --git a/doc/27_ref_optional_synopsis.qbk b/doc/27_ref_optional_synopsis.qbk index 042dd3d..6a4f853 100644 --- a/doc/27_ref_optional_synopsis.qbk +++ b/doc/27_ref_optional_synopsis.qbk @@ -9,21 +9,79 @@ ] -[#ref_header_optional_optional_hpp][section:header_optional_optional Synopsis] +[#ref_header_optional_optional_hpp] [section:header_optional_optional Synopsis] ```// In Header: <`[@boost:/boost/optional/optional.hpp boost/optional/optional.hpp]'''>'''`` namespace boost { + template + class optional ; ``[link reference_operator_template __GO_TO__]`` + + template + class optional ; ``[link reference_operator_template_spec __GO_TO__]`` + + template inline bool operator == ( optional const& x, optional const& y ) ; ``[link reference_operator_compare_equal_optional_optional __GO_TO__]`` + + template inline bool operator != ( optional const& x, optional const& y ) ; ``[link reference_operator_compare_not_equal_optional_optional __GO_TO__]`` + + template inline bool operator < ( optional const& x, optional const& y ) ; ``[link reference_operator_compare_less_optional_optional __GO_TO__]`` + + template inline bool operator > ( optional const& x, optional const& y ) ; ``[link reference_operator_compare_greater_optional_optional __GO_TO__]`` + + template inline bool operator <= ( optional const& x, optional const& y ) ; ``[link reference_operator_compare_less_or_equal_optional_optional __GO_TO__]`` + + template inline bool operator >= ( optional const& x, optional const& y ) ; ``[link reference_operator_compare_greater_or_equal_optional_optional __GO_TO__]`` + + template inline bool operator == ( optional const& x, none_t ) noexcept ; ``[link reference_operator_compare_equal_optional_none __GO_TO__]`` + + template inline bool operator != ( optional const& x, none_t ) noexcept ; ``[link reference_operator_compare_not_equal_optional_none __GO_TO__]`` + + template inline optional make_optional ( T const& v ) ; ``[link reference_make_optional_value __GO_TO__]`` + + template inline optional make_optional ( bool condition, T const& v ) ; ``[link reference_make_optional_bool_value __GO_TO__]`` + + template inline auto get_optional_value_or ( optional const& opt, typename optional::reference_const_type def ) -> typename optional::reference_const_type; ``[link reference_free_get_value_or __GO_TO__]`` + + template inline auto get_optional_value_or ( optional const& opt, typename optional::reference_type def ) -> typename optional::reference_type ; ``[link reference_free_get_value_or __GO_TO__]`` + + template inline T const& get ( optional const& opt ) ; ``[link reference_optional_get __GO_TO__]`` + + template inline T& get ( optional & opt ) ; ``[link reference_optional_get __GO_TO__]`` + + template inline T const* get ( optional const* opt ) ; ``[link reference_optional_get __GO_TO__]`` + + template inline T* get ( optional* opt ) ; ``[link reference_optional_get __GO_TO__]`` + + template inline auto get_pointer ( optional const& opt ) -> ``['see below]``; ``[link reference_free_get_pointer __GO_TO__]`` + + template inline auto get_pointer ( optional & opt ) -> ``['see below]``; ``[link reference_free_get_pointer __GO_TO__]`` + + template inline void swap( optional& x, optional& y ) ; ``[link reference_swap_optional_optional __GO_TO__]`` + + template inline void swap( optional& x, optional& y ) ; ``[link reference_swap_optional_reference __GO_TO__]`` + + } // namespace boost + + +[endsect] + + +[section:header_optional_optional_values Optional Values] + +[#reference_operator_template] + template class optional { public : - typedef T value_type; + typedef T value_type ; + typedef T & reference_type ; + typedef T const& reference_const_type ; + typedef T * pointer_type ; + typedef T const* pointer_const_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__]`` @@ -109,43 +167,79 @@ T const& get_value_or( T const& default ) const ; ``[link reference_optional_get_value_or_value __GO_TO__]`` }; - template inline bool operator == ( optional const& x, optional const& y ) ; ``[link reference_operator_compare_equal_optional_optional __GO_TO__]`` - - template inline bool operator != ( optional const& x, optional const& y ) ; ``[link reference_operator_compare_not_equal_optional_optional __GO_TO__]`` - - template inline bool operator < ( optional const& x, optional const& y ) ; ``[link reference_operator_compare_less_optional_optional __GO_TO__]`` - - template inline bool operator > ( optional const& x, optional const& y ) ; ``[link reference_operator_compare_greater_optional_optional __GO_TO__]`` - - template inline bool operator <= ( optional const& x, optional const& y ) ; ``[link reference_operator_compare_less_or_equal_optional_optional __GO_TO__]`` - - template inline bool operator >= ( optional const& x, optional const& y ) ; ``[link reference_operator_compare_greater_or_equal_optional_optional __GO_TO__]`` - - template inline bool operator == ( optional const& x, none_t ) noexcept ; ``[link reference_operator_compare_equal_optional_none __GO_TO__]`` - - template inline bool operator != ( optional const& x, none_t ) noexcept ; ``[link reference_operator_compare_not_equal_optional_none __GO_TO__]`` - - template inline optional make_optional ( T const& v ) ; ``[link reference_make_optional_value __GO_TO__]`` - - template inline optional make_optional ( bool condition, T const& v ) ; ``[link reference_make_optional_bool_value __GO_TO__]`` - - template inline T const& get_optional_value_or ( optional const& opt, T const& default ) ; ``[link reference_optional_get_value_or_value __GO_TO__]`` - - template inline T const& get ( optional const& opt ) ; ``[link reference_optional_get __GO_TO__]`` - - template inline T& get ( optional & opt ) ; ``[link reference_optional_get __GO_TO__]`` - - template inline T const* get ( optional const* opt ) ; ``[link reference_optional_get __GO_TO__]`` - - template inline T* get ( optional* opt ) ; ``[link reference_optional_get __GO_TO__]`` - - template inline T const* get_pointer ( optional const& opt ) ; ``[link reference_optional_get_ptr __GO_TO__]`` - - template inline T* get_pointer ( optional & opt ) ; ``[link reference_optional_get_ptr __GO_TO__]`` - - template inline void swap( optional& x, optional& y ) ; ``[link reference_swap_optional_optional __GO_TO__]`` - - } // namespace boost - [endsect] + + +[section:header_optional_optional_refs Optional References] + +[#reference_operator_template_spec] + template + class optional // specilization for lvalue references + { + public : + + typedef T& value_type; + typedef T& reference_type; + typedef T& reference_const_type; // no const propagation + typedef T* pointer_type; + typedef T* pointer_const_type; // no const propagation + + optional () noexcept ; ``[link reference_optional_ref_default_ctor __GO_TO__]`` + + optional ( none_t ) noexcept ; ``[link reference_optional_ref_default_ctor __GO_TO__]`` + + template optional(R&& r) noexcept ; ``[link reference_optional_ref_value_ctor __GO_TO__]`` + + template optional(bool cond, R&& r) noexcept ; ``[link reference_optional_ref_cond_value_ctor __GO_TO__]`` + + optional ( optional const& rhs ) noexcept ; ``[link reference_optional_ref_copy_ctor __GO_TO__]`` + + template explicit optional ( optional const& rhs ) noexcept ; ``[link reference_optional_ref_ctor_from_opt_U __GO_TO__]`` + + optional& operator = ( none_t ) noexcept ; ``[link reference_optional_ref_assign_none_t __GO_TO__]`` + + + optional& operator = ( optional const& rhs ) noexcept; ``[link reference_optional_ref_copy_assign __GO_TO__]`` + + template optional& operator = ( optional const& rhs ) noexcept ; ``[link reference_optional_ref_assign_optional_U __GO_TO__]`` + + template optional& operator = (R&& r) noexcept ; ``[link reference_optional_ref_assign_R __GO_TO__]`` + + template void emplace ( R&& r ) noexcept ; ``[link reference_optional_ref_emplace_R __GO_TO__]`` + + T& get() const ; ``[link reference_optional_ref_get __GO_TO__]`` + T& operator *() const ; ``[link reference_optional_ref_get __GO_TO__]`` + + T* operator ->() const ; ``[link reference_optional_ref_arrow __GO_TO__]`` + + T& value() const& ; ``[link reference_optional_ref_value __GO_TO__]`` + + template T& value_or( R && r ) const noexcept ; ``[link reference_optional_ref_value_or __GO_TO__]`` + + template T& value_or_eval( F f ) const ; ``[link reference_optional_ref_value_or_eval __GO_TO__]`` + + T* get_ptr() const noexcept ; ``[link reference_optional_ref_get_ptr __GO_TO__]`` + + explicit operator bool() const noexcept ; ``[link reference_optional_ref_operator_bool __GO_TO__]`` + + bool operator!() const noexcept ; ``[link reference_optional_ref_operator_not __GO_TO__]`` + + // deprecated methods + + // (deprecated) + void reset() noexcept ; ``[link reference_optional_ref_reset __GO_TO__]`` + + // (deprecated) + template void reset ( R && r ) noexcept ; ``[link reference_optional_ref_reset_value __GO_TO__]`` + + // (deprecated) + bool is_initialized() const noexcept ; ``[link reference_optional_ref_is_initialized __GO_TO__]`` + + // (deprecated) + template T& get_value_or( R && r ) constnoexcept; ``[link reference_optional_ref_get_value_or_value __GO_TO__]`` + + private: + T* ref; // exposition only + }; +[endsect] diff --git a/doc/28_ref_optional_semantics.qbk b/doc/28_ref_optional_semantics.qbk index 791eb99..31dc178 100644 --- a/doc/28_ref_optional_semantics.qbk +++ b/doc/28_ref_optional_semantics.qbk @@ -9,18 +9,7 @@ ] -[section Detailed Semantics] - -Because `T` might be of reference type, in the sequel, those entries whose -semantic depends on `T` being of reference type or not will be distinguished -using the following convention: - -* If the entry reads: `optional`, the description -corresponds only to the case where `T` is not of reference type. -* If the entry reads: `optional`, the description corresponds only to -the case where `T` is of reference type. -* If the entry reads: `optional`, the description is the same for both -cases. +[section Detailed Semantics - Optional Values] [note The following section contains various `assert()` which are used only to show @@ -29,9 +18,6 @@ support each particular expression but that if the expression is supported, the implied condition holds. ] -__SPACE__ - -[heading optional class member functions] __SPACE__ @@ -70,7 +56,7 @@ __SPACE__ [#reference_optional_constructor_value] -[: `optional::optional( T const& v )`] +[: `optional::optional( T const& v )`] * [*Requires:] `is_copy_constructible::value` is `true`. * [*Effect:] Directly-Constructs an `optional`. @@ -87,29 +73,12 @@ optional opt(v); assert ( *opt == v ) ; `` -__SPACE__ - -[: `optional::optional( T& ref )`] - -* [*Effect:] Directly-Constructs an `optional`. -* [*Postconditions:] `*this` is [_initialized] and its value is an instance -of an internal type wrapping the reference `ref`. -* [*Throws:] Nothing. -* [*Example:] -`` -T v; -T& vref = v ; -optional opt(vref); -assert ( *opt == v ) ; -++ v ; // mutate referee -assert (*opt == v); -`` __SPACE__ [#reference_optional_constructor_move_value] -[: `optional::optional( T&& v )`] +[: `optional::optional( T&& v )`] * [*Requires:] `is_move_constructible::value` is `true`. * [*Effect:] Directly-Move-Constructs an `optional`. @@ -125,35 +94,27 @@ optional opt(std::move(v1)); assert ( *opt == v2 ) ; `` -__SPACE__ - -[: `optional::optional( T&& ref ) = delete`] - -* [*Notes:] This constructor is deleted - __SPACE__ [#reference_optional_constructor_bool_value] -[: `optional::optional( bool condition, T const& v ) ;` ] -[: `optional ::optional( bool condition, T& v ) ;` ] +[: `optional::optional( bool condition, T const& v ) ;` ] * If condition is true, same as: -[: `optional::optional( T const& v )`] -[: `optional ::optional( T& v )`] +[: `optional::optional( T const& v )`] * otherwise, same as: -[: `optional::optional()`] -[: `optional ::optional()`] +[: `optional::optional()`] + __SPACE__ [#reference_optional_constructor_optional] -[: `optional::optional( optional const& rhs );`] +[: `optional::optional( optional const& rhs );`] * [*Requires:] `is_copy_constructible::value` is `true`. * [*Effect:] Copy-Constructs an `optional`. @@ -178,43 +139,12 @@ optional init2 ( init ) ; assert ( init2 == init ) ; `` -__SPACE__ - -[: `optional::optional( optional const& rhs );`] - -* [*Effect:] Copy-Constructs an `optional`. -* [*Postconditions:] If `rhs` is initialized, `*this` is initialized and its -value is another reference to the same object referenced by `*rhs`; else -`*this` is uninitialized. -* [*Throws:] Nothing. -* [*Notes:] If `rhs` is initialized, both `*this` and `*rhs` will refer to the -same object (they alias). -* [*Example:] -`` -optional uninit ; -assert (!uninit); - -optional uinit2 ( uninit ) ; -assert ( uninit2 == uninit ); - -T v = 2 ; T& ref = v ; -optional init(ref); -assert ( *init == v ) ; - -optional init2 ( init ) ; -assert ( *init2 == v ) ; - -v = 3 ; - -assert ( *init == 3 ) ; -assert ( *init2 == 3 ) ; -`` __SPACE__ [#reference_optional_move_constructor_optional] -[: `optional::optional( optional&& rhs ) noexcept(`['see below]`);`] +[: `optional::optional( optional&& rhs ) noexcept(`['see below]`);`] * [*Requires:] `is_move_constructible::value` is `true`. * [*Effect:] Move-constructs an `optional`. @@ -243,43 +173,12 @@ assert ( init2 ); assert ( **init2 == T(2) ) ; `` -__SPACE__ - -[: `optional::optional( optional && rhs );`] - -* [*Effect:] Move-Constructs an `optional`. -* [*Postconditions:] If `rhs` is initialized, `*this` is initialized and its -value is another reference to the same object referenced by `*rhs`; else -`*this` is uninitialized. -* [*Throws:] Nothing. -* [*Notes:] If `rhs` is initialized, both `*this` and `*rhs` will refer to the -same object (they alias). -* [*Example:] -`` -optional&> uninit ; -assert (!uninit); - -optional&> uinit2 ( std::move(uninit) ) ; -assert ( uninit2 == uninit ); - -std::unique_ptr v(new T(2)) ; -optional&> init(v); -assert ( *init == v ) ; - -optional&> init2 ( std::move(init) ) ; -assert ( *init2 == v ) ; - -*v = 3 ; - -assert ( **init == 3 ) ; -assert ( **init2 == 3 ) ; -`` __SPACE__ [#reference_optional_constructor_other_optional] -[: `template explicit optional::optional( optional const& rhs );`] +[: `template explicit optional::optional( optional const& rhs );`] * [*Effect:] Copy-Constructs an `optional`. * [*Postconditions:] If `rhs` is initialized, `*this` is initialized and its @@ -303,7 +202,7 @@ __SPACE__ [#reference_optional_move_constructor_other_optional] -[: `template explicit optional::optional( optional&& rhs );`] +[: `template explicit optional::optional( optional&& rhs );`] * [*Effect:] Move-constructs an `optional`. * [*Postconditions:] If `rhs` is initialized, `*this` is initialized and its @@ -327,8 +226,8 @@ __SPACE__ [#reference_optional_constructor_factory] -[: `template explicit optional::optional( InPlaceFactory const& f );`] -[: `template explicit optional::optional( TypedInPlaceFactory const& f );`] +[: `template explicit optional::optional( InPlaceFactory const& f );`] +[: `template explicit optional::optional( TypedInPlaceFactory const& f );`] * [*Effect:] Constructs an `optional` with a value of `T` obtained from the factory. @@ -365,7 +264,7 @@ __SPACE__ [#reference_optional_operator_equal_value] -[: `optional& optional::operator= ( T const& rhs ) ;`] +[: `optional& optional::operator= ( T const& rhs ) ;`] * [*Effect:] Assigns the value `rhs` to an `optional`. * [*Postconditions: ] `*this` is initialized and its value is a ['copy] of `rhs`. @@ -390,40 +289,12 @@ opt = y ; assert ( *opt == y ) ; `` -__SPACE__ - -[: `optional& optional::operator= ( T& rhs ) ;`] - -* [*Effect:] (Re)binds the wrapped reference. -* [*Postconditions: ] `*this` is initialized and it references the same -object referenced by `rhs`. -* [*Notes:] If `*this` was initialized, it is ['rebound] to the new object. -See [link boost_optional.tutorial.rebinding_semantics_for_assignment_of_optional_references here] for details on this behavior. -* [*Example:] -`` -int a = 1 ; -int b = 2 ; -T& ra = a ; -T& rb = b ; -optional def ; -optional opt(ra) ; - -def = rb ; // binds 'def' to 'b' through 'rb' -assert ( *def == b ) ; -*def = a ; // changes the value of 'b' to a copy of the value of 'a' -assert ( b == a ) ; -int c = 3; -int& rc = c ; -opt = rc ; // REBINDS to 'c' through 'rc' -c = 4 ; -assert ( *opt == 4 ) ; -`` __SPACE__ [#reference_optional_operator_move_equal_value] -[: `optional& optional::operator= ( T&& rhs ) ;`] +[: `optional& optional::operator= ( T&& rhs ) ;`] * [*Effect:] Moves the value `rhs` to an `optional`. * [*Postconditions: ] `*this` is initialized and its value is moved from `rhs`. @@ -448,18 +319,12 @@ opt = std::move(y2) ; assert ( *opt == yR ) ; `` -__SPACE__ - -[: `optional& optional::operator= ( T&& rhs ) = delete;`] - -* [*Notes:] This assignment operator is deleted. - __SPACE__ [#reference_optional_operator_equal_optional] -[: `optional& optional::operator= ( optional const& rhs ) ;`] +[: `optional& optional::operator= ( optional const& rhs ) ;`] * [*Requires:] `T` is __COPY_CONSTRUCTIBLE__ and `CopyAssignable`. * [*Effects:] @@ -485,43 +350,12 @@ assert ( !def ) ; // previous value (copy of 'v') destroyed from within 'opt'. `` -__SPACE__ - -[: `optional & optional::operator= ( optional const& rhs ) ;`] - -* [*Effect:] (Re)binds thee wrapped reference. -* [*Postconditions:] If `*rhs` is initialized, `*this` is initialized and it -references the same object referenced by `*rhs`; otherwise, `*this` is -uninitialized (and references no object). -* [*Notes:] If `*this` was initialized and so is `*rhs`, `*this` is ['rebound] to -the new object. See [link boost_optional.tutorial.rebinding_semantics_for_assignment_of_optional_references here] for details on this behavior. -* [*Example:] -`` -int a = 1 ; -int b = 2 ; -T& ra = a ; -T& rb = b ; -optional def ; -optional ora(ra) ; -optional orb(rb) ; - -def = orb ; // binds 'def' to 'b' through 'rb' wrapped within 'orb' -assert ( *def == b ) ; -*def = ora ; // changes the value of 'b' to a copy of the value of 'a' -assert ( b == a ) ; -int c = 3; -int& rc = c ; -optional orc(rc) ; -ora = orc ; // REBINDS ora to 'c' through 'rc' -c = 4 ; -assert ( *ora == 4 ) ; -`` __SPACE__ [#reference_optional_operator_move_equal_optional] -[: `optional& optional::operator= ( optional&& rhs ) noexcept(`['see below]`);`] +[: `optional& optional::operator= ( optional&& rhs ) noexcept(`['see below]`);`] * [*Requires:] `T` is __MOVE_CONSTRUCTIBLE__ and `MoveAssignable`. * [*Effects:] @@ -548,18 +382,13 @@ assert ( opt ) ; assert ( *opt == T(2) ) ; `` -__SPACE__ - -[: `optional & optional::operator= ( optional&& rhs ) ;`] - -* [*Effect:] Same as `optional::operator= ( optional const& rhs )`. __SPACE__ [#reference_optional_operator_equal_other_optional] -[: `template optional& optional::operator= ( optional const& rhs ) ;`] +[: `template optional& optional::operator= ( optional const& rhs ) ;`] * [*Effect:] [table @@ -587,7 +416,7 @@ __SPACE__ [#reference_optional_operator_move_equal_other_optional] -[: `template optional& optional::operator= ( optional&& rhs ) ;`] +[: `template optional& optional::operator= ( optional&& rhs ) ;`] * [*Effect:] [table @@ -617,7 +446,7 @@ __SPACE__ [#reference_optional_emplace] -[: `template void optional::emplace( Args...&& args );`] +[: `template void optional::emplace( Args...&& args );`] * [*Requires:] The compiler supports rvalue references and variadic templates. * [*Effect:] If `*this` is initialized calls `*this = none`. @@ -642,8 +471,8 @@ __SPACE__ [#reference_optional_operator_equal_factory] -[: `template optional& optional::operator=( InPlaceFactory const& f );`] -[: `template optional& optional::operator=( TypedInPlaceFactory const& f );`] +[: `template optional& optional::operator=( InPlaceFactory const& f );`] +[: `template optional& optional::operator=( TypedInPlaceFactory const& f );`] * [*Effect:] Assigns an `optional` with a value of `T` obtained from the factory. @@ -659,7 +488,7 @@ __SPACE__ [#reference_optional_reset_value] -[: `void optional::reset( T const& v ) ;`] +[: `void optional::reset( T const& v ) ;`] * [*Deprecated:] same as `operator= ( T const& v) ;` __SPACE__ @@ -673,36 +502,24 @@ __SPACE__ [#reference_optional_get] -[: `T const& optional::get() const ;`] -[: `T& optional::get() ;`] +[: `T const& optional::get() const ;`] +[: `T& optional::get() ;`] -[: `inline T const& get ( optional const& ) ;`] -[: `inline T& get ( optional &) ;`] +[: `inline T const& get ( optional const& ) ;`] +[: `inline T& get ( optional &) ;`] * [*Requires:] `*this` is initialized * [*Returns:] A reference to the contained value * [*Throws:] Nothing. * [*Notes:] The requirement is asserted via `BOOST_ASSERT()`. -__SPACE__ - -[: `T const& optional::get() const ;`] -[: `T& optional::get() ;`] - -[: `inline T const& get ( optional const& ) ;`] -[: `inline T& get ( optional &) ;`] - -* [*Requires: ] `*this` is initialized -* [*Returns:] [_The] reference contained. -* [*Throws:] Nothing. -* [*Notes:] The requirement is asserted via `BOOST_ASSERT()`. __SPACE__ [#reference_optional_operator_asterisk] -[: `T const& optional::operator*() const& ;`] -[: `T& optional::operator*() &;`] +[: `T const& optional::operator*() const& ;`] +[: `T& optional::operator*() &;`] * [*Requires:] `*this` is initialized * [*Returns:] A reference to the contained value @@ -723,32 +540,12 @@ __SPACE__ [#reference_optional_operator_asterisk_move] -[: `T&& optional::operator*() &&;`] +[: `T&& optional::operator*() &&;`] * [*Requires:] `*this` contains a value. * [*Effects:] Equivalent to `return std::move(*val);`. * [*Notes:] The requirement is asserted via `BOOST_ASSERT()`. On compilers that do not support ref-qualifiers on member functions this overload is not present. -__SPACE__ - -[: `T & optional::operator*() const& ;`] -[: `T & optional::operator*() & ;`] -[: `T & optional::operator*() && ;`] - -* [*Requires: ] `*this` is initialized -* [*Returns:] [_The] reference contained. -* [*Throws:] Nothing. -* [*Notes:] The requirement is asserted via `BOOST_ASSERT()`. On compilers that do not support ref-qualifiers on member functions these three overloads are replaced with the classical two: a `const` and non-`const` member functions. -* [*Example:] -`` -T v ; -T& vref = v ; -optional opt ( vref ); -T const& vref2 = *opt; -assert ( vref2 == v ) ; -++ v ; -assert ( *opt == v ) ; -`` __SPACE__ @@ -845,11 +642,8 @@ __SPACE__ [#reference_optional_get_value_or_value] -[: `T const& optional::get_value_or( T const& default) const ;`] -[: `T& optional::get_value_or( T& default ) ;`] - -[: `inline T const& get_optional_value_or ( optional const& o, T const& default ) ;`] -[: `inline T& get_optional_value_or ( optional& o, T& default ) ;`] +[: `T const& optional::get_value_or( T const& default) const ;`] +[: `T& optional::get_value_or( T& default ) ;`] * [*Deprecated:] Use `value_or()` instead. * [*Returns:] A reference to the contained value, if any, or `default`. @@ -862,7 +656,7 @@ T const& y = def.get_value_or(z); assert ( y == z ) ; optional opt ( v ); -T const& u = get_optional_value_or(opt,z); +T const& u = opt.get_value_or(z); assert ( u == v ) ; assert ( u != z ) ; `` @@ -872,11 +666,8 @@ __SPACE__ [#reference_optional_get_ptr] -[: `T const* optional::get_ptr() const ;`] -[: `T* optional::get_ptr() ;`] - -[: `inline T const* get_pointer ( optional const& ) ;`] -[: `inline T* get_pointer ( optional &) ;`] +[: `T const* optional::get_ptr() const ;`] +[: `T* optional::get_ptr() ;`] * [*Returns:] If `*this` is initialized, a pointer to the contained value; else `0` (['null]). @@ -898,8 +689,8 @@ __SPACE__ [#reference_optional_operator_arrow] -[: `T const* optional::operator ->() const ;`] -[: `T* optional::operator ->() ;`] +[: `T const* optional::operator ->() const ;`] +[: `T* optional::operator ->() ;`] * [*Requires: ] `*this` is initialized. * [*Returns:] A pointer to the contained value. @@ -957,15 +748,300 @@ __SPACE__ * [*Deprecated:] Same as `explicit operator bool () ;` + +[endsect] + +[section Detailed Semantics - Optional References] + __SPACE__ -[heading Free functions] +[#reference_optional_ref_default_ctor] + +[: `optional::optional() noexcept;`] +[: `optional::optional(none_t) noexcept;`] + +* [*Postconditions:] `bool(*this) == false`; `*this` refers to nothing. + + +__SPACE__ + +[#reference_optional_ref_value_ctor] + +[: `template optional::optional(R&& r) noexcept;`] +* [*Postconditions:] `bool(*this) == true`; `addressof(**this) == addressof(r)`. +* [*Remarks:] Unless `R` is an lvalue reference, the program is ill-formed. This constructor does not participate in overload resolution if `decay` is an instance of `boost::optional`. +* [*Example:] +`` +T v; +T& vref = v ; +optional opt(vref); +assert ( *opt == v ) ; +++ v ; // mutate referee +assert (*opt == v); +`` + +__SPACE__ + +[#reference_optional_ref_cond_value_ctor] + +[: `template optional::optional(bool cond, R&& r) noexcept;`] +* [*Effects: ] Initializes `ref` with expression `cond ? addressof(r) : nullptr`. +* [*Postconditions:] `bool(*this) == cond`; If `bool(*this)`, `addressof(**this) == addressof(r)`. +* [*Remarks:] Unless `R` is an lvalue reference, the program is ill-formed. This constructor does not participate in overload resolution if `decay` is an instance of `boost::optional`. + +__SPACE__ + +[#reference_optional_ref_copy_ctor] + +[: `optional::optional ( optional const& rhs ) noexcept ;`] + +* [*Effects: ] Initializes `ref` with expression `rhs.ref`. + +* [*Postconditions:] `bool(*this) == bool(rhs)`. + +* [*Example:] +`` +optional uninit ; +assert (!uninit); + +optional uinit2 ( uninit ) ; +assert ( uninit2 == uninit ); + +T v = 2 ; T& ref = v ; +optional init(ref); +assert ( *init == v ) ; + +optional init2 ( init ) ; +assert ( *init2 == v ) ; + +v = 3 ; + +assert ( *init == 3 ) ; +assert ( *init2 == 3 ) ; +`` + +__SPACE__ + +[#reference_optional_ref_ctor_from_opt_U] + +[: `template explicit optional::optional ( optional const& rhs ) noexcept ;`] + +* [*Requires:] `is_convertible::value` is `true`. + +* [*Effects: ] Initializes `ref` with expression `rhs.ref`. + +* [*Postconditions:] `bool(*this) == bool(rhs)`. + + +__SPACE__ + +[#reference_optional_ref_assign_none_t] + +[: `optional::operator= ( none_t ) noexcept ;`] + +* [*Effects: ] Assigns `ref` with expression `nullptr`. + +* [*returns:] `*this`. + +* [*Postconditions:] `bool(*this) == false`. + + + +[#reference_optional_ref_copy_assign] + +[: `optional& optional::operator= ( optional const& rhs ) noexcept ;`] + +* [*Effects: ] Assigns `ref` with expression `rhs.ref`. + +* [*returns:] `*this`. + +* [*Postconditions:] `bool(*this) == bool(rhs)`. + +* [*Notes:] This behaviour is called ['rebinding semantics]. See [link boost_optional.tutorial.optional_references.rebinding_semantics_for_assignment_of_optional_references here] for details. + +* [*Example:] +`` +int a = 1 ; +int b = 2 ; +T& ra = a ; +T& rb = b ; +optional def ; +optional ora(ra) ; +optional orb(rb) ; + +def = orb ; // binds 'def' to 'b' through 'rb' wrapped within 'orb' +assert ( *def == b ) ; +*def = ora ; // changes the value of 'b' to a copy of the value of 'a' +assert ( b == a ) ; +int c = 3; +int& rc = c ; +optional orc(rc) ; +ora = orc ; // REBINDS ora to 'c' through 'rc' +c = 4 ; +assert ( *ora == 4 ) ; +`` + + +[#reference_optional_ref_assign_optional_U] + +[: `template optional& optional::operator= ( optional const& rhs ) noexcept ;`] + +* [*Requires:] `is_convertible::value` is `true`. + +* [*Effects: ] Assigns `ref` with expression `rhs.ref`. + +* [*returns:] `*this`. + +* [*Postconditions:] `bool(*this) == bool(rhs)`. + + +__SPACE__ + +[#reference_optional_ref_assign_R] + +[: `template optional& optional::operator= ( R&& r ) noexcept ;`] + +* [*Effects: ] Assigns `ref` with expression `r`. + +* [*returns:] `*this`. + +* [*Postconditions:] `bool(*this) == true`. + +* [*Remarks:] Unless `R` is an lvalue reference, the program is ill-formed. This function does not participate in overload resolution if `decay` is an instance of `boost::optional`. + +* [*Example:] +`` +int a = 1 ; +int b = 2 ; +T& ra = a ; +T& rb = b ; +optional def ; +optional opt(ra) ; + +def = rb ; // binds 'def' to 'b' through 'rb' +assert ( *def == b ) ; +*def = a ; // changes the value of 'b' to a copy of the value of 'a' +assert ( b == a ) ; +int c = 3; +int& rc = c ; +opt = rc ; // REBINDS to 'c' through 'rc' +c = 4 ; +assert ( *opt == 4 ) ; +`` + +__SPACE__ + +[#reference_optional_ref_emplace_R] + +[: `void optional::emplace( R&& r ) noexcept ;`] +* [*Effects: ] Assigns `ref` with expression `r`. +* [*Postconditions:] `bool(*this) == true`. +* [*Remarks:] Unless `R` is an lvalue reference, the program is ill-formed. This function does not participate in overload resolution if `decay` is an instance of `boost::optional`. + +__SPACE__ + +[#reference_optional_ref_get] +[: `T& optional::get() const ;`] +[: `T& optional::operator *() const ;`] +* [*Requires:] `bool(*this) == true`. +* [*Effects: ] Returns `*ref`. +* [*Throws: ] Nothing. +* [*Example:] +`` +T v ; +T& vref = v ; +optional opt ( vref ); +T const& vref2 = *opt; +assert ( vref2 == v ) ; +++ v ; +assert ( *opt == v ) ; +`` + +__SPACE__ + +[#reference_optional_ref_arrow] +[: `T* optional::operator -> () const ;`] +* [*Requires:] `bool(*this) == true`. +* [*Effects: ] Returns `ref`. +* [*Throws: ] Nothing. + +__SPACE__ + +[#reference_optional_ref_value] +[: `T& optional::value() const ;`] +* [*Effects:] Equivalent to `return bool(*this) ? *val : throw bad_optional_access();`. + +__SPACE__ + +[#reference_optional_ref_value_or] +[: `template T& optional::value_or( R&& r ) const noexcept;`] +* [*Effects:] Equivalent to `if (*this) return **this; else return r;`. +* [*Remarks:] Unless `R` is an lvalue reference, the program is ill-formed. + +__SPACE__ + +[#reference_optional_ref_value_or_eval] +[: `template T& optional::value_or( F f ) const ;`] +* [*Effects:] Equivalent to `if (*this) return **this; else return f();`. +* [*Remarks:] Unless `decltype(f())` is an lvalue reference, the program is ill-formed. + +__SPACE__ + +[#reference_optional_ref_get_ptr] +[: `T* optional::get_ptr () const noexcept;`] +* [*Returns:] `ref`. + +__SPACE__ + +[#reference_optional_ref_operator_bool] +[: `optional::operator bool () const noexcept;`] +* [*Returns:] `bool(ref)`. + +__SPACE__ + +[#reference_optional_ref_operator_not] +[: `optional::operator ! () const noexcept;`] +* [*Returns:] `!bool(ref)`. + +__SPACE__ + +[#reference_optional_ref_reset] +[: `void optional::reset() noexcept;`] +* [*Effects:] Use `*this = none` instead. +* [*Remarks:] This function is depprecated. + +__SPACE__ + +[#reference_optional_ref_reset_value] +[: `template void optional::reset ( R&& r) noexcept;`] +* [*Effects:] Equivalent to `*this = std::forward(r)`. +* [*Remarks:] This function is depprecated. + +__SPACE__ + +[#reference_optional_ref_is_initialized] +[: `bool optional::is_initialized() const noexcept;`] +* [*Effects:] Equivalent to `return bool(*this)`. +* [*Remarks:] This function is depprecated. + +__SPACE__ + +[#reference_optional_ref_get_value_or_value] +[: `template T& optional::get_value_or( R&& r ) const noexcept;`] +* [*Effects:] Equivalent to `return value_or(std::forward(r);`. +* [*Remarks:] This function is depprecated. + +[endsect] + + +[section Detailed Semantics - Free Functions] + __SPACE__ [#reference_make_optional_value] -[: `optional make_optional( T const& v )`] +[: `optional make_optional( T const& v )`] * [*Returns: ] `optional(v)` for the ['deduced] type `T` of `v`. * [*Example:] @@ -979,9 +1055,9 @@ __SPACE__ [#reference_make_optional_bool_value] -[: `optional make_optional( bool condition, T const& v )`] +[: `optional make_optional( bool condition, T const& v )`] -* [*Returns: ] `optional(condition,v)` for the ['deduced] type `T` of `v`. +* [*Returns: ] `optional(condition, v)` for the ['deduced] type `T` of `v`. * [*Example:] `` optional calculate_foo() @@ -1108,6 +1184,25 @@ __SPACE__ * [*Returns: ] `!( x == y );` +__SPACE__ + + +[#reference_free_get_pointer] +[: `auto get_pointer ( optional& o ) -> typename optional::pointer_type ;`] +[: `auto get_pointer ( optional const& o ) -> typename optional::pointer_const_type ;`] +* [*Returns:] `o.get_ptr()`. +* [*Throws:] Nothing. + +__SPACE__ + + +[#reference_free_get_value_or] +[: `auto get_optional_value_or ( optional& o, typename optional::reference_type def ) -> typename optional::reference_type ;`] +[: `auto get_optional_value_or ( optional const& o, typename optional::reference_const_type def ) -> typename optional::reference_const_type ;`] +* [*Returns:] `o.get_value_or(def)`. +* [*Throws:] Nothing. +* [*Remarks:] This function is deprecated. + __SPACE__ [#reference_swap_optional_optional] @@ -1147,4 +1242,30 @@ assert ( *optX == y ); assert ( *optY == x ); `` -[endsect] +__SPACE__ + +[#reference_swap_optional_reference] +[: `void swap ( optional& x, optional& y ) noexcept ;`] + +* [*Postconditions:] `x` refers to what `y` refererred to before the swap (if anything). `y` refers to whatever `x` referred to before the swap. + +* [*Example:] +`` +T x(12); +T y(21); + +optional opt0; +optional optX (x); +optional optY (y); + +boost::swap(optX, optY); +assert (addressof(*optX) == addressof(y)); +assert (addressof(*optY) == addressof(x)); + +boost::swap(opt0, optX); +assert ( opt0 ); +assert ( !optX ); +assert (addressof(*opt0) == addressof(y)); +`` + +[endsect] \ No newline at end of file diff --git a/doc/90_dependencies.qbk b/doc/90_dependencies.qbk index cf678dc..80e1803 100644 --- a/doc/90_dependencies.qbk +++ b/doc/90_dependencies.qbk @@ -30,17 +30,17 @@ The implementation uses the following other Boost modules: [section Optional Reference Binding] -On compilers that do not conform to Standard C++ rules of reference binding, operations on optional references might give adverse results: rather than binding a reference to a designated object they may create an unexpected temporary and bind to it. Compilers known to have these deficiencies include GCC versions 4.2, 4.3, 4.4, 4.5; QCC 4.4.2; MSVC versions 8.0, 9.0, 10.0, 11.0, 12.0. On these compilers prefer using direct-initialization and copy assignment of optional references to copy-initialization and assignment from `T&`: +A number of compilers incorrectly treat const lvalues of integral type as rvalues, and create an illegal temporary when binding to an lvalue reference to const in some expressions. This could result in creating an optional lvalue reference that is in fact bound to an unexpected temporary rather than to the intended object. In order to prevent hard to find run-time bugs, this library performs compile-time checks to prevent expressions that would otherwise bind an optional reference to an unexpected temporary. As a consequence, on certain compilers certain pieces of functionality in optional references are missing. In order to maintain a portability of your code across diferent compilers, it is recommended that you only stick to the minimum portable interface of optional references: prefer direct-initialization and copy assignment of optional references to copy-initialization and assignment from `T&`: const int i = 0; optional or1; - optional or2 = i; // not portable - or1 = i; // not portable + optional or2 = i; // caution: not portable + or1 = i; // caution: not portable optional or3(i); // portable or1 = optional(i); // portable -In order to check if your compiler correctly implements reference binding use this test program. +Compilers known to have these deficiencies include GCC versions 4.2, 4.3, 4.4, 4.5, 5.1, 5.2; QCC 4.4.2; MSVC versions 8.0, 9.0, 10.0, 11.0, 12.0. In order to check if your compiler correctly implements reference binding use this test program. #include diff --git a/doc/91_relnotes.qbk b/doc/91_relnotes.qbk index 8fecf89..dcf180d 100644 --- a/doc/91_relnotes.qbk +++ b/doc/91_relnotes.qbk @@ -1,7 +1,7 @@ [/ Boost.Optional - Copyright (c) 2015 Andrzej Krzemienski + Copyright (c) 2015, 2016 Andrzej Krzemienski Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at @@ -11,11 +11,25 @@ [section:relnotes Release Notes] + +[heading Boost Release 1.61] + +* Now `boost::optional` is specialized for reference parameters. This addresses a couple of issues: + * the `sizeof` of optional reference is that of a pointer, + * some bugs connected to copying optional references are gone, + * all run-time bugs caused by incorrect reference binding on some compilers are now turned into compile-time errors, + * you can swap optional references: it is like swapping pointers: shalow, underlying objects are not affected, + * optional references to abstract types work. +* Documented nested typedefs ([@https://svn.boost.org/trac/boost/ticket/5193 Trac #5193]). +* Made the perfect-forwarding constructor SFINAE-friendly, which fixes [@https://svn.boost.org/trac/boost/ticket/12002 Trac #12002]. However, this only works in the newer compilers that implement variadic macros and `decltype` correctly. + + [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] + +[heading Boost Release 1.59] * For C++03 compilers, added 0-argument overload for member function `emplace()`, and therewith removed the dependency on ``. * Fixed [@https://svn.boost.org/trac/boost/ticket/11241 Trac #11241]. diff --git a/doc/html/boost_optional/acknowledgements.html b/doc/html/boost_optional/acknowledgements.html index d025d50..2cd116c 100644 --- a/doc/html/boost_optional/acknowledgements.html +++ b/doc/html/boost_optional/acknowledgements.html @@ -116,7 +116,7 @@ -
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

diff --git a/doc/html/boost_optional/dependencies_and_portability.html b/doc/html/boost_optional/dependencies_and_portability.html index 7c30637..b24c517 100644 --- a/doc/html/boost_optional/dependencies_and_portability.html +++ b/doc/html/boost_optional/dependencies_and_portability.html @@ -75,7 +75,7 @@
-
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

diff --git a/doc/html/boost_optional/dependencies_and_portability/optional_reference_binding.html b/doc/html/boost_optional/dependencies_and_portability/optional_reference_binding.html index bb9f5d6..fbe4ba8 100644 --- a/doc/html/boost_optional/dependencies_and_portability/optional_reference_binding.html +++ b/doc/html/boost_optional/dependencies_and_portability/optional_reference_binding.html @@ -28,24 +28,30 @@ Reference Binding

- On compilers that do not conform to Standard C++ rules of reference binding, - operations on optional references might give adverse results: rather than - binding a reference to a designated object they may create an unexpected - temporary and bind to it. Compilers known to have these deficiencies include - GCC versions 4.2, 4.3, 4.4, 4.5; QCC 4.4.2; MSVC versions 8.0, 9.0, 10.0, - 11.0, 12.0. On these compilers prefer using direct-initialization and copy - assignment of optional references to copy-initialization and assignment from - T&: + A number of compilers incorrectly treat const lvalues of integral type as + rvalues, and create an illegal temporary when binding to an lvalue reference + to const in some expressions. This could result in creating an optional lvalue + reference that is in fact bound to an unexpected temporary rather than to + the intended object. In order to prevent hard to find run-time bugs, this + library performs compile-time checks to prevent expressions that would otherwise + bind an optional reference to an unexpected temporary. As a consequence, + on certain compilers certain pieces of functionality in optional references + are missing. In order to maintain a portability of your code across diferent + compilers, it is recommended that you only stick to the minimum portable + interface of optional references: prefer direct-initialization and copy assignment + of optional references to copy-initialization and assignment from T&: 

const int i = 0;
 optional<const int&> or1;
-optional<const int&> or2 = i;  // not portable
-or1 = i;                       // not portable
+optional<const int&> or2 = i;  // caution: not portable
+or1 = i;                       // caution: not portable
 
 optional<const int&> or3(i);   // portable
 or1 = optional<const int&>(i); // portable

+ Compilers known to have these deficiencies include GCC versions 4.2, 4.3, + 4.4, 4.5, 5.1, 5.2; QCC 4.4.2; MSVC versions 8.0, 9.0, 10.0, 11.0, 12.0. In order to check if your compiler correctly implements reference binding use this test program.

@@ -86,7 +92,7 @@ -
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

diff --git a/doc/html/boost_optional/quick_start.html b/doc/html/boost_optional/quick_start.html index d6b1c39..d68edf5 100644 --- a/doc/html/boost_optional/quick_start.html +++ b/doc/html/boost_optional/quick_start.html @@ -155,7 +155,7 @@
-
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

diff --git a/doc/html/boost_optional/quick_start/bypassing_unnecessary_default_construction.html b/doc/html/boost_optional/quick_start/bypassing_unnecessary_default_construction.html index 1d75a3f..e0ea689 100644 --- a/doc/html/boost_optional/quick_start/bypassing_unnecessary_default_construction.html +++ b/doc/html/boost_optional/quick_start/bypassing_unnecessary_default_construction.html @@ -61,7 +61,7 @@
-
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

diff --git a/doc/html/boost_optional/quick_start/optional_automatic_variables.html b/doc/html/boost_optional/quick_start/optional_automatic_variables.html index bde643c..30ca415 100644 --- a/doc/html/boost_optional/quick_start/optional_automatic_variables.html +++ b/doc/html/boost_optional/quick_start/optional_automatic_variables.html @@ -61,7 +61,7 @@
-
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

diff --git a/doc/html/boost_optional/quick_start/optional_data_members.html b/doc/html/boost_optional/quick_start/optional_data_members.html index 1a1a3b0..be051c9 100644 --- a/doc/html/boost_optional/quick_start/optional_data_members.html +++ b/doc/html/boost_optional/quick_start/optional_data_members.html @@ -80,7 +80,7 @@
-
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

diff --git a/doc/html/boost_optional/quick_start/storage_in_containers.html b/doc/html/boost_optional/quick_start/storage_in_containers.html index 295fcce..6cf9990 100644 --- a/doc/html/boost_optional/quick_start/storage_in_containers.html +++ b/doc/html/boost_optional/quick_start/storage_in_containers.html @@ -50,7 +50,7 @@
-
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

diff --git a/doc/html/boost_optional/reference/acknowledgements.html b/doc/html/boost_optional/reference/acknowledgements.html new file mode 100644 index 0000000..f5a719d --- /dev/null +++ b/doc/html/boost_optional/reference/acknowledgements.html @@ -0,0 +1,131 @@ + + + +Acknowledgements + + + + + + + + + + + + + + +
Boost C++ LibrariesHomeLibrariesPeopleFAQMore
+
+
+PrevUpHome +
+
+
+
+ + Pre-formal + review +
+
    +
  • + Peter Dimov suggested the name 'optional', and was the first to point + out the need for aligned storage. +
    • +
  • + Douglas Gregor developed 'type_with_alignment', and later Eric Friedman + coded 'aligned_storage', which are the core of the optional class implementation. +
    • +
  • + Andrei Alexandrescu and Brian Parker also worked with aligned storage + techniques and their work influenced the current implementation. +
    • +
  • + Gennadiy Rozental made extensive and important comments which shaped + the design. +
    • +
  • + Vesa Karvonen and Douglas Gregor made quite useful comparisons between + optional, variant and any; and made other relevant comments. +
    • +
  • + Douglas Gregor and Peter Dimov commented on comparisons and evaluation + in boolean contexts. +
    • +
  • + Eric Friedman helped understand the issues involved with aligned storage, + move/copy operations and exception safety. +
    • +
  • + Many others have participated with useful comments: Aleksey Gurotov, + Kevlin Henney, David Abrahams, and others I can't recall. +
    • +
+
+ + Post-formal + review +
+
    +
  • + William Kempf carefully considered the originally proposed interface + and suggested the new interface which is currently used. He also started + and fueled the discussion about the analogy optional<>/smart pointer + and about relational operators. +
    • +
  • + Peter Dimov, Joel de Guzman, David Abrahams, Tanton Gibbs and Ian Hanson + focused on the relational semantics of optional (originally undefined); + concluding with the fact that the pointer-like interface doesn't make + it a pointer so it shall have deep relational operators. +
    • +
  • + Augustus Saunders also explored the different relational semantics between + optional<> and a pointer and developed the OptionalPointee concept + as an aid against potential conflicts on generic code. +
    • +
  • + Joel de Guzman noticed that optional<> can be seen as an API on + top of variant<T,nil_t>. +
    • +
  • + Dave Gomboc explained the meaning and usage of the Haskell analog to + optional<>: the Maybe type constructor (analogy originally pointed + out by David Sankel). +
    • +
  • + Other comments were posted by Vincent Finn, Anthony Williams, Ed Brey, + Rob Stewart, and others. +
    • +
  • + Joel de Guzman made the case for the support of references and helped + with the proper semantics. +
    • +
  • + Mat Marcus shown the virtues of a value-oriented interface, influencing + the current design, and contributed the idea of "none". +
    • +
  • + Vladimir Batov's design of Boost.Convert library motivated the development + of value accessors for optional: + functions value, value_or, value_or_eval. +
    • +
+
+ + + +
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

+ 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) +

+
+
+
+PrevUpHome +
+ + diff --git a/doc/html/boost_optional/reference/dependencies_and_portability.html b/doc/html/boost_optional/reference/dependencies_and_portability.html new file mode 100644 index 0000000..5128861 --- /dev/null +++ b/doc/html/boost_optional/reference/dependencies_and_portability.html @@ -0,0 +1,84 @@ + + + +Dependencies and Portability + + + + + + + + + + + + + + + +
Boost C++ LibrariesHomeLibrariesPeopleFAQMore
+
+
+PrevUpHomeNext +
+
+
+
+
+

+ The implementation uses the following other Boost modules: +

+
    +
  1. + assert +
    2. +
  2. + config +
    3. +
  3. + core +
    4. +
  4. + detail +
    5. +
  5. + move +
    6. +
  6. + mpl +
    7. +
  7. + static_assert +
    8. +
  8. + throw_exception +
    9. +
  9. + type_traits +
    10. +
  10. + utility +
    11. +
+
+
+ + + +
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

+ 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) +

+
+
+
+PrevUpHomeNext +
+ + diff --git a/doc/html/boost_optional/reference/dependencies_and_portability/optional_reference_binding.html b/doc/html/boost_optional/reference/dependencies_and_portability/optional_reference_binding.html new file mode 100644 index 0000000..16c1637 --- /dev/null +++ b/doc/html/boost_optional/reference/dependencies_and_portability/optional_reference_binding.html @@ -0,0 +1,100 @@ + + + +Optional Reference Binding + + + + + + + + + + + + + + + +
Boost C++ LibrariesHomeLibrariesPeopleFAQMore
+
+
+PrevUpHomeNext +
+
+
+

+ On compilers that do not conform to Standard C++ rules of reference binding, + operations on optional references might give adverse results: rather than + binding a reference to a designated object they may create an unexpected + temporary and bind to it. Compilers known to have these deficiencies include + GCC versions 4.2, 4.3, 4.4, 4.5; QCC 4.4.2; MSVC versions 8.0, 9.0, 10.0, + 11.0, 12.0. On these compilers prefer using direct-initialization and copy + assignment of optional references to copy-initialization and assignment + from T&: +

+
const int i = 0;
+optional<const int&> or1;
+optional<const int&> or2 = i;  // not portable
+or1 = i;                       // not portable
+
+optional<const int&> or3(i);   // portable
+or1 = optional<const int&>(i); // portable
+
+

+ In order to check if your compiler correctly implements reference binding + use this test program. +

+
#include <cassert>
+
+const int global_i = 0;
+
+struct TestingReferenceBinding
+{
+  TestingReferenceBinding(const int& ii)
+  {
+    assert(&ii == &global_i);
+  }
+
+  void operator=(const int& ii)
+  {
+    assert(&ii == &global_i);
+  }
+
+  void operator=(int&&) // remove this if your compiler doesn't have rvalue refs
+  {
+    assert(false);
+  }
+};
+
+int main()
+{
+  const int& iref = global_i;
+  assert(&iref == &global_i);
+
+  TestingReferenceBinding ttt = global_i;
+  ttt = global_i;
+
+  TestingReferenceBinding ttt2 = iref;
+  ttt2 = iref;
+}
+
+
+ + + +
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

+ 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) +

+
+
+
+PrevUpHomeNext +
+ + diff --git a/doc/html/boost_optional/reference/header__boost_optional_bad_optional_access_hpp_.html b/doc/html/boost_optional/reference/header__boost_optional_bad_optional_access_hpp_.html index e0d8ba9..930bc15 100644 --- a/doc/html/boost_optional/reference/header__boost_optional_bad_optional_access_hpp_.html +++ b/doc/html/boost_optional/reference/header__boost_optional_bad_optional_access_hpp_.html @@ -49,7 +49,7 @@
-
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

diff --git a/doc/html/boost_optional/reference/header__boost_optional_bad_optional_access_hpp_/detailed_semantics.html b/doc/html/boost_optional/reference/header__boost_optional_bad_optional_access_hpp_/detailed_semantics.html index 2b69cac..1971eac 100644 --- a/doc/html/boost_optional/reference/header__boost_optional_bad_optional_access_hpp_/detailed_semantics.html +++ b/doc/html/boost_optional/reference/header__boost_optional_bad_optional_access_hpp_/detailed_semantics.html @@ -46,7 +46,7 @@
-
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

diff --git a/doc/html/boost_optional/reference/header__boost_optional_hpp_.html b/doc/html/boost_optional/reference/header__boost_optional_hpp_.html index 19ed6cf..52d67c3 100644 --- a/doc/html/boost_optional/reference/header__boost_optional_hpp_.html +++ b/doc/html/boost_optional/reference/header__boost_optional_hpp_.html @@ -6,7 +6,7 @@ - + @@ -20,7 +20,7 @@
-PrevUpHomeNext +PrevUpHomeNext

@@ -33,7 +33,7 @@

-
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

@@ -41,7 +41,7 @@
-PrevUpHomeNext +PrevUpHomeNext
diff --git a/doc/html/boost_optional/reference/header__boost_optional_optional_fwd_hpp_.html b/doc/html/boost_optional/reference/header__boost_optional_optional_fwd_hpp_.html index d87a473..06b75d0 100644 --- a/doc/html/boost_optional/reference/header__boost_optional_optional_fwd_hpp_.html +++ b/doc/html/boost_optional/reference/header__boost_optional_optional_fwd_hpp_.html @@ -52,7 +52,7 @@
-
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

diff --git a/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html b/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html index 47b4d4c..b7d25f5 100644 --- a/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html +++ b/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics.html @@ -6,8 +6,8 @@ - - + + @@ -20,7 +20,7 @@
-PrevUpHomeNext +PrevUpHomeNext

@@ -2368,10 +2368,48 @@

+

+ space +

+

+ void swap + ( optional<T&>& x, optional<T&>& y + ) noexcept + ; +

+
    +
  • + Postconditions: x + refers to what y refererred + to before the swap (if anything). y + refers to whatever x + referred to before the swap. +
    • +
  • + Example: +
    T x(12);
+T y(21);
+
+optional<T&> opt0;
+optional<T&> optX (x);
+optional<T&> optY (y);
+
+boost::swap(optX, optY);
+assert (addressof(*optX) == addressof(y));
+assert (addressof(*optY) == addressof(x));
+
+boost::swap(opt0, optX);
+assert ( opt0 );
+assert ( !optX );
+assert (addressof(*opt0) == addressof(y));
+
    + [endsect] +
    • +
-
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

@@ -2379,7 +2417,7 @@
-PrevUpHomeNext +PrevUpHomeNext
diff --git a/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics____free_functions.html b/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics____free_functions.html new file mode 100644 index 0000000..462f109 --- /dev/null +++ b/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics____free_functions.html @@ -0,0 +1,447 @@ + + + +Detailed Semantics -- Free Functions + + + + + + + + + + + + + + + +
Boost C++ LibrariesHomeLibrariesPeopleFAQMore
+
+
+PrevUpHomeNext +
+
+
+

+ space +

+

+ optional<T> make_optional( + T const& v ) +

+
    +
  • + Returns: optional<T>(v) for the deduced + type T of v. +
    • +
  • + Example: +
    template<class T> void foo ( optional<T> const& opt ) ;
+
+foo ( make_optional(1+1) ) ; // Creates an optional<int>
+
    +
    • +
+

+ space +

+

+ optional<T (not a ref)> make_optional( bool condition, + T const& v ) +

+
    +
  • + Returns: optional<T>(condition,v) for the deduced + type T of v. +
    • +
  • + Example: +
    optional<double> calculate_foo()
+{
+  double val = compute_foo();
+  return make_optional(is_not_nan_and_finite(val),val);
+}
+
+optional<double> v = calculate_foo();
+if ( !v )
+  error("foo wasn't computed");
+
    +
    • +
+

+ space +

+

+ bool operator + == ( + optional<T> const& x, optional<T> const& y ); +

+
    +
  • + Requires: T + shall meet requirements of EqualityComparable. +
    • +
  • + Returns: If both x + and y are initialized, + (*x + == *y). + If only x or y is initialized, false. + If both are uninitialized, true. +
    • +
  • + 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 equal_pointees() + instead +
    • +
  • + Example: +
    optional<T> oN, oN_;
+optional<T> o1(T(1)), o1_(T(1));
+optional<T> o2(T(2));
+
+assert ( oN == oN );  // Identity implies equality
+assert ( o1 == o1 );  //
+
+assert ( oN == oN_ ); // Both uninitialized compare equal
+
+assert ( oN != o1 );  // Initialized unequal to initialized.
+
+assert ( o1 == o1_ ); // Both initialized compare as (*lhs == *rhs)
+assert ( o1 != o2 );  //
+
    +
    • +
+

+ space +

+

+ bool operator + < ( + optional<T> const& x, optional<T> const& y ); +

+
    +
  • + Requires: Expression *x < *y shall be well-formed and its result + shall be convertible to bool. +
    • +
  • + Returns: (!y) ? false : (!x) ? true : *x < + *y. +
    • +
  • + 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 less_pointees() + instead. T need not + be LessThanComparable. Only + single operator< + is required. Other relational operations are defined in terms of this + one. If T's operator< + satisfies the axioms of LessThanComparable (transitivity, + antisymmetry and irreflexivity), optinal<T> is LessThanComparable. +
    • +
  • + Example: +
    optional<T> oN, oN_;
+optional<T> o0(T(0));
+optional<T> o1(T(1));
+
+assert ( !(oN < oN) );  // Identity implies equivalence
+assert ( !(o1 < o1) );
+
+assert ( !(oN < oN_) ); // Two uninitialized are equivalent
+assert ( !(oN_ < oN) );
+
+assert ( oN < o0 );     // Uninitialized is less than initialized
+assert ( !(o0 < oN) );
+
+assert ( o1 < o2 ) ;    // Two initialized compare as (*lhs < *rhs)
+assert ( !(o2 < o1) ) ;
+assert ( !(o2 < o2) ) ;
+
    +
    • +
+

+ space +

+

+ bool operator + != ( + optional<T> const& x, optional<T> const& y ); +

+
  • + Returns: !( + x == + y ); +
+

+ space +

+

+ bool operator + > ( + optional<T> const& x, optional<T> const& y ); +

+
  • + Returns: ( + y < + x ); +
+

+ space +

+

+ bool operator + <= ( + optional<T> const& x, optional<T> const& y ); +

+
  • + Returns: !( + y < + x ); +
+

+ space +

+

+ bool operator + >= ( + optional<T> const& x, optional<T> const& y ); +

+
  • + Returns: !( + x < + y ); +
+

+ space +

+

+ bool operator + == ( + optional<T> const& x, none_t ) + noexcept; +

+

+ bool operator + == ( + none_t, + optional<T> const& x ) noexcept; +

+
+

+ space +

+

+ bool operator + != ( + optional<T> const& x, none_t ) + noexcept; +

+

+ bool operator + != ( + none_t, + optional<T> const& x ) noexcept; +

+
  • + Returns: !( + x == + y ); +
+

+ space +

+

+ void swap + ( optional<T>& x, optional<T>& y + ) ; +

+
    +
  • + Requires: Lvalues of type T shall be swappable and T shall be MoveConstructible. +
    • +
  • +

    + Effects: +

    +
    +++++ + + + + + + + + + + + + + + + + + + +
    + +

    + *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. +
    • +
  • + Example: +
    T x(12);
+T y(21);
+optional<T> def0 ;
+optional<T> def1 ;
+optional<T> optX(x);
+optional<T> optY(y);
+
+boost::swap(def0,def1); // no-op
+
+boost::swap(def0,optX);
+assert ( *def0 == x );
+assert ( !optX );
+
+boost::swap(def0,optX); // Get back to original values
+
+boost::swap(optX,optY);
+assert ( *optX == y );
+assert ( *optY == x );
+
    +
    • +
+

+ space +

+

+ void swap + ( optional<T&>& x, optional<T&>& y + ) noexcept + ; +

+
    +
  • + Postconditions: x + refers to what y refererred + to before the swap (if anything). y + refers to whatever x + referred to before the swap. +
    • +
  • + Example: +
    T x(12);
+T y(21);
+
+optional<T&> opt0;
+optional<T&> optX (x);
+optional<T&> optY (y);
+
+boost::swap(optX, optY);
+assert (addressof(*optX) == addressof(y));
+assert (addressof(*optY) == addressof(x));
+
+boost::swap(opt0, optX);
+assert ( opt0 );
+assert ( !optX );
+assert (addressof(*opt0) == addressof(y));
+
    + [endsect] +
    • +
+
+ + + +
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

+ 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) +

+
+
+
+PrevUpHomeNext +
+ + diff --git a/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics____optional_references.html b/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics____optional_references.html new file mode 100644 index 0000000..7eedfab --- /dev/null +++ b/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics____optional_references.html @@ -0,0 +1,57 @@ + + + +Detailed Semantics -- Optional References + + + + + + + + + + + + + + + +
Boost C++ LibrariesHomeLibrariesPeopleFAQMore
+
+
+PrevUpHomeNext +
+
+
+

+ space +

+

+ optional<&>::optional() + noexcept; +

+

+ optional<&>::optional(none_t) noexcept; +

+
  • + Postconditions: *this refers to nothing. +
+
+ + + +
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

+ 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) +

+
+
+
+PrevUpHomeNext +
+ + diff --git a/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics____optional_values.html b/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics____optional_values.html new file mode 100644 index 0000000..5fd6391 --- /dev/null +++ b/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics____optional_values.html @@ -0,0 +1,1983 @@ + + + +Detailed Semantics -- Optional Values + + + + + + + + + + + + + + + +
Boost C++ LibrariesHomeLibrariesPeopleFAQMore
+
+
+PrevUpHomeNext +
+
+
+
+ + + + + +
[Note]Note

+ The following section contains various assert() which are used only to show the postconditions + as sample code. It is not implied that the type T + must support each particular expression but that if the expression is + supported, the implied condition holds. +

+

+ space +

+

+ optional<T>::optional() + noexcept; +

+
    +
  • + Effect: Default-Constructs an optional. +
    • +
  • + Postconditions: *this is uninitialized. +
    • +
  • + Notes: T's default constructor is not called. +
    • +
  • + Example: +
    optional<T> def ;
+assert ( !def ) ;
+
    +
    • +
+

+ space +

+

+ optional<T>::optional( + none_t ) + noexcept; +

+
    +
  • + Effect: Constructs an optional uninitialized. +
    • +
  • + Postconditions: *this is uninitialized. +
    • +
  • + Notes: T's + default constructor is not called. + The expression boost::none + denotes an instance of boost::none_t + that can be used as the parameter. +
    • +
  • + Example: +
    #include <boost/none.hpp>
+optional<T> n(none) ;
+assert ( !n ) ;
+
    +
    • +
+

+ space +

+

+ optional<T (not a ref)>::optional( T const& v ) +

+
    +
  • + Requires: is_copy_constructible<T>::value + is true. +
    • +
  • + Effect: Directly-Constructs an optional. +
    • +
  • + Postconditions: *this is initialized + and its value is a copy of v. +
    • +
  • + Throws: Whatever T::T( T const& + ) throws. +
    • +
  • + Notes: T::T( T const& + ) is called. +
    • +
  • + Exception Safety: Exceptions can only + be thrown during T::T( T const& + ); in that case, this constructor + has no effect. +
    • +
  • + Example: +
    T v;
+optional<T> opt(v);
+assert ( *opt == v ) ;
+
    +
    • +
+

+ space +

+

+ optional<T&>::optional( + T& + ref ) +

+
    +
  • + Effect: Directly-Constructs an optional. +
    • +
  • + Postconditions: *this is initialized + and its value is an instance of an internal type wrapping the reference + ref. +
    • +
  • + Throws: Nothing. +
    • +
  • + Example: +
    T v;
+T& vref = v ;
+optional<T&> opt(vref);
+assert ( *opt == v ) ;
+++ v ; // mutate referee
+assert (*opt == v);
+
    +
    • +
+

+ space +

+

+ optional<T (not a ref)>::optional( T&& v + ) +

+
    +
  • + Requires: is_move_constructible<T>::value + is true. +
    • +
  • + Effect: Directly-Move-Constructs an + optional. +
    • +
  • + Postconditions: *this is initialized + and its value is move-constructed from v. +
    • +
  • + Throws: Whatever T::T( T&& ) + throws. +
    • +
  • + Notes: T::T( T&& ) + is called. +
    • +
  • + Exception Safety: Exceptions can only + be thrown during T::T( T&& ); + in that case, the state of v + is determined by exception safety guarantees for T::T(T&&). +
    • +
  • + Example: +
    T v1, v2;
+optional<T> opt(std::move(v1));
+assert ( *opt == v2 ) ;
+
    +
    • +
+

+ space +

+

+ optional<T&>::optional( + T&& + ref ) + = delete +

+
  • + Notes: This constructor is deleted +
+

+ space +

+

+ optional<T (not a ref)>::optional( bool condition, + T const& v ) ; +

+

+ optional<T&> + ::optional( bool condition, + T& + v ) + ; +

+
  • + If condition is true, same as: +
+

+ optional<T (not a ref)>::optional( T const& v ) +

+

+ optional<T&> + ::optional( T& v ) +

+
  • + otherwise, same as: +
+

+ optional<T (not a ref)>::optional() +

+

+ optional<T&> + ::optional() +

+

+ space +

+

+ optional<T (not a ref)>::optional( optional + const& + rhs ); +

+
    +
  • + Requires: is_copy_constructible<T>::value + is true. +
    • +
  • + Effect: Copy-Constructs an optional. +
    • +
  • + Postconditions: If rhs is initialized, + *this + is initialized and its value is a copy of the + value of rhs; else + *this + is uninitialized. +
    • +
  • + Throws: Whatever T::T( T const& + ) throws. +
    • +
  • + Notes: If rhs is initialized, T::T(T const& ) + is called. +
    • +
  • + Exception Safety: Exceptions can only + be thrown during T::T( T const& + ); in that case, this constructor + has no effect. +
    • +
  • + Example: +
    optional<T> uninit ;
+assert (!uninit);
+
+optional<T> uinit2 ( uninit ) ;
+assert ( uninit2 == uninit );
+
+optional<T> init( T(2) );
+assert ( *init == T(2) ) ;
+
+optional<T> init2 ( init ) ;
+assert ( init2 == init ) ;
+
    +
    • +
+

+ space +

+

+ optional<T&>::optional( + optional const& rhs + ); +

+
    +
  • + Effect: Copy-Constructs an optional. +
    • +
  • + Postconditions: If rhs + is initialized, *this + is initialized and its value is another reference to the same object + referenced by *rhs; + else *this + is uninitialized. +
    • +
  • + Throws: Nothing. +
    • +
  • + Notes: If rhs + is initialized, both *this and *rhs will refer to the same object + (they alias). +
    • +
  • + Example: +
    optional<T&> uninit ;
+assert (!uninit);
+
+optional<T&> uinit2 ( uninit ) ;
+assert ( uninit2 == uninit );
+
+T v = 2 ; T& ref = v ;
+optional<T> init(ref);
+assert ( *init == v ) ;
+
+optional<T> init2 ( init ) ;
+assert ( *init2 == v ) ;
+
+v = 3 ;
+
+assert ( *init  == 3 ) ;
+assert ( *init2 == 3 ) ;
+
    +
    • +
+

+ space +

+

+ optional<T (not a ref)>::optional( optional&& rhs + ) noexcept(see below); +

+
    +
  • + Requires: is_move_constructible<T>::value + is true. +
    • +
  • + Effect: Move-constructs an optional. +
    • +
  • + Postconditions: If rhs + is initialized, *this + is initialized and its value is move constructed from rhs; else *this is uninitialized. +
    • +
  • + Throws: Whatever T::T( T&& ) + throws. +
    • +
  • + Remarks: The expression inside noexcept is equivalent to is_nothrow_move_constructible<T>::value. +
    • +
  • + Notes: If rhs + is initialized, T::T( T && + ) is called. +
    • +
  • + Exception Safety: Exceptions can only + be thrown during T::T( T&& ); + in that case, rhs remains + initialized and the value of *rhs is determined by exception safety + of T::T(T&&). +
    • +
  • + Example: +
    optional<std::unique_ptr<T>> uninit ;
+assert (!uninit);
+
+optional<std::unique_ptr<T>> uinit2 ( std::move(uninit) ) ;
+assert ( uninit2 == uninit );
+
+optional<std::unique_ptr<T>> init( std::uniqye_ptr<T>(new T(2)) );
+assert ( **init == T(2) ) ;
+
+optional<std::unique_ptr<T>> init2 ( std::move(init) ) ;
+assert ( init );
+assert ( *init == nullptr );
+assert ( init2 );
+assert ( **init2 == T(2) ) ;
+
    +
    • +
+

+ space +

+

+ optional<T&>::optional( + optional && + rhs ); +

+
    +
  • + Effect: Move-Constructs an optional. +
    • +
  • + Postconditions: If rhs + is initialized, *this + is initialized and its value is another reference to the same object + referenced by *rhs; + else *this + is uninitialized. +
    • +
  • + Throws: Nothing. +
    • +
  • + Notes: If rhs + is initialized, both *this and *rhs will refer to the same object + (they alias). +
    • +
  • + Example: +
    optional<std::unique_ptr<T>&> uninit ;
+assert (!uninit);
+
+optional<std::unique_ptr<T>&> uinit2 ( std::move(uninit) ) ;
+assert ( uninit2 == uninit );
+
+std::unique_ptr<T> v(new T(2)) ;
+optional<std::unique_ptr<T>&> init(v);
+assert ( *init == v ) ;
+
+optional<std::unique_ptr<T>&> init2 ( std::move(init) ) ;
+assert ( *init2 == v ) ;
+
+*v = 3 ;
+
+assert ( **init  == 3 ) ;
+assert ( **init2 == 3 ) ;
+
    +
    • +
+

+ space +

+

+ template<U> explicit optional<T + (not a ref)>::optional( + optional<U> const& rhs ); +

+
    +
  • + Effect: Copy-Constructs 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::T( U const& + ) throws. +
    • +
  • + Notes: T::T( U const& + ) is called if rhs is initialized, which requires + a valid conversion from U + to T. +
    • +
  • + Exception Safety: Exceptions can only + be thrown during T::T( U const& + ); in that case, this constructor + has no effect. +
    • +
  • + Example: +
    optional<double> x(123.4);
+assert ( *x == 123.4 ) ;
+
+optional<int> y(x) ;
+assert( *y == 123 ) ;
+
    +
    • +
+

+ space +

+

+ template<U> explicit optional<T + (not a ref)>::optional( + optional<U>&& + rhs ); +

+
    +
  • + Effect: Move-constructs an optional. +
    • +
  • + Postconditions: If rhs + is initialized, *this + is initialized and its value is move-constructed from *rhs; + else *this + is uninitialized. +
    • +
  • + Throws: Whatever T::T( U&& ) + throws. +
    • +
  • + Notes: T::T( U&& ) + is called if rhs is + initialized, which requires a valid conversion from U + to T. +
    • +
  • + Exception Safety: Exceptions can only + be thrown during T::T( U&& ); + in that case, rhs remains + initialized and the value of *rhs is determined by exception safety + guarantee of T::T( U&& + ). +
    • +
  • + Example: +
    optional<double> x(123.4);
+assert ( *x == 123.4 ) ;
+
+optional<int> y(std::move(x)) ;
+assert( *y == 123 ) ;
+
    +
    • +
+

+ space +

+

+ template<InPlaceFactory> + explicit optional<T + (not a ref)>::optional( + InPlaceFactory const& f ); +

+

+ template<TypedInPlaceFactory> + explicit optional<T + (not a ref)>::optional( + TypedInPlaceFactory const& f ); +

+
    +
  • + Effect: Constructs an optional with a value of T obtained from the factory. +
    • +
  • + Postconditions: *this is initialized + and its value is directly given from the factory + f (i.e., the value + is not copied). +
    • +
  • + Throws: Whatever the T constructor called by the factory + throws. +
    • +
  • + Notes: See In-Place + Factories +
    • +
  • + Exception Safety: Exceptions can only + be thrown during the call to the T + constructor used by the factory; in that case, this constructor has + no effect. +
    • +
  • + Example: +
    class C { C ( char, double, std::string ) ; } ;
+
+C v('A',123.4,"hello");
+
+optional<C> x( in_place   ('A', 123.4, "hello") ); // InPlaceFactory used
+optional<C> y( in_place<C>('A', 123.4, "hello") ); // TypedInPlaceFactory used
+
+assert ( *x == v ) ;
+assert ( *y == v ) ;
+
    +
    • +
+

+ space +

+

+ optional& + optional<T>::operator= ( none_t + ) noexcept; +

+
    +
  • + Effect: If *this is initialized destroys its contained + value. +
    • +
  • + Postconditions: *this is uninitialized. +
    • +
+

+ space +

+

+ optional& + optional<T (not a ref)>::operator= ( T + const& + rhs ) + ; +

+
    +
  • + Effect: Assigns the value rhs to an optional. +
    • +
  • + Postconditions: *this is initialized and its value is + a copy of rhs. +
    • +
  • + Throws: Whatever T::operator=( T const& + ) or T::T(T const&) + throws. +
    • +
  • + Notes: If *this was initialized, T's assignment operator is used, + otherwise, its copy-constructor is used. +
    • +
  • + 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 + copy constructor fails, *this is left properly uninitialized. +
    • +
  • + Example: +
    T x;
+optional<T> def ;
+optional<T> opt(x) ;
+
+T y;
+def = y ;
+assert ( *def == y ) ;
+opt = y ;
+assert ( *opt == y ) ;
+
    +
    • +
+

+ space +

+

+ optional<T&>& + optional<T&>::operator= ( T& rhs + ) ; +

+
    +
  • + Effect: (Re)binds the wrapped reference. +
    • +
  • + Postconditions: *this is initialized and it references + the same object referenced by rhs. +
    • +
  • + Notes: If *this was initialized, it is rebound + to the new object. See here + for details on this behavior. +
    • +
  • + Example: +
    int a = 1 ;
+int b = 2 ;
+T& ra = a ;
+T& rb = b ;
+optional<int&> def ;
+optional<int&> opt(ra) ;
+
+def = rb ; // binds 'def' to 'b' through 'rb'
+assert ( *def == b ) ;
+*def = a ; // changes the value of 'b' to a copy of the value of 'a'
+assert ( b == a ) ;
+int c = 3;
+int& rc = c ;
+opt = rc ; // REBINDS to 'c' through 'rc'
+c = 4 ;
+assert ( *opt == 4 ) ;
+
    +
    • +
+

+ space +

+

+ optional& + optional<T (not a ref)>::operator= ( T&& rhs + ) ; +

+
    +
  • + Effect: Moves the value rhs to an optional. +
    • +
  • + Postconditions: *this is initialized and its value is + moved from rhs. +
    • +
  • + Throws: Whatever T::operator=( T&& ) + or T::T(T &&) + throws. +
    • +
  • + Notes: If *this was initialized, T's move-assignment operator is used, + otherwise, its move-constructor is used. +
    • +
  • + 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 + move constructor fails, *this is left properly uninitialized. +
    • +
  • + Example: +
    T x;
+optional<T> def ;
+optional<T> opt(x) ;
+
+T y1, y2, yR;
+def = std::move(y1) ;
+assert ( *def == yR ) ;
+opt = std::move(y2) ;
+assert ( *opt == yR ) ;
+
    +
    • +
+

+ space +

+

+ optional<T&>& + optional<T&>::operator= ( T&& rhs + ) = + delete; +

+
  • + Notes: This assignment operator is + deleted. +
+

+ space +

+

+ optional& + optional<T (not a ref)>::operator= ( optional + const& + rhs ) + ; +

+
    +
  • + Requires: T + is CopyConstructible and CopyAssignable. +
    • +
  • +

    + Effects: +

    +
    +++++ + + + + + + + + + + + + + + + + + + +
    + +

    + *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. If an exception is thrown during the call to T's copy constructor, no effect. + If an exception is thrown during the call to T's + copy assignment, the state of its contained value is as defined by + the exception safety guarantee of T's + copy assignment. +
    • +
  • + Example: +
    T v;
+optional<T> opt(v);
+optional<T> def ;
+
+opt = def ;
+assert ( !def ) ;
+// previous value (copy of 'v') destroyed from within 'opt'.
+
    +
    • +
+

+ space +

+

+ optional<T&> + & optional<T&>::operator= ( optional<T&> const& rhs + ) ; +

+
    +
  • + Effect: (Re)binds thee wrapped reference. +
    • +
  • + Postconditions: If *rhs is initialized, *this + is initialized and it references the same object referenced by *rhs; + otherwise, *this + is uninitialized (and references no object). +
    • +
  • + Notes: If *this was initialized and so is *rhs, + *this + is rebound to the new object. See here + for details on this behavior. +
    • +
  • + Example: +
    int a = 1 ;
+int b = 2 ;
+T& ra = a ;
+T& rb = b ;
+optional<int&> def ;
+optional<int&> ora(ra) ;
+optional<int&> orb(rb) ;
+
+def = orb ; // binds 'def' to 'b' through 'rb' wrapped within 'orb'
+assert ( *def == b ) ;
+*def = ora ; // changes the value of 'b' to a copy of the value of 'a'
+assert ( b == a ) ;
+int c = 3;
+int& rc = c ;
+optional<int&> orc(rc) ;
+ora = orc ; // REBINDS ora to 'c' through 'rc'
+c = 4 ;
+assert ( *ora == 4 ) ;
+
    +
    • +
+

+ space +

+

+ optional& + optional<T (not a ref)>::operator= ( optional&& rhs + ) noexcept(see below); +

+
    +
  • + Requires: T + is MoveConstructible + and MoveAssignable. +
    • +
  • +

    + Effects: +

    +
    +++++ + + + + + + + + + + + + + + + + + + +
    + +

    + *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. +
    • +
  • + Exception Safety: If any exception + is thrown, the initialization state of *this and rhs + remains unchanged. If an exception is thrown during the call to T's move constructor, the state of + *rhs + is determined by the exception safety guarantee of T's + move constructor. If an exception is thrown during the call to T's + move-assignment, the state of **this and *rhs is determined by the exception + safety guarantee of T's move assignment. +
    • +
  • + Example: +
    optional<T> opt(T(2)) ;
+optional<T> def ;
+
+opt = def ;
+assert ( def ) ;
+assert ( opt ) ;
+assert ( *opt == T(2) ) ;
+
    +
    • +
+

+ space +

+

+ optional<T&> + & optional<T&>::operator= ( optional<T&>&& rhs + ) ; +

+
  • + Effect: Same as optional<T&>::operator= ( optional<T&> + const& + rhs ). +
+

+ space +

+

+ template<U> optional& + optional<T (not a ref)>::operator= ( optional<U> const& rhs + ) ; +

+
    +
  • +

    + Effect: +

    +
    +++++ + + + + + + + + + + + + + + + + + + +
    + +

    + *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;
+optional<T> opt0(v);
+optional<U> opt1;
+
+opt1 = opt0 ;
+assert ( *opt1 == static_cast<U>(v) ) ;
+
    +
    • +
+

+ space +

+

+ template<U> optional& + optional<T (not a ref)>::operator= ( optional<U>&& rhs + ) ; +

+
    +
  • +

    + Effect: +

    +
    +++++ + + + + + + + + + + + + + + + + + + +
    + +

    + *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;
+optional<T> opt0(v);
+optional<U> opt1;
+
+opt1 = std::move(opt0) ;
+assert ( opt0 );
+assert ( opt1 )
+assert ( *opt1 == static_cast<U>(v) ) ;
+
    +
    • +
+

+ space +

+

+ template<class... Args> + void optional<T + (not a ref)>::emplace( + Args...&& + args ); +

+
    +
  • + Requires: The compiler supports rvalue + references and variadic templates. +
    • +
  • + Effect: If *this is initialized calls *this = none. + Then initializes in-place the contained value as if direct-initializing + an object of type T + with std::forward<Args>(args).... +
    • +
  • + Postconditions: *this is initialized. +
    • +
  • + Throws: Whatever the selected T's constructor throws. +
    • +
  • + Exception Safety: If an exception + is thrown during the initialization of T, + *this + is uninitialized. +
    • +
  • + Notes: T + need not be MoveConstructible + 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;
+optional<const T> opt;
+opt.emplace(0);  // create in-place using ctor T(int)
+opt.emplace();   // destroy previous and default-construct another T
+opt.emplace(v);  // destroy and copy-construct in-place (no assignment called)
+
    +
    • +
+

+ space +

+

+ template<InPlaceFactory> + optional<T>& + optional<T (not a ref)>::operator=( InPlaceFactory + const& + f ); +

+

+ template<TypedInPlaceFactory> + optional<T>& + optional<T (not a ref)>::operator=( TypedInPlaceFactory + const& + f ); +

+
    +
  • + Effect: Assigns an optional + with a value of T obtained + from the factory. +
    • +
  • + Postconditions: *this is initialized + and its value is directly given from the factory + f (i.e., the value + is not copied). +
    • +
  • + Throws: Whatever the T constructor called by the factory + throws. +
    • +
  • + Notes: See In-Place + Factories +
    • +
  • + Exception Safety: Exceptions can only + be thrown during the call to the T + constructor used by the factory; in that case, the optional + object will be reset to be uninitialized. +
    • +
+

+ space +

+

+ void optional<T + (not a ref)>::reset( T const& v ) ; +

+
  • + Deprecated: same as operator= + ( T + const& + v) + ; +
+

+ space +

+

+ void optional<T>::reset() noexcept + ; +

+
  • + Deprecated: Same as operator=( + none_t ); +
+

+ space +

+

+ T const& optional<T + (not a ref)>::get() const ; +

+

+ T& + optional<T (not a ref)>::get() ; +

+

+ inline T + const& + get ( + optional<T (not a ref)> const& ) ; +

+

+ inline T& get + ( optional<T + (not a ref)> + &) ; +

+
    +
  • + Requires: *this is initialized +
    • +
  • + Returns: A reference to the contained + value +
    • +
  • + Throws: Nothing. +
    • +
  • + Notes: The requirement is asserted + via BOOST_ASSERT(). +
    • +
+

+ space +

+

+ T const& optional<T&>::get() const ; +

+

+ T& + optional<T&>::get() ; +

+

+ inline T + const& + get ( + optional<T&> + const& + ) ; +

+

+ inline T& get + ( optional<T&> &) + ; +

+
    +
  • + Requires: *this is initialized +
    • +
  • + Returns: The + reference contained. +
    • +
  • + Throws: Nothing. +
    • +
  • + Notes: The requirement is asserted + via BOOST_ASSERT(). +
    • +
+

+ space +

+

+ T const& optional<T + (not a ref)>::operator*() + const& + ; +

+

+ T& + optional<T (not a ref)>::operator*() &; +

+
    +
  • + Requires: *this is initialized +
    • +
  • + Returns: A reference to the contained + value +
    • +
  • + Throws: Nothing. +
    • +
  • + Notes: The requirement is asserted + via BOOST_ASSERT(). + On compilers that do not support ref-qualifiers on member functions + these two overloads are replaced with the classical two: a const and non-const + member functions. +
    • +
  • + Example: +
    T v ;
+optional<T> opt ( v );
+T const& u = *opt;
+assert ( u == v ) ;
+T w ;
+*opt = w ;
+assert ( *opt == w ) ;
+
    +
    • +
+

+ space +

+

+ T&& + optional<T (not a ref)>::operator*() &&; +

+
    +
  • + Requires: *this contains a value. +
    • +
  • + Effects: Equivalent to return std::move(*val);. +
    • +
  • + Notes: The requirement is asserted + via BOOST_ASSERT(). + On compilers that do not support ref-qualifiers on member functions + this overload is not present. +
    • +
+

+ space +

+

+ T & + optional<T&>::operator*() + const& + ; +

+

+ T & + optional<T&>::operator*() + & ; +

+

+ T & + optional<T&>::operator*() + && ; +

+
    +
  • + Requires: *this is initialized +
    • +
  • + Returns: The + reference contained. +
    • +
  • + Throws: Nothing. +
    • +
  • + Notes: The requirement is asserted + via BOOST_ASSERT(). + On compilers that do not support ref-qualifiers on member functions + these three overloads are replaced with the classical two: a const and non-const + member functions. +
    • +
  • + Example: +
    T v ;
+T& vref = v ;
+optional<T&> opt ( vref );
+T const& vref2 = *opt;
+assert ( vref2 == v ) ;
+++ v ;
+assert ( *opt == v ) ;
+
    +
    • +
+

+ space +

+

+ T const& optional<T>::value() const& ; +

+

+ T& + optional<T>::value() & ; +

+
    +
  • + Effects: Equivalent to return bool(*this) ? *val : throw bad_optional_access();. +
    • +
  • + Notes: On compilers that do not support + ref-qualifiers on member functions these two overloads are replaced + with the classical two: a const + and non-const member functions. +
    • +
  • + Example: +
    T v ;
+optional<T> o0, o1 ( v );
+assert ( o1.value() == v );
+
+try {
+  o0.value(); // throws
+  assert ( false );
+}
+catch(bad_optional_access&) {
+  assert ( true );
+}
+
    +
    • +
+

+ space +

+

+ T&& + optional<T>::value() && ; +

+
    +
  • + Effects: Equivalent to return bool(*this) ? std::move(*val) : throw bad_optional_access();. +
    • +
  • + Notes: On compilers that do not support + ref-qualifiers on member functions this overload is not present. +
    • +
+

+ space +

+

+ template<class U> T optional<T>::value_or(U && + v) + const& + ; +

+
    +
  • + Effects: Equivalent to if (*this) return **this; else return + std::forward<U>(v);. +
    • +
  • + Remarks: If T + is not CopyConstructible or U && + is not convertible to T, + the program is ill-formed. +
    • +
  • + Notes: On compilers that do not support + ref-qualifiers on member functions this overload is replaced with the + const-qualified member + function. On compilers without rvalue reference support the type of + v becomes U const&. +
    • +
+

+ space +

+

+ template<class U> T optional<T>::value_or(U && + v) + && ; +

+
    +
  • + Effects: Equivalent to if (*this) return std::move(**this); else return std::forward<U>(v);. +
    • +
  • + Remarks: If T + is not MoveConstructible + or U && + is not convertible to T, + the program is ill-formed. +
    • +
  • + Notes: On compilers that do not support + ref-qualifiers on member functions this overload is not present. +
    • +
+

+ space +

+

+ template<class F> T optional<T>::value_or_eval(F f) const& ; +

+
    +
  • + Requires: T + is CopyConstructible and F models a Generator whose result type + is convertible to T. +
    • +
  • + Effects: if + (*this) return **this; else return f();. +
    • +
  • + Notes: On compilers that do not support + ref-qualifiers on member functions this overload is replaced with the + const-qualified member + function. +
    • +
  • + Example: +
    int complain_and_0()
+{
+  clog << "no value returned, using default" << endl;
+  return 0;
+}
+
+optional<int> o1 = 1;
+optional<int> oN = none;
+
+int i = o1.value_or_eval(complain_and_0); // fun not called
+assert (i == 1);
+
+int j = oN.value_or_eval(complain_and_0); // fun called
+assert (i == 0);
+
    +
    • +
+

+ space +

+

+ template<class F> T optional<T>::value_or_eval(F f) && + ; +

+
    +
  • + Requires: T + is MoveConstructible + and F models a Generator + whose result type is convertible to T. +
    • +
  • + Effects: if + (*this) return std::move(**this); else return + f();. +
    • +
  • + Notes: On compilers that do not support + ref-qualifiers on member functions this overload is not present. +
    • +
+

+ space +

+

+ T const& optional<T + (not a ref)>::get_value_or( + T const& default) const ; +

+

+ T& + optional<T (not a ref)>::get_value_or( T& default + ) ; +

+

+ inline T + const& + get_optional_value_or ( + optional<T (not a ref)> const& o, T const& default ) ; +

+

+ inline T& get_optional_value_or + ( optional<T + (not a ref)>& + o, + T& + default ) + ; +

+
    +
  • + Deprecated: Use value_or() instead. +
    • +
  • + Returns: A reference to the contained + value, if any, or default. +
    • +
  • + Throws: Nothing. +
    • +
  • + Example: +
    T v, z ;
+optional<T> def;
+T const& y = def.get_value_or(z);
+assert ( y == z ) ;
+
+optional<T> opt ( v );
+T const& u = get_optional_value_or(opt,z);
+assert ( u == v ) ;
+assert ( u != z ) ;
+
    +
    • +
+

+ space +

+

+ T const* optional<T + (not a ref)>::get_ptr() + const ; +

+

+ T* + optional<T (not a ref)>::get_ptr() ; +

+

+ inline T + const* + get_pointer ( + optional<T (not a ref)> const& ) ; +

+

+ inline T* get_pointer + ( optional<T + (not a ref)> + &) ; +

+
    +
  • + Returns: If *this is initialized, a pointer to the + contained value; else 0 + (null). +
    • +
  • + Throws: Nothing. +
    • +
  • + Notes: The contained value is permanently + stored within *this, + so you should not hold nor delete this pointer +
    • +
  • + Example: +
    T v;
+optional<T> opt(v);
+optional<T> const copt(v);
+T* p = opt.get_ptr() ;
+T const* cp = copt.get_ptr();
+assert ( p == get_pointer(opt) );
+assert ( cp == get_pointer(copt) ) ;
+
    +
    • +
+

+ space +

+

+ T const* optional<T + (not a ref)>::operator ->() + const ; +

+

+ T* + optional<T (not a ref)>::operator + ->() ; +

+
    +
  • + Requires: *this is initialized. +
    • +
  • + Returns: A pointer to the contained + value. +
    • +
  • + Throws: Nothing. +
    • +
  • + Notes: The requirement is asserted + via BOOST_ASSERT(). +
    • +
  • + Example: +
    struct X { int mdata ; } ;
+X x ;
+optional<X> opt (x);
+opt->mdata = 2 ;
+
    +
    • +
+

+ space +

+

+ explicit optional<T>::operator + bool() + const noexcept + ; +

+
    +
  • + Returns: get_ptr() != 0. +
    • +
  • + Notes: On compilers that do not support + explicit conversion operators this falls back to safe-bool idiom. +
    • +
  • + Example: +
    optional<T> def ;
+assert ( def == 0 );
+optional<T> opt ( v ) ;
+assert ( opt );
+assert ( opt != 0 );
+
    +
    • +
+

+ space +

+

+ bool optional<T>::operator!() noexcept + ; +

+
    +
  • + Returns: If *this is uninitialized, true; else false. +
    • +
  • + Notes: This operator is provided for + those compilers which can't use the unspecified-bool-type + operator in certain boolean contexts. +
    • +
  • + Example: +
    optional<T> opt ;
+assert ( !opt );
+*opt = some_T ;
+
+// Notice the "double-bang" idiom here.
+assert ( !!opt ) ;
+
    +
    • +
+

+ space +

+

+ bool optional<T>::is_initialized() const ; +

+
  • + Deprecated: Same as explicit operator + bool () + ; +
+
+ + + +
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

+ 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) +

+
+
+
+PrevUpHomeNext +
+ + diff --git a/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___free_functions.html b/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___free_functions.html new file mode 100644 index 0000000..f786277 --- /dev/null +++ b/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___free_functions.html @@ -0,0 +1,497 @@ + + + +Detailed Semantics - Free Functions + + + + + + + + + + + + + + + +
Boost C++ LibrariesHomeLibrariesPeopleFAQMore
+
+
+PrevUpHomeNext +
+
+
+

+ space +

+

+ optional<T> make_optional( + T const& v ) +

+
    +
  • + Returns: optional<T>(v) for the deduced + type T of v. +
    • +
  • + Example: +
    template<class T> void foo ( optional<T> const& opt ) ;
+
+foo ( make_optional(1+1) ) ; // Creates an optional<int>
+
    +
    • +
+

+ space +

+

+ optional<T> make_optional( + bool condition, T const& v ) +

+
    +
  • + Returns: optional<T>(condition, v) for the deduced + type T of v. +
    • +
  • + Example: +
    optional<double> calculate_foo()
+{
+  double val = compute_foo();
+  return make_optional(is_not_nan_and_finite(val),val);
+}
+
+optional<double> v = calculate_foo();
+if ( !v )
+  error("foo wasn't computed");
+
    +
    • +
+

+ space +

+

+ bool operator + == ( + optional<T> const& x, optional<T> const& y ); +

+
    +
  • + Requires: T + shall meet requirements of EqualityComparable. +
    • +
  • + Returns: If both x + and y are initialized, + (*x + == *y). + If only x or y is initialized, false. + If both are uninitialized, true. +
    • +
  • + 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 equal_pointees() + instead +
    • +
  • + Example: +
    optional<T> oN, oN_;
+optional<T> o1(T(1)), o1_(T(1));
+optional<T> o2(T(2));
+
+assert ( oN == oN );  // Identity implies equality
+assert ( o1 == o1 );  //
+
+assert ( oN == oN_ ); // Both uninitialized compare equal
+
+assert ( oN != o1 );  // Initialized unequal to initialized.
+
+assert ( o1 == o1_ ); // Both initialized compare as (*lhs == *rhs)
+assert ( o1 != o2 );  //
+
    +
    • +
+

+ space +

+

+ bool operator + < ( + optional<T> const& x, optional<T> const& y ); +

+
    +
  • + Requires: Expression *x < *y shall be well-formed and its result + shall be convertible to bool. +
    • +
  • + Returns: (!y) ? false : (!x) ? true : *x < + *y. +
    • +
  • + 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 less_pointees() + instead. T need not + be LessThanComparable. Only + single operator< + is required. Other relational operations are defined in terms of this + one. If T's operator< + satisfies the axioms of LessThanComparable (transitivity, + antisymmetry and irreflexivity), optinal<T> is LessThanComparable. +
    • +
  • + Example: +
    optional<T> oN, oN_;
+optional<T> o0(T(0));
+optional<T> o1(T(1));
+
+assert ( !(oN < oN) );  // Identity implies equivalence
+assert ( !(o1 < o1) );
+
+assert ( !(oN < oN_) ); // Two uninitialized are equivalent
+assert ( !(oN_ < oN) );
+
+assert ( oN < o0 );     // Uninitialized is less than initialized
+assert ( !(o0 < oN) );
+
+assert ( o1 < o2 ) ;    // Two initialized compare as (*lhs < *rhs)
+assert ( !(o2 < o1) ) ;
+assert ( !(o2 < o2) ) ;
+
    +
    • +
+

+ space +

+

+ bool operator + != ( + optional<T> const& x, optional<T> const& y ); +

+
  • + Returns: !( + x == + y ); +
+

+ space +

+

+ bool operator + > ( + optional<T> const& x, optional<T> const& y ); +

+
  • + Returns: ( + y < + x ); +
+

+ space +

+

+ bool operator + <= ( + optional<T> const& x, optional<T> const& y ); +

+
  • + Returns: !( + y < + x ); +
+

+ space +

+

+ bool operator + >= ( + optional<T> const& x, optional<T> const& y ); +

+
  • + Returns: !( + x < + y ); +
+

+ space +

+

+ bool operator + == ( + optional<T> const& x, none_t ) + noexcept; +

+

+ bool operator + == ( + none_t, + optional<T> const& x ) noexcept; +

+
+

+ space +

+

+ bool operator + != ( + optional<T> const& x, none_t ) + noexcept; +

+

+ bool operator + != ( + none_t, + optional<T> const& x ) noexcept; +

+
  • + Returns: !( + x == + y ); +
+

+ space +

+

+ auto get_pointer + ( optional<T>& o + ) -> + typename optional<T>::pointer_type + ; +

+

+ auto get_pointer + ( optional<T> const& o ) -> typename optional<T>::pointer_const_type + ; +

+
    +
  • + Returns: o.get_ptr(). +
    • +
  • + Throws: Nothing. +
    • +
+

+ space +

+

+ auto get_optional_value_or + ( optional<T>& o, typename optional<T>::reference_type def + ) -> + typename optional<T>::reference_type + ; +

+

+ auto get_optional_value_or + ( optional<T> const& o, typename optional<T>::reference_const_type def + ) -> + typename optional<T>::reference_const_type + ; +

+
    +
  • + Returns: o.get_value_or(def). +
    • +
  • + Throws: Nothing. +
    • +
  • + Remarks: This function is deprecated. +
    • +
+

+ space +

+

+ void swap + ( optional<T>& x, optional<T>& y + ) ; +

+
    +
  • + Requires: Lvalues of type T shall be swappable and T shall be MoveConstructible. +
    • +
  • +

    + Effects: +

    +
    +++++ + + + + + + + + + + + + + + + + + + +
    + +

    + *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. +
    • +
  • + Example: +
    T x(12);
+T y(21);
+optional<T> def0 ;
+optional<T> def1 ;
+optional<T> optX(x);
+optional<T> optY(y);
+
+boost::swap(def0,def1); // no-op
+
+boost::swap(def0,optX);
+assert ( *def0 == x );
+assert ( !optX );
+
+boost::swap(def0,optX); // Get back to original values
+
+boost::swap(optX,optY);
+assert ( *optX == y );
+assert ( *optY == x );
+
    +
    • +
+

+ space +

+

+ void swap + ( optional<T&>& x, optional<T&>& y + ) noexcept + ; +

+
    +
  • + Postconditions: x + refers to what y refererred + to before the swap (if anything). y + refers to whatever x + referred to before the swap. +
    • +
  • + Example: +
    T x(12);
+T y(21);
+
+optional<T&> opt0;
+optional<T&> optX (x);
+optional<T&> optY (y);
+
+boost::swap(optX, optY);
+assert (addressof(*optX) == addressof(y));
+assert (addressof(*optY) == addressof(x));
+
+boost::swap(opt0, optX);
+assert ( opt0 );
+assert ( !optX );
+assert (addressof(*opt0) == addressof(y));
+
    +
    • +
+
+ + + +
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

+ 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) +

+
+
+
+PrevUpHomeNext +
+ + diff --git a/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___optional_references.html b/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___optional_references.html new file mode 100644 index 0000000..0bca093 --- /dev/null +++ b/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___optional_references.html @@ -0,0 +1,509 @@ + + + +Detailed Semantics - Optional References + + + + + + + + + + + + + + + +
Boost C++ LibrariesHomeLibrariesPeopleFAQMore
+
+
+PrevUpHomeNext +
+
+
+

+ space +

+

+ optional<T&>::optional() + noexcept; +

+

+ optional<T&>::optional(none_t) noexcept; +

+
  • + Postconditions: bool(*this) == false; *this refers to nothing. +
+

+ space +

+

+ template<class R> optional<T&>::optional(R&& r) noexcept; +

+
    +
  • + Postconditions: bool(*this) == true; addressof(**this) == addressof(r). +
    • +
  • + Remarks: Unless R + is an lvalue reference, the program is ill-formed. This constructor + does not participate in overload resolution if decay<R> is an instance of boost::optional. +
    • +
  • + Example: +
    T v;
+T& vref = v ;
+optional<T&> opt(vref);
+assert ( *opt == v ) ;
+++ v ; // mutate referee
+assert (*opt == v);
+
    +
    • +
+

+ space +

+

+ template<class R> optional<T&>::optional(bool cond, R&& + r) + noexcept; +

+
    +
  • + Effects: Initializes ref with expression cond ? + addressof(r) : nullptr. +
    • +
  • + Postconditions: bool(*this) == cond; If bool(*this), addressof(**this) == addressof(r). +
    • +
  • + Remarks: Unless R + is an lvalue reference, the program is ill-formed. This constructor + does not participate in overload resolution if decay<R> is an instance of boost::optional. +
    • +
+

+ space +

+

+ optional<T&>::optional ( + optional const& rhs + ) noexcept + ; +

+
    +
  • + Effects: Initializes ref with expression rhs.ref. +
    • +
  • + Postconditions: bool(*this) == bool(rhs). +
    • +
  • + Example: +
    optional<T&> uninit ;
+assert (!uninit);
+
+optional<T&> uinit2 ( uninit ) ;
+assert ( uninit2 == uninit );
+
+T v = 2 ; T& ref = v ;
+optional<T> init(ref);
+assert ( *init == v ) ;
+
+optional<T> init2 ( init ) ;
+assert ( *init2 == v ) ;
+
+v = 3 ;
+
+assert ( *init  == 3 ) ;
+assert ( *init2 == 3 ) ;
+
    +
    • +
+

+ space +

+

+ template<class U> explicit + optional<T&>::optional ( + optional<U&> + const& + rhs ) + noexcept ; +

+
    +
  • + Requires: is_convertible<U&, T&>::value + is true. +
    • +
  • + Effects: Initializes ref with expression rhs.ref. +
    • +
  • + Postconditions: bool(*this) == bool(rhs). +
    • +
+

+ space +

+

+ optional<T&>::operator= ( none_t + ) noexcept + ; +

+
    +
  • + Effects: Assigns ref + with expression nullptr. +
    • +
  • + returns: *this. +
    • +
  • + Postconditions: bool(*this) == false. +
    • +
+

+ optional& + optional<T&>::operator= ( optional + const& + rhs ) + noexcept ; +

+
    +
  • + Effects: Assigns ref + with expression rhs.ref. +
    • +
  • + returns: *this. +
    • +
  • + Postconditions: bool(*this) == bool(rhs). +
    • +
  • + Notes: This behaviour is called rebinding + semantics. See here + for details. +
    • +
  • + Example: +
    int a = 1 ;
+int b = 2 ;
+T& ra = a ;
+T& rb = b ;
+optional<int&> def ;
+optional<int&> ora(ra) ;
+optional<int&> orb(rb) ;
+
+def = orb ; // binds 'def' to 'b' through 'rb' wrapped within 'orb'
+assert ( *def == b ) ;
+*def = ora ; // changes the value of 'b' to a copy of the value of 'a'
+assert ( b == a ) ;
+int c = 3;
+int& rc = c ;
+optional<int&> orc(rc) ;
+ora = orc ; // REBINDS ora to 'c' through 'rc'
+c = 4 ;
+assert ( *ora == 4 ) ;
+
    +
    • +
+

+ template<class U> optional& optional<T&>::operator= ( optional<U&> const& rhs + ) noexcept + ; +

+
    +
  • + Requires: is_convertible<U&, T&>::value + is true. +
    • +
  • + Effects: Assigns ref + with expression rhs.ref. +
    • +
  • + returns: *this. +
    • +
  • + Postconditions: bool(*this) == bool(rhs). +
    • +
+

+ space +

+

+ template<class R> optional& optional<T&>::operator= ( R&& r + ) noexcept + ; +

+
    +
  • + Effects: Assigns ref + with expression r. +
    • +
  • + returns: *this. +
    • +
  • + Postconditions: bool(*this) == true. +
    • +
  • + Remarks: Unless R + is an lvalue reference, the program is ill-formed. This function does + not participate in overload resolution if decay<R> is an instance of boost::optional. +
    • +
  • + Example: +
    int a = 1 ;
+int b = 2 ;
+T& ra = a ;
+T& rb = b ;
+optional<int&> def ;
+optional<int&> opt(ra) ;
+
+def = rb ; // binds 'def' to 'b' through 'rb'
+assert ( *def == b ) ;
+*def = a ; // changes the value of 'b' to a copy of the value of 'a'
+assert ( b == a ) ;
+int c = 3;
+int& rc = c ;
+opt = rc ; // REBINDS to 'c' through 'rc'
+c = 4 ;
+assert ( *opt == 4 ) ;
+
    +
    • +
+

+ space +

+

+ void optional<T&>::emplace( R&& r + ) noexcept + ; +

+
    +
  • + Effects: Assigns ref + with expression r. +
    • +
  • + Postconditions: bool(*this) == true. +
    • +
  • + Remarks: Unless R + is an lvalue reference, the program is ill-formed. This function does + not participate in overload resolution if decay<R> is an instance of boost::optional. +
    • +
+

+ space +

+

+ T& + optional<T&>::get() const ; +

+

+ T& + optional<T&>::operator *() + const ; +

+
    +
  • + Requires: bool(*this) == true. +
    • +
  • + Effects: Returns *ref. +
    • +
  • + Throws: Nothing. +
    • +
  • + Example: +
    T v ;
+T& vref = v ;
+optional<T&> opt ( vref );
+T const& vref2 = *opt;
+assert ( vref2 == v ) ;
+++ v ;
+assert ( *opt == v ) ;
+
    +
    • +
+

+ space +

+

+ T* + optional<T&>::operator -> + () const + ; +

+
    +
  • + Requires: bool(*this) == true. +
    • +
  • + Effects: Returns ref. +
    • +
  • + Throws: Nothing. +
    • +
+

+ space +

+

+ T& + optional<T&>::value() const ; +

+
  • + Effects: Equivalent to return bool(*this) ? *val : throw bad_optional_access();. +
+

+ space +

+

+ template<class R> T& optional<T&>::value_or( R&& r + ) const + noexcept; +

+
    +
  • + Effects: Equivalent to if (*this) return **this; else return + r;. +
    • +
  • + Remarks: Unless R + is an lvalue reference, the program is ill-formed. +
    • +
+

+ space +

+

+ template<class F> T& optional<T&>::value_or( F f ) const ; +

+
    +
  • + Effects: Equivalent to if (*this) return **this; else return + f();. +
    • +
  • + Remarks: Unless decltype(f()) is an lvalue reference, the program + is ill-formed. +
    • +
+

+ space +

+

+ T* + optional<T&>::get_ptr () + const noexcept; +

+
  • + Returns: ref. +
+

+ space +

+

+ optional<T&>::operator bool + () const + noexcept; +

+
  • + Returns: bool(ref). +
+

+ space +

+

+ optional<T&>::operator ! () const noexcept; +

+
  • + Returns: !bool(ref). +
+

+ space +

+

+ void optional<T&>::reset() noexcept; +

+
    +
  • + Effects: Use *this = none instead. +
    • +
  • + Remarks: This function is depprecated. +
    • +
+

+ space +

+

+ template<class R> void optional<T&>::reset ( R&& + r) + noexcept; +

+
    +
  • + Effects: Equivalent to *this = std::forward<R>(r). +
    • +
  • + Remarks: This function is depprecated. +
    • +
+

+ space +

+

+ bool optional<T&>::is_initialized() const noexcept; +

+
    +
  • + Effects: Equivalent to return bool(*this). +
    • +
  • + Remarks: This function is depprecated. +
    • +
+

+ space +

+

+ template<class R> T& optional<T&>::get_value_or( R&& r + ) const + noexcept; +

+
    +
  • + Effects: Equivalent to return value_or(std::forward<R>(r);. +
    • +
  • + Remarks: This function is depprecated. +
    • +
+
+ + + +
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

+ 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) +

+
+
+
+PrevUpHomeNext +
+ + diff --git a/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___optional_values.html b/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___optional_values.html new file mode 100644 index 0000000..a33ad48 --- /dev/null +++ b/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___optional_values.html @@ -0,0 +1,1584 @@ + + + +Detailed Semantics - Optional Values + + + + + + + + + + + + + + + +
Boost C++ LibrariesHomeLibrariesPeopleFAQMore
+
+
+PrevUpHomeNext +
+
+
+
+ + + + + +
[Note]Note

+ The following section contains various assert() which are used only to show the postconditions + as sample code. It is not implied that the type T + must support each particular expression but that if the expression is + supported, the implied condition holds. +

+

+ space +

+

+ optional<T>::optional() + noexcept; +

+
    +
  • + Effect: Default-Constructs an optional. +
    • +
  • + Postconditions: *this is uninitialized. +
    • +
  • + Notes: T's default constructor is not called. +
    • +
  • + Example: +
    optional<T> def ;
+assert ( !def ) ;
+
    +
    • +
+

+ space +

+

+ optional<T>::optional( + none_t ) + noexcept; +

+
    +
  • + Effect: Constructs an optional uninitialized. +
    • +
  • + Postconditions: *this is uninitialized. +
    • +
  • + Notes: T's + default constructor is not called. + The expression boost::none + denotes an instance of boost::none_t + that can be used as the parameter. +
    • +
  • + Example: +
    #include <boost/none.hpp>
+optional<T> n(none) ;
+assert ( !n ) ;
+
    +
    • +
+

+ space +

+

+ optional<T>::optional( + T const& v ) +

+
    +
  • + Requires: is_copy_constructible<T>::value + is true. +
    • +
  • + Effect: Directly-Constructs an optional. +
    • +
  • + Postconditions: *this is initialized + and its value is a copy of v. +
    • +
  • + Throws: Whatever T::T( T const& + ) throws. +
    • +
  • + Notes: T::T( T const& + ) is called. +
    • +
  • + Exception Safety: Exceptions can only + be thrown during T::T( T const& + ); in that case, this constructor + has no effect. +
    • +
  • + Example: +
    T v;
+optional<T> opt(v);
+assert ( *opt == v ) ;
+
    +
    • +
+

+ space +

+

+ optional<T>::optional( + T&& + v ) +

+
    +
  • + Requires: is_move_constructible<T>::value + is true. +
    • +
  • + Effect: Directly-Move-Constructs an + optional. +
    • +
  • + Postconditions: *this is initialized + and its value is move-constructed from v. +
    • +
  • + Throws: Whatever T::T( T&& ) + throws. +
    • +
  • + Notes: T::T( T&& ) + is called. +
    • +
  • + Exception Safety: Exceptions can only + be thrown during T::T( T&& ); + in that case, the state of v + is determined by exception safety guarantees for T::T(T&&). +
    • +
  • + Example: +
    T v1, v2;
+optional<T> opt(std::move(v1));
+assert ( *opt == v2 ) ;
+
    +
    • +
+

+ space +

+

+ optional<T>::optional( + bool condition, T const& v ) ; +

+
  • + If condition is true, same as: +
+

+ optional<T>::optional( + T const& v ) +

+
  • + otherwise, same as: +
+

+ optional<T>::optional() +

+

+ space +

+

+ optional<T>::optional( + optional const& rhs + ); +

+
    +
  • + Requires: is_copy_constructible<T>::value + is true. +
    • +
  • + Effect: Copy-Constructs an optional. +
    • +
  • + Postconditions: If rhs is initialized, + *this + is initialized and its value is a copy of the + value of rhs; else + *this + is uninitialized. +
    • +
  • + Throws: Whatever T::T( T const& + ) throws. +
    • +
  • + Notes: If rhs is initialized, T::T(T const& ) + is called. +
    • +
  • + Exception Safety: Exceptions can only + be thrown during T::T( T const& + ); in that case, this constructor + has no effect. +
    • +
  • + Example: +
    optional<T> uninit ;
+assert (!uninit);
+
+optional<T> uinit2 ( uninit ) ;
+assert ( uninit2 == uninit );
+
+optional<T> init( T(2) );
+assert ( *init == T(2) ) ;
+
+optional<T> init2 ( init ) ;
+assert ( init2 == init ) ;
+
    +
    • +
+

+ space +

+

+ optional<T>::optional( + optional&& + rhs ) + noexcept(see + below); +

+
    +
  • + Requires: is_move_constructible<T>::value + is true. +
    • +
  • + Effect: Move-constructs an optional. +
    • +
  • + Postconditions: If rhs + is initialized, *this + is initialized and its value is move constructed from rhs; else *this is uninitialized. +
    • +
  • + Throws: Whatever T::T( T&& ) + throws. +
    • +
  • + Remarks: The expression inside noexcept is equivalent to is_nothrow_move_constructible<T>::value. +
    • +
  • + Notes: If rhs + is initialized, T::T( T && + ) is called. +
    • +
  • + Exception Safety: Exceptions can only + be thrown during T::T( T&& ); + in that case, rhs remains + initialized and the value of *rhs is determined by exception safety + of T::T(T&&). +
    • +
  • + Example: +
    optional<std::unique_ptr<T>> uninit ;
+assert (!uninit);
+
+optional<std::unique_ptr<T>> uinit2 ( std::move(uninit) ) ;
+assert ( uninit2 == uninit );
+
+optional<std::unique_ptr<T>> init( std::uniqye_ptr<T>(new T(2)) );
+assert ( **init == T(2) ) ;
+
+optional<std::unique_ptr<T>> init2 ( std::move(init) ) ;
+assert ( init );
+assert ( *init == nullptr );
+assert ( init2 );
+assert ( **init2 == T(2) ) ;
+
    +
    • +
+

+ space +

+

+ template<U> explicit optional<T>::optional( optional<U> const& rhs + ); +

+
    +
  • + Effect: Copy-Constructs 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::T( U const& + ) throws. +
    • +
  • + Notes: T::T( U const& + ) is called if rhs is initialized, which requires + a valid conversion from U + to T. +
    • +
  • + Exception Safety: Exceptions can only + be thrown during T::T( U const& + ); in that case, this constructor + has no effect. +
    • +
  • + Example: +
    optional<double> x(123.4);
+assert ( *x == 123.4 ) ;
+
+optional<int> y(x) ;
+assert( *y == 123 ) ;
+
    +
    • +
+

+ space +

+

+ template<U> explicit optional<T>::optional( optional<U>&& rhs + ); +

+
    +
  • + Effect: Move-constructs an optional. +
    • +
  • + Postconditions: If rhs + is initialized, *this + is initialized and its value is move-constructed from *rhs; + else *this + is uninitialized. +
    • +
  • + Throws: Whatever T::T( U&& ) + throws. +
    • +
  • + Notes: T::T( U&& ) + is called if rhs is + initialized, which requires a valid conversion from U + to T. +
    • +
  • + Exception Safety: Exceptions can only + be thrown during T::T( U&& ); + in that case, rhs remains + initialized and the value of *rhs is determined by exception safety + guarantee of T::T( U&& + ). +
    • +
  • + Example: +
    optional<double> x(123.4);
+assert ( *x == 123.4 ) ;
+
+optional<int> y(std::move(x)) ;
+assert( *y == 123 ) ;
+
    +
    • +
+

+ space +

+

+ template<InPlaceFactory> + explicit optional<T>::optional( InPlaceFactory + const& + f ); +

+

+ template<TypedInPlaceFactory> + explicit optional<T>::optional( TypedInPlaceFactory + const& + f ); +

+
    +
  • + Effect: Constructs an optional with a value of T obtained from the factory. +
    • +
  • + Postconditions: *this is initialized + and its value is directly given from the factory + f (i.e., the value + is not copied). +
    • +
  • + Throws: Whatever the T constructor called by the factory + throws. +
    • +
  • + Notes: See In-Place + Factories +
    • +
  • + Exception Safety: Exceptions can only + be thrown during the call to the T + constructor used by the factory; in that case, this constructor has + no effect. +
    • +
  • + Example: +
    class C { C ( char, double, std::string ) ; } ;
+
+C v('A',123.4,"hello");
+
+optional<C> x( in_place   ('A', 123.4, "hello") ); // InPlaceFactory used
+optional<C> y( in_place<C>('A', 123.4, "hello") ); // TypedInPlaceFactory used
+
+assert ( *x == v ) ;
+assert ( *y == v ) ;
+
    +
    • +
+

+ space +

+

+ optional& + optional<T>::operator= ( none_t + ) noexcept; +

+
    +
  • + Effect: If *this is initialized destroys its contained + value. +
    • +
  • + Postconditions: *this is uninitialized. +
    • +
+

+ space +

+

+ optional& + optional<T>::operator= ( T const& rhs ) ; +

+
    +
  • + Effect: Assigns the value rhs to an optional. +
    • +
  • + Postconditions: *this is initialized and its value is + a copy of rhs. +
    • +
  • + Throws: Whatever T::operator=( T const& + ) or T::T(T const&) + throws. +
    • +
  • + Notes: If *this was initialized, T's assignment operator is used, + otherwise, its copy-constructor is used. +
    • +
  • + 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 + copy constructor fails, *this is left properly uninitialized. +
    • +
  • + Example: +
    T x;
+optional<T> def ;
+optional<T> opt(x) ;
+
+T y;
+def = y ;
+assert ( *def == y ) ;
+opt = y ;
+assert ( *opt == y ) ;
+
    +
    • +
+

+ space +

+

+ optional& + optional<T>::operator= ( T&& rhs + ) ; +

+
    +
  • + Effect: Moves the value rhs to an optional. +
    • +
  • + Postconditions: *this is initialized and its value is + moved from rhs. +
    • +
  • + Throws: Whatever T::operator=( T&& ) + or T::T(T &&) + throws. +
    • +
  • + Notes: If *this was initialized, T's move-assignment operator is used, + otherwise, its move-constructor is used. +
    • +
  • + 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 + move constructor fails, *this is left properly uninitialized. +
    • +
  • + Example: +
    T x;
+optional<T> def ;
+optional<T> opt(x) ;
+
+T y1, y2, yR;
+def = std::move(y1) ;
+assert ( *def == yR ) ;
+opt = std::move(y2) ;
+assert ( *opt == yR ) ;
+
    +
    • +
+

+ space +

+

+ optional& + optional<T>::operator= ( optional + const& + rhs ) + ; +

+
    +
  • + Requires: T + is CopyConstructible and CopyAssignable. +
    • +
  • +

    + Effects: +

    +
    +++++ + + + + + + + + + + + + + + + + + + +
    + +

    + *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. If an exception is thrown during the call to T's copy constructor, no effect. + If an exception is thrown during the call to T's + copy assignment, the state of its contained value is as defined by + the exception safety guarantee of T's + copy assignment. +
    • +
  • + Example: +
    T v;
+optional<T> opt(v);
+optional<T> def ;
+
+opt = def ;
+assert ( !def ) ;
+// previous value (copy of 'v') destroyed from within 'opt'.
+
    +
    • +
+

+ space +

+

+ optional& + optional<T>::operator= ( optional&& rhs + ) noexcept(see below); +

+
    +
  • + Requires: T + is MoveConstructible + and MoveAssignable. +
    • +
  • +

    + Effects: +

    +
    +++++ + + + + + + + + + + + + + + + + + + +
    + +

    + *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. +
    • +
  • + Exception Safety: If any exception + is thrown, the initialization state of *this and rhs + remains unchanged. If an exception is thrown during the call to T's move constructor, the state of + *rhs + is determined by the exception safety guarantee of T's + move constructor. If an exception is thrown during the call to T's + move-assignment, the state of **this and *rhs is determined by the exception + safety guarantee of T's move assignment. +
    • +
  • + Example: +
    optional<T> opt(T(2)) ;
+optional<T> def ;
+
+opt = def ;
+assert ( def ) ;
+assert ( opt ) ;
+assert ( *opt == T(2) ) ;
+
    +
    • +
+

+ space +

+

+ template<U> optional& + optional<T>::operator= ( optional<U> const& rhs + ) ; +

+
    +
  • +

    + Effect: +

    +
    +++++ + + + + + + + + + + + + + + + + + + +
    + +

    + *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;
+optional<T> opt0(v);
+optional<U> opt1;
+
+opt1 = opt0 ;
+assert ( *opt1 == static_cast<U>(v) ) ;
+
    +
    • +
+

+ space +

+

+ template<U> optional& + optional<T>::operator= ( optional<U>&& rhs + ) ; +

+
    +
  • +

    + Effect: +

    +
    +++++ + + + + + + + + + + + + + + + + + + +
    + +

    + *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;
+optional<T> opt0(v);
+optional<U> opt1;
+
+opt1 = std::move(opt0) ;
+assert ( opt0 );
+assert ( opt1 )
+assert ( *opt1 == static_cast<U>(v) ) ;
+
    +
    • +
+

+ space +

+

+ template<class... Args> + void optional<T>::emplace( Args...&& args + ); +

+
    +
  • + Requires: The compiler supports rvalue + references and variadic templates. +
    • +
  • + Effect: If *this is initialized calls *this = none. + Then initializes in-place the contained value as if direct-initializing + an object of type T + with std::forward<Args>(args).... +
    • +
  • + Postconditions: *this is initialized. +
    • +
  • + Throws: Whatever the selected T's constructor throws. +
    • +
  • + Exception Safety: If an exception + is thrown during the initialization of T, + *this + is uninitialized. +
    • +
  • + Notes: T + need not be MoveConstructible + 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;
+optional<const T> opt;
+opt.emplace(0);  // create in-place using ctor T(int)
+opt.emplace();   // destroy previous and default-construct another T
+opt.emplace(v);  // destroy and copy-construct in-place (no assignment called)
+
    +
    • +
+

+ space +

+

+ template<InPlaceFactory> + optional<T>& + optional<T>::operator=( InPlaceFactory const& f ); +

+

+ template<TypedInPlaceFactory> + optional<T>& + optional<T>::operator=( TypedInPlaceFactory const& f ); +

+
    +
  • + Effect: Assigns an optional + with a value of T obtained + from the factory. +
    • +
  • + Postconditions: *this is initialized + and its value is directly given from the factory + f (i.e., the value + is not copied). +
    • +
  • + Throws: Whatever the T constructor called by the factory + throws. +
    • +
  • + Notes: See In-Place + Factories +
    • +
  • + Exception Safety: Exceptions can only + be thrown during the call to the T + constructor used by the factory; in that case, the optional + object will be reset to be uninitialized. +
    • +
+

+ space +

+

+ void optional<T>::reset( T const& v ) ; +

+
  • + Deprecated: same as operator= + ( T + const& + v) + ; +
+

+ space +

+

+ void optional<T>::reset() noexcept + ; +

+
  • + Deprecated: Same as operator=( + none_t ); +
+

+ space +

+

+ T const& optional<T>::get() const ; +

+

+ T& + optional<T>::get() ; +

+

+ inline T + const& + get ( + optional<T> const& ) ; +

+

+ inline T& get + ( optional<T> &) + ; +

+
    +
  • + Requires: *this is initialized +
    • +
  • + Returns: A reference to the contained + value +
    • +
  • + Throws: Nothing. +
    • +
  • + Notes: The requirement is asserted + via BOOST_ASSERT(). +
    • +
+

+ space +

+

+ T const& optional<T>::operator*() const& ; +

+

+ T& + optional<T>::operator*() + &; +

+
    +
  • + Requires: *this is initialized +
    • +
  • + Returns: A reference to the contained + value +
    • +
  • + Throws: Nothing. +
    • +
  • + Notes: The requirement is asserted + via BOOST_ASSERT(). + On compilers that do not support ref-qualifiers on member functions + these two overloads are replaced with the classical two: a const and non-const + member functions. +
    • +
  • + Example: +
    T v ;
+optional<T> opt ( v );
+T const& u = *opt;
+assert ( u == v ) ;
+T w ;
+*opt = w ;
+assert ( *opt == w ) ;
+
    +
    • +
+

+ space +

+

+ T&& + optional<T>::operator*() + &&; +

+
    +
  • + Requires: *this contains a value. +
    • +
  • + Effects: Equivalent to return std::move(*val);. +
    • +
  • + Notes: The requirement is asserted + via BOOST_ASSERT(). + On compilers that do not support ref-qualifiers on member functions + this overload is not present. +
    • +
+

+ space +

+

+ T const& optional<T>::value() const& ; +

+

+ T& + optional<T>::value() & ; +

+
    +
  • + Effects: Equivalent to return bool(*this) ? *val : throw bad_optional_access();. +
    • +
  • + Notes: On compilers that do not support + ref-qualifiers on member functions these two overloads are replaced + with the classical two: a const + and non-const member functions. +
    • +
  • + Example: +
    T v ;
+optional<T> o0, o1 ( v );
+assert ( o1.value() == v );
+
+try {
+  o0.value(); // throws
+  assert ( false );
+}
+catch(bad_optional_access&) {
+  assert ( true );
+}
+
    +
    • +
+

+ space +

+

+ T&& + optional<T>::value() && ; +

+
    +
  • + Effects: Equivalent to return bool(*this) ? std::move(*val) : throw bad_optional_access();. +
    • +
  • + Notes: On compilers that do not support + ref-qualifiers on member functions this overload is not present. +
    • +
+

+ space +

+

+ template<class U> T optional<T>::value_or(U && + v) + const& + ; +

+
    +
  • + Effects: Equivalent to if (*this) return **this; else return + std::forward<U>(v);. +
    • +
  • + Remarks: If T + is not CopyConstructible or U && + is not convertible to T, + the program is ill-formed. +
    • +
  • + Notes: On compilers that do not support + ref-qualifiers on member functions this overload is replaced with the + const-qualified member + function. On compilers without rvalue reference support the type of + v becomes U const&. +
    • +
+

+ space +

+

+ template<class U> T optional<T>::value_or(U && + v) + && ; +

+
    +
  • + Effects: Equivalent to if (*this) return std::move(**this); else return std::forward<U>(v);. +
    • +
  • + Remarks: If T + is not MoveConstructible + or U && + is not convertible to T, + the program is ill-formed. +
    • +
  • + Notes: On compilers that do not support + ref-qualifiers on member functions this overload is not present. +
    • +
+

+ space +

+

+ template<class F> T optional<T>::value_or_eval(F f) const& ; +

+
    +
  • + Requires: T + is CopyConstructible and F models a Generator whose result type + is convertible to T. +
    • +
  • + Effects: if + (*this) return **this; else return f();. +
    • +
  • + Notes: On compilers that do not support + ref-qualifiers on member functions this overload is replaced with the + const-qualified member + function. +
    • +
  • + Example: +
    int complain_and_0()
+{
+  clog << "no value returned, using default" << endl;
+  return 0;
+}
+
+optional<int> o1 = 1;
+optional<int> oN = none;
+
+int i = o1.value_or_eval(complain_and_0); // fun not called
+assert (i == 1);
+
+int j = oN.value_or_eval(complain_and_0); // fun called
+assert (i == 0);
+
    +
    • +
+

+ space +

+

+ template<class F> T optional<T>::value_or_eval(F f) && + ; +

+
    +
  • + Requires: T + is MoveConstructible + and F models a Generator + whose result type is convertible to T. +
    • +
  • + Effects: if + (*this) return std::move(**this); else return + f();. +
    • +
  • + Notes: On compilers that do not support + ref-qualifiers on member functions this overload is not present. +
    • +
+

+ space +

+

+ T const& optional<T>::get_value_or( T const& default) const ; +

+

+ T& + optional<T>::get_value_or( + T& + default ) + ; +

+
    +
  • + Deprecated: Use value_or() instead. +
    • +
  • + Returns: A reference to the contained + value, if any, or default. +
    • +
  • + Throws: Nothing. +
    • +
  • + Example: +
    T v, z ;
+optional<T> def;
+T const& y = def.get_value_or(z);
+assert ( y == z ) ;
+
+optional<T> opt ( v );
+T const& u = opt.get_value_or(z);
+assert ( u == v ) ;
+assert ( u != z ) ;
+
    +
    • +
+

+ space +

+

+ T const* optional<T>::get_ptr() const ; +

+

+ T* + optional<T>::get_ptr() + ; +

+
    +
  • + Returns: If *this is initialized, a pointer to the + contained value; else 0 + (null). +
    • +
  • + Throws: Nothing. +
    • +
  • + Notes: The contained value is permanently + stored within *this, + so you should not hold nor delete this pointer +
    • +
  • + Example: +
    T v;
+optional<T> opt(v);
+optional<T> const copt(v);
+T* p = opt.get_ptr() ;
+T const* cp = copt.get_ptr();
+assert ( p == get_pointer(opt) );
+assert ( cp == get_pointer(copt) ) ;
+
    +
    • +
+

+ space +

+

+ T const* optional<T>::operator + ->() const + ; +

+

+ T* + optional<T>::operator ->() + ; +

+
    +
  • + Requires: *this is initialized. +
    • +
  • + Returns: A pointer to the contained + value. +
    • +
  • + Throws: Nothing. +
    • +
  • + Notes: The requirement is asserted + via BOOST_ASSERT(). +
    • +
  • + Example: +
    struct X { int mdata ; } ;
+X x ;
+optional<X> opt (x);
+opt->mdata = 2 ;
+
    +
    • +
+

+ space +

+

+ explicit optional<T>::operator + bool() + const noexcept + ; +

+
    +
  • + Returns: get_ptr() != 0. +
    • +
  • + Notes: On compilers that do not support + explicit conversion operators this falls back to safe-bool idiom. +
    • +
  • + Example: +
    optional<T> def ;
+assert ( def == 0 );
+optional<T> opt ( v ) ;
+assert ( opt );
+assert ( opt != 0 );
+
    +
    • +
+

+ space +

+

+ bool optional<T>::operator!() noexcept + ; +

+
    +
  • + Returns: If *this is uninitialized, true; else false. +
    • +
  • + Notes: This operator is provided for + those compilers which can't use the unspecified-bool-type + operator in certain boolean contexts. +
    • +
  • + Example: +
    optional<T> opt ;
+assert ( !opt );
+*opt = some_T ;
+
+// Notice the "double-bang" idiom here.
+assert ( !!opt ) ;
+
    +
    • +
+

+ space +

+

+ bool optional<T>::is_initialized() const ; +

+
  • + Deprecated: Same as explicit operator + bool () + ; +
+
+ + + +
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

+ 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) +

+
+
+
+PrevUpHomeNext +
+ + diff --git a/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/header__boost_optional_hpp_.html b/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/header__boost_optional_hpp_.html new file mode 100644 index 0000000..8496d37 --- /dev/null +++ b/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/header__boost_optional_hpp_.html @@ -0,0 +1,47 @@ + + + +Header <boost/optional.hpp> + + + + + + + + + + + + + + + +
Boost C++ LibrariesHomeLibrariesPeopleFAQMore
+
+
+PrevUpHomeNext +
+
+
+

+ This is an alias for header <boost/optional/optional.hpp>. +

+
+ + + +
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

+ 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) +

+
+
+
+PrevUpHomeNext +
+ + diff --git a/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/header_optional_optional_refs.html b/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/header_optional_optional_refs.html new file mode 100644 index 0000000..c3325c5 --- /dev/null +++ b/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/header_optional_optional_refs.html @@ -0,0 +1,113 @@ + + + +Optional References + + + + + + + + + + + + + + + +
Boost C++ LibrariesHomeLibrariesPeopleFAQMore
+
+
+PrevUpHomeNext +
+
+
+
template <class T>
+class optional<T&> // specilization for lvalue references
+{
+public :
+
+    typedef T& value_type;
+    typedef T& reference_type;
+    typedef T& reference_const_type; // no const propagation
+    typedef T* pointer_type;
+    typedef T* pointer_const_type;   // no const propagation
+
+    optional () noexcept ; R
+
+    optional ( none_t ) noexcept ; R
+
+    template<class R> optional(R&& r) noexcept ;  R
+
+    template <class R> optional(bool cond, R&& r) noexcept ; R
+
+    optional ( optional const& rhs ) noexcept ; R
+
+    template<class U> explicit optional ( optional<U&> const& rhs ) noexcept ; R
+
+    optional& operator = ( none_t ) noexcept ; R
+
+
+    optional& operator = ( optional const& rhs ) noexcept; R
+
+    template<class U> optional& operator = ( optional<U&> const& rhs ) noexcept ; R
+
+    template<class R> optional& operator = (R&& r) noexcept ; R
+
+    template<class R> void emplace ( R&& r ) noexcept ; R
+
+    T& get() const ; R
+    T& operator *() const ; R
+
+    T* operator ->() const ; R
+
+    T& value() const& ; R
+
+    template<class R> T& value_or( R && r ) const noexcept ; R
+
+    template<class F> T& value_or_eval( F f ) const ; R
+
+    T* get_ptr() const noexcept ; R
+
+    explicit operator bool() const noexcept ; R
+
+    bool operator!() const noexcept ; R
+
+    // deprecated methods
+
+    // (deprecated)
+    void reset() noexcept ; R
+
+    // (deprecated)
+    template<class R> void reset ( R && r ) noexcept ; R
+
+    // (deprecated)
+    bool is_initialized() const noexcept ; R
+
+    // (deprecated)
+    template<class R> T& get_value_or( R && r ) constnoexcept; R
+
+private:
+    T* ref; // exposition only
+};
+
+
+ + + +
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

+ 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) +

+
+
+
+PrevUpHomeNext +
+ + diff --git a/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/header_optional_optional_values.html b/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/header_optional_optional_values.html new file mode 100644 index 0000000..2877563 --- /dev/null +++ b/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/header_optional_optional_values.html @@ -0,0 +1,140 @@ + + + +Optional Values + + + + + + + + + + + + + + + +
Boost C++ LibrariesHomeLibrariesPeopleFAQMore
+
+
+PrevUpHomeNext +
+
+
+
template <class T>
+class optional
+{
+public :
+
+    typedef T         value_type ;
+    typedef T &       reference_type ;
+    typedef T const&  reference_const_type ;
+    typedef T *       pointer_type ;
+    typedef T const*  pointer_const_type ;
+
+    optional () noexcept ; R
+
+    optional ( none_t ) noexcept ; R
+
+    optional ( T const& v ) ; R
+
+    optional ( T&& v ) ; R
+
+    // [new in 1.34]
+    optional ( bool condition, T const& v ) ; R
+
+    optional ( optional const& rhs ) ; R
+
+    optional ( optional&& rhs ) noexcept(see below) ; R
+
+    template<class U> explicit optional ( optional<U> const& rhs ) ; R
+
+    template<class U> explicit optional ( optional<U>&& rhs ) ; R
+
+    template<class InPlaceFactory> explicit optional ( InPlaceFactory const& f ) ; R
+
+    template<class TypedInPlaceFactory> explicit optional ( TypedInPlaceFactory const& f ) ; R
+
+    optional& operator = ( none_t ) noexcept ; R
+
+    optional& operator = ( T const& v ) ; R
+
+    optional& operator = ( T&& v ) ; R
+
+    optional& operator = ( optional const& rhs ) ; R
+
+    optional& operator = ( optional&& rhs ) noexcept(see below) ; R
+
+    template<class U> optional& operator = ( optional<U> const& rhs ) ; R
+
+    template<class U> optional& operator = ( optional<U>&& rhs ) ; R
+
+    template<class... Args> void emplace ( Args...&& args ) ; R
+
+    template<class InPlaceFactory> optional& operator = ( InPlaceFactory const& f ) ; R
+
+    template<class TypedInPlaceFactory> optional& operator = ( TypedInPlaceFactory const& f ) ; R
+
+    T const& get() const ; R
+    T&       get() ; R
+
+    T const* operator ->() const ; R
+    T*       operator ->() ; R
+
+    T const& operator *() const& ; R
+    T&       operator *() & ; R
+    T&&      operator *() && ; R
+
+    T const& value() const& ; R
+    T&       value() & ; R
+    T&&      value() && ; R
+
+    template<class U> T value_or( U && v ) const& ; R
+    template<class U> T value_or( U && v ) && ; R
+
+    template<class F> T value_or_eval( F f ) const& ; R
+    template<class F> T value_or_eval( F f ) && ; R
+
+    T const* get_ptr() const ; R
+    T*       get_ptr() ; R
+
+    explicit operator bool() const noexcept ; R
+
+    bool operator!() const noexcept ; R
+
+    // deprecated methods
+
+    // (deprecated)
+    void reset() noexcept ; R
+
+    // (deprecated)
+    void reset ( T const& ) ; R
+
+    // (deprecated)
+    bool is_initialized() const ; R
+
+    // (deprecated)
+    T const& get_value_or( T const& default ) const ; R
+};
+
+
+ + + +
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

+ 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) +

+
+
+
+PrevUpHomeNext +
+ + diff --git a/doc/html/boost_optional/reference/io_header.html b/doc/html/boost_optional/reference/io_header.html index c61e5c6..263e710 100644 --- a/doc/html/boost_optional/reference/io_header.html +++ b/doc/html/boost_optional/reference/io_header.html @@ -58,7 +58,7 @@
-
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

diff --git a/doc/html/boost_optional/reference/io_header/io_semantics.html b/doc/html/boost_optional/reference/io_header/io_semantics.html index c368ac7..767cc48 100644 --- a/doc/html/boost_optional/reference/io_header/io_semantics.html +++ b/doc/html/boost_optional/reference/io_header/io_semantics.html @@ -98,7 +98,7 @@
-
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

diff --git a/doc/html/boost_optional/reference/relnotes.html b/doc/html/boost_optional/reference/relnotes.html new file mode 100644 index 0000000..c67535e --- /dev/null +++ b/doc/html/boost_optional/reference/relnotes.html @@ -0,0 +1,183 @@ + + + +Release Notes + + + + + + + + + + + + + + + +
Boost C++ LibrariesHomeLibrariesPeopleFAQMore
+
+
+PrevUpHomeNext +
+
+
+
+ + Boost Release + X.XX +
+
  • + Now boost::optional is specialized for reference + parameters. This way the sizeof + of optional reference is that of a pointer, and a number of bugs is avoided. +
+
+ + 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 Trac + #11203. +
+
+ + 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 Trac + #11241. +
    • +
+
+ + 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 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 Trac + #10399. +
    • +
  • + It is no longer possible to assign optional<U> to optional<T> when U + is not assignable or convertible to T + (Trac #11087). +
    • +
  • + Value accessors now work correctly on rvalues of optional<T&> (Trac + #10839). +
    • +
+
+ + Boost Release + 1.57 +
+
  • + Git pull #9: + "Supply <string> + to fix C++03 compile error on logic_error("...")". +
+
+ + 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 + 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 (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 (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. +
    • +
+
+ + + +
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

+ 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) +

+
+
+
+PrevUpHomeNext +
+ + diff --git a/doc/html/boost_optional/relnotes.html b/doc/html/boost_optional/relnotes.html index 4526c48..50ddc8e 100644 --- a/doc/html/boost_optional/relnotes.html +++ b/doc/html/boost_optional/relnotes.html @@ -28,6 +28,46 @@

+ Boost + Release X.XX +

+
    +
  • + Now boost::optional is specialized for reference + parameters. This addresses a couple of issues: +
      +
    • + the sizeof of optional + reference is that of a pointer, +
      • +
    • + some bugs connected to copying optional references are gone, +
      • +
    • + all run-time bugs caused by incorrect reference binding on some compilers + are now turned into compile-time errors, +
      • +
    • + you can swap optional references: it is like swapping pointers: shalow, + underlying objects are not affected, +
      • +
    • + optional references to abstract types work. +
      • +
    +
    • +
  • + Documented nested typedefs (Trac + #5193). +
    • +
  • + Made the perfect-forwarding constructor SFINAE-friendly, which fixes Trac #12002. + However, this only works in the newer compilers that implement variadic + macros and decltype correctly. +
    • +
+

+ Boost Release 1.60

@@ -38,7 +78,7 @@ #11203.

- + Boost Release 1.59

@@ -52,7 +92,7 @@

- + Boost Release 1.58

@@ -88,7 +128,7 @@

- + Boost Release 1.57

@@ -98,7 +138,7 @@ to fix C++03 compile error on logic_error("...")".

- + Boost Release 1.56

@@ -155,7 +195,7 @@ -
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

diff --git a/doc/html/boost_optional/tutorial/a_note_about_optional_bool_.html b/doc/html/boost_optional/tutorial/a_note_about_optional_bool_.html index def5bbf..ffd5c3d 100644 --- a/doc/html/boost_optional/tutorial/a_note_about_optional_bool_.html +++ b/doc/html/boost_optional/tutorial/a_note_about_optional_bool_.html @@ -94,7 +94,7 @@
-
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

diff --git a/doc/html/boost_optional/tutorial/design_overview.html b/doc/html/boost_optional/tutorial/design_overview.html index cc5e3b4..0aeb0c0 100644 --- a/doc/html/boost_optional/tutorial/design_overview.html +++ b/doc/html/boost_optional/tutorial/design_overview.html @@ -170,7 +170,7 @@
-
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

diff --git a/doc/html/boost_optional/tutorial/design_overview/the_interface.html b/doc/html/boost_optional/tutorial/design_overview/the_interface.html index c3833ff..77e17a5 100644 --- a/doc/html/boost_optional/tutorial/design_overview/the_interface.html +++ b/doc/html/boost_optional/tutorial/design_overview/the_interface.html @@ -142,10 +142,10 @@ about the possibly uninitialized state appealing to the familiar pointer semantics w.r.t. to null pointers.

-
+
- - + +
[Warning]Warning[Caution]Caution

However, it is particularly important to note that optional<> objects are not pointers. optional<> is not, and does not model, a @@ -173,7 +173,7 @@ -
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

diff --git a/doc/html/boost_optional/tutorial/design_overview/the_semantics.html b/doc/html/boost_optional/tutorial/design_overview/the_semantics.html index 9a38fef..2a19976 100644 --- a/doc/html/boost_optional/tutorial/design_overview/the_semantics.html +++ b/doc/html/boost_optional/tutorial/design_overview/the_semantics.html @@ -107,7 +107,7 @@
-
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

diff --git a/doc/html/boost_optional/tutorial/exception_safety_guarantees.html b/doc/html/boost_optional/tutorial/exception_safety_guarantees.html index dfa34c8..edce61d 100644 --- a/doc/html/boost_optional/tutorial/exception_safety_guarantees.html +++ b/doc/html/boost_optional/tutorial/exception_safety_guarantees.html @@ -161,7 +161,7 @@
-
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

diff --git a/doc/html/boost_optional/tutorial/in_place_factories.html b/doc/html/boost_optional/tutorial/in_place_factories.html index 4cfef32..3b72041 100644 --- a/doc/html/boost_optional/tutorial/in_place_factories.html +++ b/doc/html/boost_optional/tutorial/in_place_factories.html @@ -6,7 +6,7 @@ - + @@ -20,7 +20,7 @@
-PrevUpHomeNext +PrevUpHomeNext

@@ -183,7 +183,7 @@

-
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

@@ -191,7 +191,7 @@
-PrevUpHomeNext +PrevUpHomeNext
diff --git a/doc/html/boost_optional/tutorial/io_operators.html b/doc/html/boost_optional/tutorial/io_operators.html index 8443a49..05f5af0 100644 --- a/doc/html/boost_optional/tutorial/io_operators.html +++ b/doc/html/boost_optional/tutorial/io_operators.html @@ -73,7 +73,7 @@
-
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

diff --git a/doc/html/boost_optional/tutorial/optional_references.html b/doc/html/boost_optional/tutorial/optional_references.html index 1320941..9dd45b3 100644 --- a/doc/html/boost_optional/tutorial/optional_references.html +++ b/doc/html/boost_optional/tutorial/optional_references.html @@ -7,7 +7,7 @@ - + @@ -20,88 +20,90 @@
-PrevUpHomeNext +PrevUpHomeNext
+
+

- This library allows the template parameter T - to be of reference type: T&, and to some extent, T - const&. -

+ This library allows the template parameter T + to be of reference type: T&, and to some extent, T const&. +

- However, since references are not real objects some restrictions apply and - some operations are not available in this case: -

+ However, since references are not real objects some restrictions apply + and some operations are not available in this case: +

  • - Converting constructors -
    • + Converting constructors +
  • - Converting assignment -
    • + Converting assignment +
  • - InPlace construction -
    • + InPlace construction +
  • - InPlace assignment -
    • + InPlace assignment +
  • - Value-access via pointer -
    • + Value-access via pointer +

- Also, even though optional<T&> - treats it wrapped pseudo-object much as a real value, a true real reference - is stored so aliasing will ocurr: -

+ Also, even though optional<T&> treats it wrapped pseudo-object + much as a real value, a true real reference is stored so aliasing will + ocurr: +

  • - Copies of optional<T&> - will copy the references but all these references will nonetheless refer - to the same object. -
    • + Copies of optional<T&> will copy the references but + all these references will nonetheless refer to the same object. +
  • - Value-access will actually provide access to the referenced object rather - than the reference itself. -
    • + Value-access will actually provide access to the referenced object + rather than the reference itself. +
-
+
- - + + + On compilers that do not conform to Standard C++ rules of reference binding, + some operations on optional references are disabled in order to prevent + subtle bugs. For more details see Dependencies + and Portability section. +

[Warning]Warning[Caution]Caution

- On compilers that do not conform to Standard C++ rules of reference binding, - operations on optional references might give adverse results: rather than - binding a reference to a designated object they may create an unexpected - temporary and bind to it. For more details see Dependencies - and Portability section. -

-
- - Rvalue - references -
+
+ + Rvalue + references +

- Rvalue references and lvalue references to const have the ability in C++ - to extend the life time of a temporary they bind to. Optional references - do not have this capability, therefore to avoid surprising effects it is - not possible to initialize an optional references from a temporary. Optional - rvalue references are disabled altogether. Also, the initialization and assignment - of an optional reference to const from rvalue reference is disabled. -

+ Rvalue references and lvalue references to const have the ability in C++ + to extend the life time of a temporary they bind to. Optional references + do not have this capability, therefore to avoid surprising effects it is + not possible to initialize an optional references from a temporary. Optional + rvalue references are disabled altogether. Also, the initialization and + assignment of an optional reference to const from rvalue reference is disabled. + 

const int& i = 1;            // legal
 optional<const int&> oi = 1; // illegal
+
-
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

@@ -109,7 +111,7 @@
-PrevUpHomeNext +PrevUpHomeNext
diff --git a/doc/html/boost_optional/tutorial/performance_considerations.html b/doc/html/boost_optional/tutorial/performance_considerations.html index 2e2d4ca..db70539 100644 --- a/doc/html/boost_optional/tutorial/performance_considerations.html +++ b/doc/html/boost_optional/tutorial/performance_considerations.html @@ -209,7 +209,7 @@
-
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

diff --git a/doc/html/boost_optional/tutorial/rebinding_semantics_for_assignment_of_optional_references.html b/doc/html/boost_optional/tutorial/rebinding_semantics_for_assignment_of_optional_references.html index a4c566f..ee693ee 100644 --- a/doc/html/boost_optional/tutorial/rebinding_semantics_for_assignment_of_optional_references.html +++ b/doc/html/boost_optional/tutorial/rebinding_semantics_for_assignment_of_optional_references.html @@ -135,7 +135,7 @@
-
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

diff --git a/doc/html/boost_optional/tutorial/relational_operators.html b/doc/html/boost_optional/tutorial/relational_operators.html index 3191427..0bfaec6 100644 --- a/doc/html/boost_optional/tutorial/relational_operators.html +++ b/doc/html/boost_optional/tutorial/relational_operators.html @@ -99,7 +99,7 @@
-
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

diff --git a/doc/html/boost_optional/tutorial/type_requirements.html b/doc/html/boost_optional/tutorial/type_requirements.html index 12cc30a..8c7a9e0 100644 --- a/doc/html/boost_optional/tutorial/type_requirements.html +++ b/doc/html/boost_optional/tutorial/type_requirements.html @@ -95,7 +95,7 @@
-
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

diff --git a/doc/html/boost_optional/tutorial/when_to_use_optional.html b/doc/html/boost_optional/tutorial/when_to_use_optional.html index fd27d80..5046f61 100644 --- a/doc/html/boost_optional/tutorial/when_to_use_optional.html +++ b/doc/html/boost_optional/tutorial/when_to_use_optional.html @@ -128,7 +128,7 @@
-
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

diff --git a/doc/html/index.html b/doc/html/index.html index 1f97394..b3bf68a 100644 --- a/doc/html/index.html +++ b/doc/html/index.html @@ -26,7 +26,7 @@ Fernando Luis Cacciola Carballal

Copyright © 2003-2007 Fernando Luis Cacciola Carballal

-

Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2014-2016 Andrzej Krzemieński

Distributed under the Boost Software License, Version 1.0. (See accompanying @@ -62,8 +62,6 @@

IO operators
Optional references
-
Rebinding - semantics for assignment of optional references
In-Place Factories
A @@ -146,7 +144,7 @@
- +

Last revised: October 20, 2015 at 21:17:45 GMT

Last revised: February 19, 2016 at 17:45:39 GMT
diff --git a/doc/html/optional/reference.html b/doc/html/optional/reference.html index 0cc575c..1c9b792 100644 --- a/doc/html/optional/reference.html +++ b/doc/html/optional/reference.html @@ -75,7 +75,7 @@ -
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

diff --git a/doc/html/optional/reference/header__boost_optional_optional_hpp_.html b/doc/html/optional/reference/header__boost_optional_optional_hpp_.html index c5f3e55..a395d63 100644 --- a/doc/html/optional/reference/header__boost_optional_optional_hpp_.html +++ b/doc/html/optional/reference/header__boost_optional_optional_hpp_.html @@ -7,7 +7,7 @@ - + @@ -20,7 +20,7 @@
-PrevUpHomeNext +PrevUpHomeNext

@@ -36,134 +36,50 @@ namespace boost { template <class T> -class optional -{ -public : +class optional ; R - typedef T value_type; +template <class T> +class optional<T&> ; R - // (If T is of reference type, the parameters and results by reference are by value) +template<class T> inline bool operator == ( optional<T> const& x, optional<T> const& y ) ; R - optional () noexcept ; R +template<class T> inline bool operator != ( optional<T> const& x, optional<T> const& y ) ; R - optional ( none_t ) noexcept ; R +template<class T> inline bool operator < ( optional<T> const& x, optional<T> const& y ) ; R - optional ( T const& v ) ; R +template<class T> inline bool operator > ( optional<T> const& x, optional<T> const& y ) ; R - optional ( T&& v ) ; R +template<class T> inline bool operator <= ( optional<T> const& x, optional<T> const& y ) ; R - // [new in 1.34] - optional ( bool condition, T const& v ) ; R +template<class T> inline bool operator >= ( optional<T> const& x, optional<T> const& y ) ; R - optional ( optional const& rhs ) ; R +template<class T> inline bool operator == ( optional<T> const& x, none_t ) noexcept ; R - optional ( optional&& rhs ) noexcept(see below) ; R +template<class T> inline bool operator != ( optional<T> const& x, none_t ) noexcept ; R - template<class U> explicit optional ( optional<U> const& rhs ) ; R +template<class T> inline optional<T> make_optional ( T const& v ) ; R - template<class U> explicit optional ( optional<U>&& rhs ) ; R +template<class T> inline optional<T> make_optional ( bool condition, T const& v ) ; R - template<class InPlaceFactory> explicit optional ( InPlaceFactory const& f ) ; R +template<class T> inline auto get_optional_value_or ( optional<T> const& opt, typename optional<T>::reference_const_type def ) -> typename optional<T>::reference_const_type; R - template<class TypedInPlaceFactory> explicit optional ( TypedInPlaceFactory const& f ) ; R +template<class T> inline auto get_optional_value_or ( optional<T> const& opt, typename optional<T>::reference_type def ) -> typename optional<T>::reference_type ; R - optional& operator = ( none_t ) noexcept ; R +template<class T> inline T const& get ( optional<T> const& opt ) ; R - optional& operator = ( T const& v ) ; R +template<class T> inline T& get ( optional<T> & opt ) ; R - optional& operator = ( T&& v ) ; R +template<class T> inline T const* get ( optional<T> const* opt ) ; R - optional& operator = ( optional const& rhs ) ; R +template<class T> inline T* get ( optional<T>* opt ) ; R - optional& operator = ( optional&& rhs ) noexcept(see below) ; R +template<class T> inline auto get_pointer ( optional<T> const& opt ) -> see below; R - template<class U> optional& operator = ( optional<U> const& rhs ) ; R +template<class T> inline auto get_pointer ( optional<T> & opt ) -> see below; R - template<class U> optional& operator = ( optional<U>&& rhs ) ; R +template<class T> inline void swap( optional<T>& x, optional<T>& y ) ; R - template<class... Args> void emplace ( Args...&& args ) ; R - - template<class InPlaceFactory> optional& operator = ( InPlaceFactory const& f ) ; R - - template<class TypedInPlaceFactory> optional& operator = ( TypedInPlaceFactory const& f ) ; R - - T const& get() const ; R - T& get() ; R - - T const* operator ->() const ; R - T* operator ->() ; R - - T const& operator *() const& ; R - T& operator *() & ; R - T&& operator *() && ; R - - T const& value() const& ; R - T& value() & ; R - T&& value() && ; R - - template<class U> T value_or( U && v ) const& ; R - template<class U> T value_or( U && v ) && ; R - - template<class F> T value_or_eval( F f ) const& ; R - template<class F> T value_or_eval( F f ) && ; R - - T const* get_ptr() const ; R - T* get_ptr() ; R - - explicit operator bool() const noexcept ; R - - bool operator!() const noexcept ; R - - // deprecated methods - - // (deprecated) - void reset() noexcept ; R - - // (deprecated) - void reset ( T const& ) ; R - - // (deprecated) - bool is_initialized() const ; R - - // (deprecated) - T const& get_value_or( T const& default ) const ; R -}; - -template<class T> inline bool operator == ( optional<T> const& x, optional<T> const& y ) ; R - -template<class T> inline bool operator != ( optional<T> const& x, optional<T> const& y ) ; R - -template<class T> inline bool operator < ( optional<T> const& x, optional<T> const& y ) ; R - -template<class T> inline bool operator > ( optional<T> const& x, optional<T> const& y ) ; R - -template<class T> inline bool operator <= ( optional<T> const& x, optional<T> const& y ) ; R - -template<class T> inline bool operator >= ( optional<T> const& x, optional<T> const& y ) ; R - -template<class T> inline bool operator == ( optional<T> const& x, none_t ) noexcept ; R - -template<class T> inline bool operator != ( optional<T> const& x, none_t ) noexcept ; R - -template<class T> inline optional<T> make_optional ( T const& v ) ; R - -template<class T> inline optional<T> make_optional ( bool condition, T const& v ) ; R - -template<class T> inline T const& get_optional_value_or ( optional<T> const& opt, T const& default ) ; R - -template<class T> inline T const& get ( optional<T> const& opt ) ; R - -template<class T> inline T& get ( optional<T> & opt ) ; R - -template<class T> inline T const* get ( optional<T> const* opt ) ; R - -template<class T> inline T* get ( optional<T>* opt ) ; R - -template<class T> inline T const* get_pointer ( optional<T> const& opt ) ; R - -template<class T> inline T* get_pointer ( optional<T> & opt ) ; R - -template<class T> inline void swap( optional<T>& x, optional<T>& y ) ; R +template<class T> inline void swap( optional<T&>& x, optional<T&>& y ) ; R } // namespace boost @@ -171,7 +87,7 @@

-
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

@@ -179,7 +95,7 @@
-PrevUpHomeNext +PrevUpHomeNext
diff --git a/doc/html/optional/tutorial.html b/doc/html/optional/tutorial.html index 537a8b0..556944d 100644 --- a/doc/html/optional/tutorial.html +++ b/doc/html/optional/tutorial.html @@ -36,8 +36,6 @@
IO operators
Optional references
-
Rebinding - semantics for assignment of optional references
In-Place Factories
A @@ -142,7 +140,7 @@
-
Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014, 2015 Andrzej Krzemieński

+

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2016 Andrzej Krzemieński

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)

diff --git a/include/boost/none.hpp b/include/boost/none.hpp index db744e5..a37c45c 100644 --- a/include/boost/none.hpp +++ b/include/boost/none.hpp @@ -1,5 +1,5 @@ // Copyright (C) 2003, Fernando Luis Cacciola Carballal. -// Copyright (C) 2014 Andrzej Krzemienski. +// Copyright (C) 2014, 2015 Andrzej Krzemienski. // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at diff --git a/include/boost/none_t.hpp b/include/boost/none_t.hpp index 608cb0c..008f369 100644 --- a/include/boost/none_t.hpp +++ b/include/boost/none_t.hpp @@ -1,5 +1,5 @@ // Copyright (C) 2003, 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 @@ -29,7 +29,7 @@ class none_t {}; struct none_t { struct init_tag{}; - explicit none_t(init_tag){} // to prevent default constructor + explicit none_t(init_tag){} // to disable default constructor }; #endif // old implementation workarounds @@ -37,4 +37,3 @@ struct none_t } // namespace boost #endif // header guard - diff --git a/include/boost/optional/detail/old_optional_implementation.hpp b/include/boost/optional/detail/old_optional_implementation.hpp new file mode 100644 index 0000000..f2e6718 --- /dev/null +++ b/include/boost/optional/detail/old_optional_implementation.hpp @@ -0,0 +1,1059 @@ +// Copyright (C) 2003, 2008 Fernando Luis Cacciola Carballal. +// Copyright (C) 2014-2016 Andrzej Krzemienski. +// +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/optional for documentation. +// +// You are welcome to contact the maintainer at: +// akrzemi1@gmail.com + +#ifndef BOOST_OPTIONAL_DETAIL_OLD_OPTIONAL_IMPLEMENTATION_AJK_28JAN2015_HPP +#define BOOST_OPTIONAL_DETAIL_OLD_OPTIONAL_IMPLEMENTATION_AJK_28JAN2015_HPP + +#include +#include +#include +#include +#include + +namespace boost { + +namespace optional_detail { + + +template +struct types_when_isnt_ref +{ + typedef T const& reference_const_type ; + typedef T & reference_type ; +#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 + // GCC 4.4 has support for an early draft of rvalue references. The conforming version below + // causes warnings about returning references to a temporary. + static T&& move(T&& r) { return r; } +#else + static rval_reference_type move(reference_type r) { return boost::move(r); } +#endif +#endif + typedef T const* pointer_const_type ; + typedef T * pointer_type ; + typedef T const& argument_type ; +} ; + +template +struct types_when_is_ref +{ + typedef BOOST_DEDUCED_TYPENAME remove_reference::type raw_type ; + + typedef raw_type& reference_const_type ; + typedef raw_type& reference_type ; +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + typedef BOOST_DEDUCED_TYPENAME remove_const::type&& rval_reference_type ; + typedef raw_type& reference_type_of_temporary_wrapper; + static reference_type move(reference_type r) { return r; } +#endif + typedef raw_type* pointer_const_type ; + typedef raw_type* pointer_type ; + typedef raw_type& argument_type ; +} ; + +template +void prevent_binding_rvalue_ref_to_optional_lvalue_ref() +{ +#ifndef BOOST_OPTIONAL_CONFIG_ALLOW_BINDING_TO_RVALUES + BOOST_STATIC_ASSERT_MSG( + !boost::is_lvalue_reference::value || !boost::is_rvalue_reference::value, + "binding rvalue references to optional lvalue references is disallowed"); +#endif +} + +struct optional_tag {} ; + +template +class optional_base : public optional_tag +{ + private : + + typedef +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + BOOST_DEDUCED_TYPENAME +#endif + ::boost::detail::make_reference_content::type internal_type ; + + typedef aligned_storage storage_type ; + + typedef types_when_isnt_ref types_when_not_ref ; + typedef types_when_is_ref types_when_ref ; + + typedef optional_base this_type ; + + protected : + + typedef T value_type ; + + typedef mpl::true_ is_reference_tag ; + typedef mpl::false_ is_not_reference_tag ; + + typedef BOOST_DEDUCED_TYPENAME is_reference::type is_reference_predicate ; + + public: + typedef BOOST_DEDUCED_TYPENAME mpl::if_::type types ; + + protected: + typedef BOOST_DEDUCED_TYPENAME types::reference_type reference_type ; + typedef BOOST_DEDUCED_TYPENAME types::reference_const_type reference_const_type ; +#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 + typedef BOOST_DEDUCED_TYPENAME types::pointer_type pointer_type ; + typedef BOOST_DEDUCED_TYPENAME types::pointer_const_type pointer_const_type ; + typedef BOOST_DEDUCED_TYPENAME types::argument_type argument_type ; + + // Creates an optional uninitialized. + // No-throw + optional_base() + : + m_initialized(false) {} + + // Creates an optional uninitialized. + // No-throw + optional_base ( none_t ) + : + m_initialized(false) {} + + // Creates an optional initialized with 'val'. + // Can throw if T::T(T const&) does + optional_base ( argument_type val ) + : + m_initialized(false) + { + construct(val); + } + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // move-construct an optional initialized from an rvalue-ref to 'val'. + // Can throw if T::T(T&&) does + optional_base ( rval_reference_type val ) + : + m_initialized(false) + { + construct( boost::move(val) ); + } +#endif + + // Creates an optional initialized with 'val' IFF cond is true, otherwise creates an uninitialzed optional. + // Can throw if T::T(T const&) does + optional_base ( bool cond, argument_type val ) + : + m_initialized(false) + { + if ( cond ) + construct(val); + } + + // Creates a deep copy of another optional + // Can throw if T::T(T const&) does + optional_base ( optional_base const& rhs ) + : + m_initialized(false) + { + if ( rhs.is_initialized() ) + construct(rhs.get_impl()); + } + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Creates a deep move of another optional + // Can throw if T::T(T&&) does + optional_base ( optional_base&& rhs ) + : + m_initialized(false) + { + if ( rhs.is_initialized() ) + construct( boost::move(rhs.get_impl()) ); + } +#endif + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + + template + explicit optional_base ( Expr&& expr, PtrExpr const* tag ) + : + m_initialized(false) + { + construct(boost::forward(expr),tag); + } + +#else + // This is used for both converting and in-place constructions. + // Derived classes use the 'tag' to select the appropriate + // implementation (the correct 'construct()' overload) + template + explicit optional_base ( Expr const& expr, Expr const* tag ) + : + m_initialized(false) + { + construct(expr,tag); + } + +#endif + + + // No-throw (assuming T::~T() doesn't) + ~optional_base() { destroy() ; } + + // Assigns from another optional (deep-copies the rhs value) + void assign ( optional_base const& rhs ) + { + if (is_initialized()) + { + if ( rhs.is_initialized() ) + assign_value(rhs.get_impl(), is_reference_predicate() ); + else destroy(); + } + else + { + if ( rhs.is_initialized() ) + construct(rhs.get_impl()); + } + } + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Assigns from another optional (deep-moves the rhs value) + void assign ( optional_base&& rhs ) + { + if (is_initialized()) + { + if ( rhs.is_initialized() ) + assign_value(boost::move(rhs.get_impl()), is_reference_predicate() ); + else destroy(); + } + else + { + if ( rhs.is_initialized() ) + construct(boost::move(rhs.get_impl())); + } + } +#endif + + // Assigns from another _convertible_ optional (deep-copies the rhs value) + template + void assign ( optional const& rhs ) + { + if (is_initialized()) + { + if ( rhs.is_initialized() ) +#ifndef BOOST_OPTIONAL_CONFIG_RESTORE_ASSIGNMENT_OF_NONCONVERTIBLE_TYPES + assign_value(rhs.get(), is_reference_predicate() ); +#else + assign_value(static_cast(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(rhs.get())); +#endif + } + } + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // move-assigns from another _convertible_ optional (deep-moves from the rhs value) + template + void assign ( optional&& rhs ) + { + typedef BOOST_DEDUCED_TYPENAME optional::rval_reference_type ref_type; + if (is_initialized()) + { + if ( rhs.is_initialized() ) + assign_value(static_cast(rhs.get()), is_reference_predicate() ); + else destroy(); + } + else + { + if ( rhs.is_initialized() ) + construct(static_cast(rhs.get())); + } + } +#endif + + // Assigns from a T (deep-copies the rhs value) + void assign ( argument_type val ) + { + if (is_initialized()) + assign_value(val, is_reference_predicate() ); + else construct(val); + } + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Assigns from a T (deep-moves the rhs value) + void assign ( rval_reference_type val ) + { + if (is_initialized()) + assign_value( boost::move(val), is_reference_predicate() ); + else construct( boost::move(val) ); + } +#endif + + // Assigns from "none", destroying the current value, if any, leaving this UNINITIALIZED + // No-throw (assuming T::~T() doesn't) + void assign ( none_t ) BOOST_NOEXCEPT { destroy(); } + +#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + template + void assign_expr ( Expr&& expr, ExprPtr const* tag ) + { + if (is_initialized()) + assign_expr_to_initialized(boost::forward(expr),tag); + else construct(boost::forward(expr),tag); + } +#else + template + void assign_expr ( Expr const& expr, Expr const* tag ) + { + if (is_initialized()) + assign_expr_to_initialized(expr,tag); + else construct(expr,tag); + } +#endif + +#endif + + public : + + // **DEPPRECATED** Destroys the current value, if any, leaving this UNINITIALIZED + // No-throw (assuming T::~T() doesn't) + void reset() BOOST_NOEXCEPT { destroy(); } + + // **DEPPRECATED** Replaces the current value -if any- with 'val' + void reset ( argument_type val ) { assign(val); } + + // Returns a pointer to the value if this is initialized, otherwise, + // returns NULL. + // No-throw + pointer_const_type get_ptr() const { return m_initialized ? get_ptr_impl() : 0 ; } + pointer_type get_ptr() { return m_initialized ? get_ptr_impl() : 0 ; } + + bool is_initialized() const { return m_initialized ; } + + protected : + + void construct ( argument_type val ) + { + ::new (m_storage.address()) internal_type(val) ; + m_initialized = true ; + } + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + void construct ( rval_reference_type val ) + { + ::new (m_storage.address()) internal_type( types::move(val) ) ; + m_initialized = true ; + } +#endif + + +#if (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) && (!defined BOOST_NO_CXX11_VARIADIC_TEMPLATES) + // Constructs in-place + // upon exception *this is always uninitialized + template + void emplace_assign ( Args&&... args ) + { + destroy(); + ::new (m_storage.address()) internal_type( boost::forward(args)... ); + m_initialized = true ; + } +#elif (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) + template + void emplace_assign ( Arg&& arg ) + { + destroy(); + ::new (m_storage.address()) internal_type( boost::forward(arg) ); + m_initialized = true ; + } + + void emplace_assign () + { + destroy(); + ::new (m_storage.address()) internal_type(); + m_initialized = true ; + } +#else + template + void emplace_assign ( const Arg& arg ) + { + destroy(); + ::new (m_storage.address()) internal_type( arg ); + m_initialized = true ; + } + + template + 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_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Constructs in-place using the given factory + template + void construct ( Expr&& factory, in_place_factory_base const* ) + { + BOOST_STATIC_ASSERT ( ::boost::mpl::not_::value ) ; + boost_optional_detail::construct(factory, m_storage.address()); + m_initialized = true ; + } + + // Constructs in-place using the given typed factory + template + void construct ( Expr&& factory, typed_in_place_factory_base const* ) + { + BOOST_STATIC_ASSERT ( ::boost::mpl::not_::value ) ; + factory.apply(m_storage.address()) ; + m_initialized = true ; + } + + template + void assign_expr_to_initialized ( Expr&& factory, in_place_factory_base const* tag ) + { + destroy(); + construct(factory,tag); + } + + // Constructs in-place using the given typed factory + template + void assign_expr_to_initialized ( Expr&& factory, typed_in_place_factory_base const* tag ) + { + destroy(); + construct(factory,tag); + } + +#else + // Constructs in-place using the given factory + template + void construct ( Expr const& factory, in_place_factory_base const* ) + { + BOOST_STATIC_ASSERT ( ::boost::mpl::not_::value ) ; + boost_optional_detail::construct(factory, m_storage.address()); + m_initialized = true ; + } + + // Constructs in-place using the given typed factory + template + void construct ( Expr const& factory, typed_in_place_factory_base const* ) + { + BOOST_STATIC_ASSERT ( ::boost::mpl::not_::value ) ; + factory.apply(m_storage.address()) ; + m_initialized = true ; + } + + template + void assign_expr_to_initialized ( Expr const& factory, in_place_factory_base const* tag ) + { + destroy(); + construct(factory,tag); + } + + // Constructs in-place using the given typed factory + template + void assign_expr_to_initialized ( Expr const& factory, typed_in_place_factory_base const* tag ) + { + destroy(); + construct(factory,tag); + } +#endif + +#endif + +#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 from optional uses this function with + // 'Expr' being of type 'U' and relying on a converting constructor of T from U. + template + void construct ( Expr&& expr, void const* ) + { + new (m_storage.address()) internal_type(boost::forward(expr)) ; + m_initialized = true ; + } + + // Assigns using a form any expression implicitly convertible to the single argument + // of a T's assignment operator. + // Converting assignments of optional from optional uses this function with + // 'Expr' being of type 'U' and relying on a converting assignment of T from U. + template + void assign_expr_to_initialized ( Expr&& expr, void const* ) + { + assign_value(boost::forward(expr), is_reference_predicate()); + } +#else + // Constructs using any expression implicitly convertible to the single argument + // of a one-argument T constructor. + // Converting constructions of optional from optional uses this function with + // 'Expr' being of type 'U' and relying on a converting constructor of T from U. + template + void construct ( Expr const& expr, void const* ) + { + new (m_storage.address()) internal_type(expr) ; + m_initialized = true ; + } + + // Assigns using a form any expression implicitly convertible to the single argument + // of a T's assignment operator. + // Converting assignments of optional from optional uses this function with + // 'Expr' being of type 'U' and relying on a converting assignment of T from U. + template + void assign_expr_to_initialized ( Expr const& expr, void const* ) + { + assign_value(expr, is_reference_predicate()); + } + +#endif + +#ifdef BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION + // BCB5.64 (and probably lower versions) workaround. + // The in-place factories are supported by means of catch-all constructors + // and assignment operators (the functions are parameterized in terms of + // an arbitrary 'Expr' type) + // This compiler incorrectly resolves the overload set and sinks optional and optional + // to the 'Expr'-taking functions even though explicit overloads are present for them. + // Thus, the following overload is needed to properly handle the case when the 'lhs' + // is another optional. + // + // For VC<=70 compilers this workaround dosen't work becasue the comnpiler issues and error + // instead of choosing the wrong overload + // +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Notice that 'Expr' will be optional or optional (but not optional_base<..>) + template + void construct ( Expr&& expr, optional_tag const* ) + { + if ( expr.is_initialized() ) + { + // An exception can be thrown here. + // It it happens, THIS will be left uninitialized. + new (m_storage.address()) internal_type(types::move(expr.get())) ; + m_initialized = true ; + } + } +#else + // Notice that 'Expr' will be optional or optional (but not optional_base<..>) + template + void construct ( Expr const& expr, optional_tag const* ) + { + if ( expr.is_initialized() ) + { + // An exception can be thrown here. + // It it happens, THIS will be left uninitialized. + new (m_storage.address()) internal_type(expr.get()) ; + m_initialized = true ; + } + } +#endif +#endif // defined BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION + + 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_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + void assign_value ( rval_reference_type val, is_not_reference_tag ) { get_impl() = static_cast(val); } + void assign_value ( rval_reference_type val, is_reference_tag ) { construct( static_cast(val) ); } +#endif + + void destroy() + { + if ( m_initialized ) + destroy_impl(is_reference_predicate()) ; + } + + reference_const_type get_impl() const { return dereference(get_object(), is_reference_predicate() ) ; } + reference_type get_impl() { return dereference(get_object(), is_reference_predicate() ) ; } + + pointer_const_type get_ptr_impl() const { return cast_ptr(get_object(), is_reference_predicate() ) ; } + pointer_type get_ptr_impl() { return cast_ptr(get_object(), is_reference_predicate() ) ; } + + private : + + // internal_type can be either T or reference_content +#if defined(BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS) + // This workaround is supposed to silence GCC warnings about broken strict aliasing rules + internal_type const* get_object() const + { + union { void const* ap_pvoid; internal_type const* as_ptype; } caster = { m_storage.address() }; + return caster.as_ptype; + } + internal_type * get_object() + { + union { void* ap_pvoid; internal_type* as_ptype; } caster = { m_storage.address() }; + return caster.as_ptype; + } +#else + internal_type const* get_object() const { return static_cast(m_storage.address()); } + internal_type * get_object() { return static_cast (m_storage.address()); } +#endif + + // reference_content lacks an implicit conversion to T&, so the following is needed to obtain a proper reference. + reference_const_type dereference( internal_type const* p, is_not_reference_tag ) const { return *p ; } + reference_type dereference( internal_type* p, is_not_reference_tag ) { return *p ; } + reference_const_type dereference( internal_type const* p, is_reference_tag ) const { return p->get() ; } + reference_type dereference( internal_type* p, is_reference_tag ) { return p->get() ; } + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581)) + void destroy_impl ( is_not_reference_tag ) { get_ptr_impl()->internal_type::~internal_type() ; m_initialized = false ; } +#else + void destroy_impl ( is_not_reference_tag ) { get_ptr_impl()->~T() ; m_initialized = false ; } +#endif + + void destroy_impl ( is_reference_tag ) { m_initialized = false ; } + + // If T is of reference type, trying to get a pointer to the held value must result in a compile-time error. + // Decent compilers should disallow conversions from reference_content* to T*, but just in case, + // the following olverloads are used to filter out the case and guarantee an error in case of T being a reference. + pointer_const_type cast_ptr( internal_type const* p, is_not_reference_tag ) const { return p ; } + pointer_type cast_ptr( internal_type * p, is_not_reference_tag ) { return p ; } + pointer_const_type cast_ptr( internal_type const* p, is_reference_tag ) const { return &p->get() ; } + pointer_type cast_ptr( internal_type * p, is_reference_tag ) { return &p->get() ; } + + bool m_initialized ; + storage_type m_storage ; +} ; + +} // namespace optional_detail + +template +class optional : public optional_detail::optional_base +{ + typedef optional_detail::optional_base base ; + + public : + + typedef optional this_type ; + + 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_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 + typedef BOOST_DEDUCED_TYPENAME base::pointer_type pointer_type ; + typedef BOOST_DEDUCED_TYPENAME base::pointer_const_type pointer_const_type ; + typedef BOOST_DEDUCED_TYPENAME base::argument_type argument_type ; + + // Creates an optional uninitialized. + // No-throw + optional() BOOST_NOEXCEPT : base() {} + + // Creates an optional uninitialized. + // No-throw + optional( none_t none_ ) BOOST_NOEXCEPT : base(none_) {} + + // Creates an optional initialized with 'val'. + // Can throw if T::T(T const&) does + optional ( argument_type val ) : base(val) {} + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Creates an optional initialized with 'move(val)'. + // Can throw if T::T(T &&) does + optional ( rval_reference_type val ) : base( boost::forward(val) ) + {optional_detail::prevent_binding_rvalue_ref_to_optional_lvalue_ref();} +#endif + + // Creates an optional initialized with 'val' IFF cond is true, otherwise creates an uninitialized optional. + // Can throw if T::T(T const&) does + optional ( bool cond, argument_type val ) : base(cond,val) {} + + // NOTE: MSVC needs templated versions first + + // Creates a deep copy of another convertible optional + // Requires a valid conversion from U to T. + // Can throw if T::T(U const&) does + template + explicit optional ( optional const& rhs ) + : + base() + { + if ( rhs.is_initialized() ) + this->construct(rhs.get()); + } + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Creates a deep move of another convertible optional + // Requires a valid conversion from U to T. + // Can throw if T::T(U&&) does + template + explicit optional ( optional && rhs ) + : + base() + { + if ( rhs.is_initialized() ) + this->construct( boost::move(rhs.get()) ); + } +#endif + +#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT + // Creates an optional with an expression which can be either + // (a) An instance of InPlaceFactory (i.e. in_place(a,b,...,n); + // (b) An instance of TypedInPlaceFactory ( i.e. in_place(a,b,...,n); + // (c) Any expression implicitly convertible to the single type + // of a one-argument T's constructor. + // (d*) Weak compilers (BCB) might also resolved Expr as optional and optional + // 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_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + + + template + explicit optional ( Expr&& expr, + BOOST_DEDUCED_TYPENAME boost::disable_if_c< + (boost::is_base_of::type>::value) || + boost::is_same::type, none_t>::value >::type* = 0 + ) + : base(boost::forward(expr),boost::addressof(expr)) + {optional_detail::prevent_binding_rvalue_ref_to_optional_lvalue_ref();} + +#else + template + explicit optional ( Expr const& expr ) : base(expr,boost::addressof(expr)) {} +#endif // !defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES +#endif // !defined BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT + + // Creates a deep copy of another optional + // Can throw if T::T(T const&) does + optional ( optional const& rhs ) : base( static_cast(rhs) ) {} + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Creates a deep move of another optional + // Can throw if T::T(T&&) does + optional ( optional && rhs ) + BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible::value) + : base( boost::move(rhs) ) + {} + +#endif + // No-throw (assuming T::~T() doesn't) + ~optional() {} + +#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_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + + template + BOOST_DEDUCED_TYPENAME boost::disable_if_c< + boost::is_base_of::type>::value || + boost::is_same::type, none_t>::value, + optional& + >::type + operator= ( Expr&& expr ) + { + optional_detail::prevent_binding_rvalue_ref_to_optional_lvalue_ref(); + this->assign_expr(boost::forward(expr),boost::addressof(expr)); + return *this ; + } + +#else + template + optional& operator= ( Expr const& expr ) + { + this->assign_expr(expr,boost::addressof(expr)); + return *this ; + } +#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 (converts && deep-copies the rhs value) + // Requires a valid conversion from U to T. + // Basic Guarantee: If T::T( U const& ) throws, this is left UNINITIALIZED + template + optional& operator= ( optional const& rhs ) + { + this->assign(rhs); + return *this ; + } + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Move-assigns from another convertible optional (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 + template + optional& operator= ( optional && rhs ) + { + this->assign(boost::move(rhs)); + return *this ; + } +#endif + + // Assigns from another optional (deep-copies the rhs value) + // Basic Guarantee: If T::T( T const& ) throws, this is left UNINITIALIZED + // (NOTE: On BCB, this operator is not actually called and left is left UNMODIFIED in case of a throw) + optional& operator= ( optional const& rhs ) + { + this->assign( static_cast(rhs) ) ; + return *this ; + } + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Assigns from another optional (deep-moves the rhs value) + optional& operator= ( optional && rhs ) + BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible::value && ::boost::is_nothrow_move_assignable::value) + { + this->assign( static_cast(rhs) ) ; + return *this ; + } +#endif + + // Assigns from a T (deep-copies the rhs value) + // Basic Guarantee: If T::( T const& ) throws, this is left UNINITIALIZED + optional& operator= ( argument_type val ) + { + this->assign( val ) ; + return *this ; + } + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Assigns from a T (deep-moves the rhs value) + optional& operator= ( rval_reference_type val ) + { + optional_detail::prevent_binding_rvalue_ref_to_optional_lvalue_ref(); + this->assign( boost::move(val) ) ; + return *this ; + } +#endif + + // Assigns from a "none" + // Which destroys the current value, if any, leaving this UNINITIALIZED + // No-throw (assuming T::~T() doesn't) + optional& operator= ( none_t none_ ) BOOST_NOEXCEPT + { + this->assign( none_ ) ; + return *this ; + } + +#if (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) && (!defined BOOST_NO_CXX11_VARIADIC_TEMPLATES) + // Constructs in-place + // upon exception *this is always uninitialized + template + void emplace ( Args&&... args ) + { + this->emplace_assign( boost::forward(args)... ); + } +#elif (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) + template + void emplace ( Arg&& arg ) + { + this->emplace_assign( boost::forward(arg) ); + } + + void emplace () + { + this->emplace_assign(); + } +#else + template + void emplace ( const Arg& arg ) + { + this->emplace_assign( arg ); + } + + template + void emplace ( Arg& arg ) + { + this->emplace_assign( arg ); + } + + void emplace () + { + this->emplace_assign(); + } +#endif + + void swap( optional & arg ) + BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible::value && ::boost::is_nothrow_move_assignable::value) + { + // allow for Koenig lookup + boost::swap(*this, arg); + } + + + // Returns a reference to the value if this is initialized, otherwise, + // the behaviour is UNDEFINED + // No-throw + reference_const_type get() const { BOOST_ASSERT(this->is_initialized()) ; return this->get_impl(); } + reference_type get() { BOOST_ASSERT(this->is_initialized()) ; return this->get_impl(); } + + // Returns a copy of the value if this is initialized, 'v' otherwise + reference_const_type get_value_or ( reference_const_type v ) const { return this->is_initialized() ? get() : v ; } + reference_type get_value_or ( reference_type v ) { return this->is_initialized() ? get() : v ; } + + // Returns a pointer to the value if this is initialized, otherwise, + // the behaviour is UNDEFINED + // No-throw + pointer_const_type operator->() const { BOOST_ASSERT(this->is_initialized()) ; return this->get_ptr_impl() ; } + pointer_type operator->() { BOOST_ASSERT(this->is_initialized()) ; return this->get_ptr_impl() ; } + + // Returns a reference to the value if this is initialized, otherwise, + // the behaviour is UNDEFINED + // No-throw +#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 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 + +#if (!defined BOOST_NO_CXX11_REF_QUALIFIERS) && (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) + reference_const_type value() const& + { + if (this->is_initialized()) + return this->get() ; + else + throw_exception(bad_optional_access()); + } + + reference_type value() & + { + if (this->is_initialized()) + return this->get() ; + else + throw_exception(bad_optional_access()); + } + + reference_type_of_temporary_wrapper value() && + { + if (this->is_initialized()) + return base::types::move(this->get()) ; + else + throw_exception(bad_optional_access()); + } + +#else + reference_const_type value() const + { + if (this->is_initialized()) + return this->get() ; + else + throw_exception(bad_optional_access()); + } + + reference_type value() + { + if (this->is_initialized()) + return this->get() ; + else + throw_exception(bad_optional_access()); + } +#endif + + +#ifndef BOOST_NO_CXX11_REF_QUALIFIERS + template + value_type value_or ( U&& v ) const& + { + if (this->is_initialized()) + return get(); + else + return boost::forward(v); + } + + template + value_type value_or ( U&& v ) && + { + if (this->is_initialized()) + return base::types::move(get()); + else + return boost::forward(v); + } +#elif !defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + template + value_type value_or ( U&& v ) const + { + if (this->is_initialized()) + return get(); + else + return boost::forward(v); + } +#else + template + value_type value_or ( U const& v ) const + { + if (this->is_initialized()) + return get(); + else + return v; + } + + template + value_type value_or ( U& v ) const + { + if (this->is_initialized()) + return get(); + else + return v; + } +#endif + + +#ifndef BOOST_NO_CXX11_REF_QUALIFIERS + template + value_type value_or_eval ( F f ) const& + { + if (this->is_initialized()) + return get(); + else + return f(); + } + + template + value_type value_or_eval ( F f ) && + { + if (this->is_initialized()) + return base::types::move(get()); + else + return f(); + } +#else + template + value_type value_or_eval ( F f ) const + { + if (this->is_initialized()) + return get(); + else + return f(); + } +#endif + + bool operator!() const BOOST_NOEXCEPT { return !this->is_initialized() ; } + + BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT() +} ; + +} // namespace boost + + +#endif // header guard diff --git a/include/boost/optional/detail/optional_aligned_storage.hpp b/include/boost/optional/detail/optional_aligned_storage.hpp new file mode 100644 index 0000000..6c7d581 --- /dev/null +++ b/include/boost/optional/detail/optional_aligned_storage.hpp @@ -0,0 +1,75 @@ +// Copyright (C) 2003, 2008 Fernando Luis Cacciola Carballal. +// Copyright (C) 2016 Andrzej Krzemienski. +// +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/optional for documentation. +// +// You are welcome to contact the author at: +// fernando_cacciola@hotmail.com +// akrzemi1@gmail.com + +#ifndef BOOST_OPTIONAL_OPTIONAL_DETAIL_OPTIONAL_ALIGNED_STORAGE_AJK_12FEB2016_HPP +#define BOOST_OPTIONAL_OPTIONAL_DETAIL_OPTIONAL_ALIGNED_STORAGE_AJK_12FEB2016_HPP + +namespace boost { + +namespace optional_detail { +// This local class is used instead of that in "aligned_storage.hpp" +// because I've found the 'official' class to ICE BCB5.5 +// when some types are used with optional<> +// (due to sizeof() passed down as a non-type template parameter) +template +class aligned_storage +{ + // Borland ICEs if unnamed unions are used for this! + union + // This works around GCC warnings about breaking strict aliasing rules when casting storage address to T* +#if defined(BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS) + __attribute__((__may_alias__)) +#endif + dummy_u + { + char data[ sizeof(T) ]; + BOOST_DEDUCED_TYPENAME type_with_alignment< + ::boost::alignment_of::value >::type aligner_; + } dummy_ ; + + public: + +#if defined(BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS) + void const* address() const { return &dummy_; } + void * address() { return &dummy_; } +#else + void const* address() const { return dummy_.data; } + void * address() { return dummy_.data; } +#endif + +#if defined(BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS) + // This workaround is supposed to silence GCC warnings about broken strict aliasing rules + T const* ptr_ref() const + { + union { void const* ap_pvoid; T const* as_ptype; } caster = { address() }; + return caster.as_ptype; + } + T * ptr_ref() + { + union { void* ap_pvoid; T* as_ptype; } caster = { address() }; + return caster.as_ptype; + } +#else + T const* ptr_ref() const { return static_cast(address()); } + T * ptr_ref() { return static_cast (address()); } +#endif + + T const& ref() const { return *ptr_ref(); } + T & ref() { return *ptr_ref(); } + +} ; + +} // namespace optional_detail +} // namespace boost + +#endif // header guard diff --git a/include/boost/optional/detail/optional_config.hpp b/include/boost/optional/detail/optional_config.hpp new file mode 100644 index 0000000..648744e --- /dev/null +++ b/include/boost/optional/detail/optional_config.hpp @@ -0,0 +1,99 @@ +// 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/libs/optional for documentation. +// +// You are welcome to contact the author at: +// akrzemi1@gmail.com + +#ifndef BOOST_OPTIONAL_DETAIL_OPTIONAL_CONFIG_AJK_28JAN2015_HPP +#define BOOST_OPTIONAL_DETAIL_OPTIONAL_CONFIG_AJK_28JAN2015_HPP + +#include +#include + +#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, +// so for the other icc versions, in-place factory support +// is disabled +# define BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT +#endif + +#if BOOST_WORKAROUND(__BORLANDC__, <= 0x551) +// BCB (5.5.1) cannot parse the nested template struct in an inplace factory. +# define BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT +#endif + +#if !defined(BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT) \ + && defined BOOST_BCB_PARTIAL_SPECIALIZATION_BUG +// BCB (up to 5.64) has the following bug: +// If there is a member function/operator template of the form +// template mfunc( Expr expr ) ; +// some calls are resolved to this even if there are other better matches. +// The effect of this bug is that calls to converting ctors and assignments +// are incorrectly sink to this general catch-all member function template as shown above. +# define BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION +#endif + +#if defined(__GNUC__) && !defined(__INTEL_COMPILER) +// GCC since 3.3 has may_alias attribute that helps to alleviate optimizer issues with +// regard to violation of the strict aliasing rules. The optional< T > storage type is marked +// with this attribute in order to let the compiler know that it will alias objects of type T +// and silence compilation warnings. +# define BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS +#endif + +#if (defined(_MSC_VER) && _MSC_VER <= 1800) +// on MSCV 2013 and earlier an unwanted temporary is created when you assign from +// a const lvalue of integral type. Thus we bind not to the original address but +// to a temporary. +# define BOOST_OPTIONAL_CONFIG_NO_PROPER_ASSIGN_FROM_CONST_INT +#endif + +#if (defined __GNUC__) && (!defined BOOST_INTEL_CXX_VERSION) && (!defined __clang__) +// On some GCC versions an unwanted temporary is created when you copy-initialize +// from a const lvalue of integral type. Thus we bind not to the original address but +// to a temporary. + +# if (__GNUC__ < 4) +# define BOOST_OPTIONAL_CONFIG_NO_PROPER_CONVERT_FROM_CONST_INT +# endif + +# if (__GNUC__ == 4 && __GNUC_MINOR__ <= 5) +# define BOOST_OPTIONAL_CONFIG_NO_PROPER_CONVERT_FROM_CONST_INT +# endif + +# if (__GNUC__ == 5 && __GNUC_MINOR__ < 2) +# define BOOST_OPTIONAL_CONFIG_NO_PROPER_CONVERT_FROM_CONST_INT +# endif + +# if (__GNUC__ == 5 && __GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ == 0) +# define BOOST_OPTIONAL_CONFIG_NO_PROPER_CONVERT_FROM_CONST_INT +# endif + +#endif // defined(__GNUC__) + +#if (defined __GNUC__) && (!defined BOOST_NO_CXX11_RVALUE_REFERENCES) +// On some initial rvalue reference implementations GCC does it in a strange way, +// preferring perfect-forwarding constructor to implicit copy constructor. + +# if (__GNUC__ == 4 && __GNUC_MINOR__ == 4) +# define BOOST_OPTIONAL_CONFIG_NO_LEGAL_CONVERT_FROM_REF +# endif + +# if (__GNUC__ == 4 && __GNUC_MINOR__ == 5) +# define BOOST_OPTIONAL_CONFIG_NO_LEGAL_CONVERT_FROM_REF +# endif + +#endif // defined(__GNUC__) + +#endif // header guard diff --git a/include/boost/optional/detail/optional_factory_support.hpp b/include/boost/optional/detail/optional_factory_support.hpp new file mode 100644 index 0000000..efff92a --- /dev/null +++ b/include/boost/optional/detail/optional_factory_support.hpp @@ -0,0 +1,36 @@ +// Copyright (C) 2003, 2008 Fernando Luis Cacciola Carballal. +// Copyright (C) 2016 Andrzej Krzemienski. +// +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/optional for documentation. +// +// You are welcome to contact the author at: +// fernando_cacciola@hotmail.com +// akrzemi1@gmail.com + +#ifndef BOOST_OPTIONAL_OPTIONAL_DETAIL_OPTIONAL_FACTORY_SUPPORT_AJK_12FEB2016_HPP +#define BOOST_OPTIONAL_OPTIONAL_DETAIL_OPTIONAL_FACTORY_SUPPORT_AJK_12FEB2016_HPP + +// Daniel Wallin discovered that bind/apply.hpp badly interacts with the apply<> +// member template of a factory as used in the optional<> implementation. +// He proposed this simple fix which is to move the call to apply<> outside +// namespace boost. +namespace boost_optional_detail +{ + template + inline void construct(Factory const& factory, void* address) + { + factory.BOOST_NESTED_TEMPLATE apply(address); + } +} + +namespace boost +{ + class in_place_factory_base ; + class typed_in_place_factory_base ; +} + +#endif // header guard diff --git a/include/boost/optional/detail/optional_reference_spec.hpp b/include/boost/optional/detail/optional_reference_spec.hpp new file mode 100644 index 0000000..eeabade --- /dev/null +++ b/include/boost/optional/detail/optional_reference_spec.hpp @@ -0,0 +1,202 @@ +// Copyright (C) 2015-2016 Andrzej Krzemienski. +// +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/optional for documentation. +// +// You are welcome to contact the author at: +// akrzemi1@gmail.com + +#ifndef BOOST_OPTIONAL_DETAIL_OPTIONAL_REFERENCE_SPEC_AJK_03OCT2015_HPP +#define BOOST_OPTIONAL_DETAIL_OPTIONAL_REFERENCE_SPEC_AJK_03OCT2015_HPP + +#ifdef BOOST_OPTIONAL_CONFIG_NO_PROPER_ASSIGN_FROM_CONST_INT +#include +#include +#endif + +# if 1 + +namespace boost { + +namespace detail { + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + +template +void prevent_binding_rvalue() +{ +#ifndef BOOST_OPTIONAL_CONFIG_ALLOW_BINDING_TO_RVALUES + BOOST_STATIC_ASSERT_MSG(boost::is_lvalue_reference::value, + "binding rvalue references to optional lvalue references is disallowed"); +#endif +} + +template +BOOST_DEDUCED_TYPENAME boost::remove_reference::type& forward_reference(T&& r) +{ + BOOST_STATIC_ASSERT_MSG(boost::is_lvalue_reference::value, + "binding rvalue references to optional lvalue references is disallowed"); + return boost::forward(r); +} + +#endif // BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + +template +void prevent_assignment_from_false_const_integral() +{ +#ifndef BOOST_OPTIONAL_CONFIG_ALLOW_BINDING_TO_RVALUES +#ifdef BOOST_OPTIONAL_CONFIG_NO_PROPER_ASSIGN_FROM_CONST_INT + // MSVC compiler without rvalue refernces: we need to disable the asignment from + // const integral lvalue reference, as it may be an invalid temporary + BOOST_STATIC_ASSERT_MSG(!(boost::is_const::value && boost::is_integral::value), + "binding const lvalue references to integral types is disabled in this compiler"); +#endif +#endif +} + +template +struct is_optional_ +{ + static const bool value = false; +}; + +template +struct is_optional_< ::boost::optional > +{ + static const bool value = true; +}; + +template +struct is_no_optional +{ + static const bool value = !is_optional_::type>::value; +}; + +} // namespace detail + +template +class optional : public optional_detail::optional_tag +{ + T* ptr_; + +public: + typedef T& value_type; + typedef T& reference_type; + typedef T& reference_const_type; + typedef T* pointer_type; + typedef T* pointer_const_type; + + optional() BOOST_NOEXCEPT : ptr_() {} + optional(none_t) BOOST_NOEXCEPT : ptr_() {} + + template + explicit optional(const optional& rhs) BOOST_NOEXCEPT : ptr_(rhs.ptr_) {} + optional(const optional& rhs) BOOST_NOEXCEPT : ptr_(rhs.ptr_) {} + + + optional& operator=(const optional& rhs) BOOST_NOEXCEPT { ptr_ = rhs.ptr_; return *this; } + template + optional& operator=(const optional& rhs) BOOST_NOEXCEPT { ptr_ = rhs.ptr_; return *this; } + optional& operator=(none_t) BOOST_NOEXCEPT { ptr_ = 0; return *this; } + + + void swap(optional& rhs) BOOST_NOEXCEPT { std::swap(ptr_, rhs.ptr_); } + T& get() const { BOOST_ASSERT(ptr_); return *ptr_; } + + T* get_ptr() const BOOST_NOEXCEPT { return ptr_; } + T* operator->() const { BOOST_ASSERT(ptr_); return ptr_; } + T& operator*() const { BOOST_ASSERT(ptr_); return *ptr_; } + T& value() const { return ptr_ ? *ptr_ : (throw_exception(bad_optional_access()), *ptr_); } + + bool operator!() const BOOST_NOEXCEPT { return ptr_ == 0; } + BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT() + + void reset() BOOST_NOEXCEPT { ptr_ = 0; } + + bool is_initialized() const BOOST_NOEXCEPT { return ptr_ != 0; } + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + + template + optional(R&& r, BOOST_DEDUCED_TYPENAME boost::enable_if >::type* = 0) BOOST_NOEXCEPT + : ptr_(boost::addressof(r)) { detail::prevent_binding_rvalue(); } + + template + optional(bool cond, R&& r, BOOST_DEDUCED_TYPENAME boost::enable_if >::type* = 0) BOOST_NOEXCEPT + : ptr_(cond ? boost::addressof(r) : 0) { detail::prevent_binding_rvalue(); } + + template + BOOST_DEDUCED_TYPENAME boost::enable_if, optional&>::type + operator=(R&& r) BOOST_NOEXCEPT { detail::prevent_binding_rvalue(); ptr_ = boost::addressof(r); return *this; } + + template + void emplace(R&& r, BOOST_DEDUCED_TYPENAME boost::enable_if >::type* = 0) BOOST_NOEXCEPT + { detail::prevent_binding_rvalue(); ptr_ = boost::addressof(r); } + + template + T& get_value_or(R&& r, BOOST_DEDUCED_TYPENAME boost::enable_if >::type* = 0) const BOOST_NOEXCEPT + { detail::prevent_binding_rvalue(); return ptr_ ? *ptr_ : r; } + + template + T& value_or(R&& r, BOOST_DEDUCED_TYPENAME boost::enable_if >::type* = 0) const BOOST_NOEXCEPT + { detail::prevent_binding_rvalue(); return ptr_ ? *ptr_ : r; } + + template + void reset(R&& r, BOOST_DEDUCED_TYPENAME boost::enable_if >::type* = 0) BOOST_NOEXCEPT + { detail::prevent_binding_rvalue(); ptr_ = boost::addressof(r); } + + template + T& value_or_eval(F f) const { return ptr_ ? *ptr_ : detail::forward_reference(f()); } + +#else // BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + + template + optional(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if >::type* = 0) BOOST_NOEXCEPT : ptr_(boost::addressof(v)) { } + + template + optional(bool cond, U& v, BOOST_DEDUCED_TYPENAME boost::enable_if >::type* = 0) BOOST_NOEXCEPT : ptr_(cond ? boost::addressof(v) : 0) {} + + template + BOOST_DEDUCED_TYPENAME boost::enable_if, optional&>::type + operator=(U& v) BOOST_NOEXCEPT + { + detail::prevent_assignment_from_false_const_integral(); + ptr_ = boost::addressof(v); return *this; + } + + template + void emplace(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if >::type* = 0) BOOST_NOEXCEPT + { ptr_ = boost::addressof(v); } + + template + T& get_value_or(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if >::type* = 0) const BOOST_NOEXCEPT + { return ptr_ ? *ptr_ : v; } + + template + T& value_or(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if >::type* = 0) const BOOST_NOEXCEPT + { return ptr_ ? *ptr_ : v; } + + template + void reset(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if >::type* = 0) BOOST_NOEXCEPT + { ptr_ = boost::addressof(v); } + + template + T& value_or_eval(F f) const { return ptr_ ? *ptr_ : f(); } + +#endif // BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES +}; + +template + void swap ( optional& x, optional& y) BOOST_NOEXCEPT +{ + x.swap(y); +} + +} // namespace boost + +#endif // 1/0 + +#endif // header guard diff --git a/include/boost/optional/detail/optional_relops.hpp b/include/boost/optional/detail/optional_relops.hpp new file mode 100644 index 0000000..3f96117 --- /dev/null +++ b/include/boost/optional/detail/optional_relops.hpp @@ -0,0 +1,196 @@ +// 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/libs/optional for documentation. +// +// You are welcome to contact the author at: +// akrzemi1@gmail.com + +#ifndef BOOST_OPTIONAL_DETAIL_OPTIONAL_RELOPS_AJK_03OCT2015_HPP +#define BOOST_OPTIONAL_DETAIL_OPTIONAL_RELOPS_AJK_03OCT2015_HPP + +namespace boost { + +// optional's relational operators ( ==, !=, <, >, <=, >= ) have deep-semantics (compare values). +// WARNING: This is UNLIKE pointers. Use equal_pointees()/less_pointess() in generic code instead. + + +// +// optional vs optional cases +// + +template +inline +bool operator == ( optional const& x, optional const& y ) +{ return equal_pointees(x,y); } + +template +inline +bool operator < ( optional const& x, optional const& y ) +{ return less_pointees(x,y); } + +template +inline +bool operator != ( optional const& x, optional const& y ) +{ return !( x == y ) ; } + +template +inline +bool operator > ( optional const& x, optional const& y ) +{ return y < x ; } + +template +inline +bool operator <= ( optional const& x, optional const& y ) +{ return !( y < x ) ; } + +template +inline +bool operator >= ( optional const& x, optional const& y ) +{ return !( x < y ) ; } + + +// +// optional vs T cases +// +template +inline +bool operator == ( optional const& x, T const& y ) +{ return equal_pointees(x, optional(y)); } + +template +inline +bool operator < ( optional const& x, T const& y ) +{ return less_pointees(x, optional(y)); } + +template +inline +bool operator != ( optional const& x, T const& y ) +{ return !( x == y ) ; } + +template +inline +bool operator > ( optional const& x, T const& y ) +{ return y < x ; } + +template +inline +bool operator <= ( optional const& x, T const& y ) +{ return !( y < x ) ; } + +template +inline +bool operator >= ( optional const& x, T const& y ) +{ return !( x < y ) ; } + +// +// T vs optional cases +// + +template +inline +bool operator == ( T const& x, optional const& y ) +{ return equal_pointees( optional(x), y ); } + +template +inline +bool operator < ( T const& x, optional const& y ) +{ return less_pointees( optional(x), y ); } + +template +inline +bool operator != ( T const& x, optional const& y ) +{ return !( x == y ) ; } + +template +inline +bool operator > ( T const& x, optional const& y ) +{ return y < x ; } + +template +inline +bool operator <= ( T const& x, optional const& y ) +{ return !( y < x ) ; } + +template +inline +bool operator >= ( T const& x, optional const& y ) +{ return !( x < y ) ; } + + +// +// optional vs none cases +// + +template +inline +bool operator == ( optional const& x, none_t ) BOOST_NOEXCEPT +{ return !x; } + +template +inline +bool operator < ( optional const& x, none_t ) +{ return less_pointees(x,optional() ); } + +template +inline +bool operator != ( optional const& x, none_t ) BOOST_NOEXCEPT +{ return bool(x); } + +template +inline +bool operator > ( optional const& x, none_t y ) +{ return y < x ; } + +template +inline +bool operator <= ( optional const& x, none_t y ) +{ return !( y < x ) ; } + +template +inline +bool operator >= ( optional const& x, none_t y ) +{ return !( x < y ) ; } + +// +// none vs optional cases +// + +template +inline +bool operator == ( none_t , optional const& y ) BOOST_NOEXCEPT +{ return !y; } + +template +inline +bool operator < ( none_t , optional const& y ) +{ return less_pointees(optional() ,y); } + +template +inline +bool operator != ( none_t, optional const& y ) BOOST_NOEXCEPT +{ return bool(y); } + +template +inline +bool operator > ( none_t x, optional const& y ) +{ return y < x ; } + +template +inline +bool operator <= ( none_t x, optional const& y ) +{ return !( y < x ) ; } + +template +inline +bool operator >= ( none_t x, optional const& y ) +{ return !( x < y ) ; } + +} // namespace boost + +#endif // header guard + diff --git a/include/boost/optional/detail/optional_swap.hpp b/include/boost/optional/detail/optional_swap.hpp new file mode 100644 index 0000000..2a7059e --- /dev/null +++ b/include/boost/optional/detail/optional_swap.hpp @@ -0,0 +1,117 @@ +// 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/libs/optional for documentation. +// +// You are welcome to contact the author at: +// akrzemi1@gmail.com + +#ifndef BOOST_OPTIONAL_DETAIL_OPTIONAL_SWAP_AJK_28JAN2015_HPP +#define BOOST_OPTIONAL_DETAIL_OPTIONAL_SWAP_AJK_28JAN2015_HPP + +#include +#include + +namespace boost { + +namespace optional_detail { + +template struct swap_selector; + +template <> +struct swap_selector +{ + template + static void optional_swap ( optional& x, optional& y ) + { + const bool hasX = !!x; + const bool hasY = !!y; + + if ( !hasX && !hasY ) + return; + + if( !hasX ) + x.emplace(); + else if ( !hasY ) + y.emplace(); + + // Boost.Utility.Swap will take care of ADL and workarounds for broken compilers + boost::swap(x.get(), y.get()); + + if( !hasX ) + y = boost::none ; + else if( !hasY ) + x = boost::none ; + } +}; + +#ifdef BOOST_OPTIONAL_DETAIL_MOVE +# undef BOOST_OPTIONAL_DETAIL_MOVE +#endif + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES +# define BOOST_OPTIONAL_DETAIL_MOVE(EXPR_) boost::move(EXPR_) +#else +# define BOOST_OPTIONAL_DETAIL_MOVE(EXPR_) EXPR_ +#endif + +template <> +struct swap_selector +{ + template + static void optional_swap ( optional& x, optional& y ) + //BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible::value && BOOST_NOEXCEPT_EXPR(boost::swap(*x, *y))) + { + if (x) + { + if (y) + { + boost::swap(*x, *y); + } + else + { + y = BOOST_OPTIONAL_DETAIL_MOVE(*x); + x = boost::none; + } + } + else + { + if (y) + { + x = BOOST_OPTIONAL_DETAIL_MOVE(*y); + y = boost::none; + } + } + } +}; + +} // namespace optional_detail + +#if (!defined BOOST_NO_CXX11_RVALUE_REFERENCES) && (!defined BOOST_CONFIG_RESTORE_OBSOLETE_SWAP_IMPLEMENTATION) + +template +struct optional_swap_should_use_default_constructor : boost::false_type {} ; + +#else + +template +struct optional_swap_should_use_default_constructor : has_nothrow_default_constructor {} ; + +#endif + +template +inline void swap ( optional& x, optional& y ) +//BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible::value && BOOST_NOEXCEPT_EXPR(boost::swap(*x, *y))) +{ + optional_detail::swap_selector::value>::optional_swap(x, y); +} + +} // namespace boost + +#undef BOOST_OPTIONAL_DETAIL_MOVE + +#endif // header guard diff --git a/include/boost/optional/optional.hpp b/include/boost/optional/optional.hpp index 9def94e..46717fe 100644 --- a/include/boost/optional/optional.hpp +++ b/include/boost/optional/optional.hpp @@ -20,7 +20,6 @@ #include #include -#include #include #include #include @@ -31,208 +30,60 @@ #include #include #include +#include #include #include #include #include #include #include +#include #include #include #include -#include #include #include -#include -#include -#include -#include #include #include #include #include +#include +#include +#include -#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, -// so for the other icc versions, in-place factory support -// is disabled -#define BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT -#endif - -#if BOOST_WORKAROUND(__BORLANDC__, <= 0x551) -// BCB (5.5.1) cannot parse the nested template struct in an inplace factory. -#define BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT -#endif - -#if !defined(BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT) \ - && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581) ) -// BCB (up to 5.64) has the following bug: -// If there is a member function/operator template of the form -// template mfunc( Expr expr ) ; -// some calls are resolved to this even if there are other better matches. -// The effect of this bug is that calls to converting ctors and assignments -// are incrorrectly sink to this general catch-all member function template as shown above. -#define BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION -#endif - -#if defined(__GNUC__) && !defined(__INTEL_COMPILER) -// GCC since 3.3 has may_alias attribute that helps to alleviate optimizer issues with -// regard to violation of the strict aliasing rules. The optional< T > storage type is marked -// with this attribute in order to let the compiler know that it will alias objects of type T -// and silence compilation warnings. -#define BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS -#endif - -// Daniel Wallin discovered that bind/apply.hpp badly interacts with the apply<> -// member template of a factory as used in the optional<> implementation. -// He proposed this simple fix which is to move the call to apply<> outside -// namespace boost. -namespace boost_optional_detail -{ - template - inline void construct(Factory const& factory, void* address) - { - factory.BOOST_NESTED_TEMPLATE apply(address); - } -} - - +#ifdef BOOST_OPTIONAL_CONFIG_USE_OLD_IMPLEMENTATION_OF_OPTIONAL +#include +#else namespace boost { -class in_place_factory_base ; -class typed_in_place_factory_base ; - -// This forward is needed to refer to namespace scope swap from the member swap -template void swap ( optional& x, optional& y ); - namespace optional_detail { -// This local class is used instead of that in "aligned_storage.hpp" -// because I've found the 'official' class to ICE BCB5.5 -// when some types are used with optional<> -// (due to sizeof() passed down as a non-type template parameter) -template -class aligned_storage -{ - // Borland ICEs if unnamed unions are used for this! - union - // This works around GCC warnings about breaking strict aliasing rules when casting storage address to T* -#if defined(BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS) - __attribute__((__may_alias__)) -#endif - dummy_u - { - char data[ sizeof(T) ]; - BOOST_DEDUCED_TYPENAME type_with_alignment< - ::boost::alignment_of::value >::type aligner_; - } dummy_ ; - - public: - -#if defined(BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS) - void const* address() const { return &dummy_; } - void * address() { return &dummy_; } -#else - void const* address() const { return dummy_.data; } - void * address() { return dummy_.data; } -#endif -} ; - -template -struct types_when_isnt_ref -{ - typedef T const& reference_const_type ; - typedef T & reference_type ; -#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 - // GCC 4.4 has support for an early draft of rvalue references. The conforming version below - // causes warnings about returning references to a temporary. - static T&& move(T&& r) { return r; } -#else - static rval_reference_type move(reference_type r) { return boost::move(r); } -#endif -#endif - typedef T const* pointer_const_type ; - typedef T * pointer_type ; - typedef T const& argument_type ; -} ; - -template -struct types_when_is_ref -{ - typedef BOOST_DEDUCED_TYPENAME remove_reference::type raw_type ; - - typedef raw_type& reference_const_type ; - typedef raw_type& reference_type ; -#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES - typedef BOOST_DEDUCED_TYPENAME remove_const::type&& rval_reference_type ; - typedef raw_type& reference_type_of_temporary_wrapper; - static reference_type move(reference_type r) { return r; } -#endif - typedef raw_type* pointer_const_type ; - typedef raw_type* pointer_type ; - typedef raw_type& argument_type ; -} ; - -template -void prevent_binding_rvalue_ref_to_optional_lvalue_ref() -{ -#ifndef BOOST_OPTIONAL_CONFIG_ALLOW_BINDING_TO_RVALUES - BOOST_STATIC_ASSERT_MSG( - !boost::is_lvalue_reference::value || !boost::is_rvalue_reference::value, - "binding rvalue references to optional lvalue references is disallowed"); -#endif -} struct optional_tag {} ; + template class optional_base : public optional_tag { private : - typedef -#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) - BOOST_DEDUCED_TYPENAME -#endif - ::boost::detail::make_reference_content::type internal_type ; - - typedef aligned_storage storage_type ; - - typedef types_when_isnt_ref types_when_not_ref ; - typedef types_when_is_ref types_when_ref ; - + typedef aligned_storage storage_type ; typedef optional_base this_type ; protected : typedef T value_type ; - typedef mpl::true_ is_reference_tag ; - typedef mpl::false_ is_not_reference_tag ; - - typedef BOOST_DEDUCED_TYPENAME is_reference::type is_reference_predicate ; - - public: - typedef BOOST_DEDUCED_TYPENAME mpl::if_::type types ; - protected: - typedef BOOST_DEDUCED_TYPENAME types::reference_type reference_type ; - typedef BOOST_DEDUCED_TYPENAME types::reference_const_type reference_const_type ; + typedef T & reference_type ; + typedef T const& reference_const_type ; #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 ; + typedef T && rval_reference_type ; + typedef T && reference_type_of_temporary_wrapper ; #endif - typedef BOOST_DEDUCED_TYPENAME types::pointer_type pointer_type ; - typedef BOOST_DEDUCED_TYPENAME types::pointer_const_type pointer_const_type ; - typedef BOOST_DEDUCED_TYPENAME types::argument_type argument_type ; + typedef T * pointer_type ; + typedef T const* pointer_const_type ; + typedef T const& argument_type ; // Creates an optional uninitialized. // No-throw @@ -252,7 +103,7 @@ class optional_base : public optional_tag : m_initialized(false) { - construct(val); + construct(val); } #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES @@ -332,7 +183,7 @@ class optional_base : public optional_tag if (is_initialized()) { if ( rhs.is_initialized() ) - assign_value(rhs.get_impl(), is_reference_predicate() ); + assign_value(rhs.get_impl()); else destroy(); } else @@ -349,7 +200,7 @@ class optional_base : public optional_tag if (is_initialized()) { if ( rhs.is_initialized() ) - assign_value(boost::move(rhs.get_impl()), is_reference_predicate() ); + assign_value( boost::move(rhs.get_impl()) ); else destroy(); } else @@ -368,9 +219,9 @@ class optional_base : public optional_tag { if ( rhs.is_initialized() ) #ifndef BOOST_OPTIONAL_CONFIG_RESTORE_ASSIGNMENT_OF_NONCONVERTIBLE_TYPES - assign_value(rhs.get(), is_reference_predicate() ); + assign_value( rhs.get() ); #else - assign_value(static_cast(rhs.get()), is_reference_predicate() ); + assign_value( static_cast(rhs.get()) ); #endif else destroy(); @@ -395,7 +246,7 @@ class optional_base : public optional_tag if (is_initialized()) { if ( rhs.is_initialized() ) - assign_value(static_cast(rhs.get()), is_reference_predicate() ); + assign_value( static_cast(rhs.get()) ); else destroy(); } else @@ -410,7 +261,7 @@ class optional_base : public optional_tag void assign ( argument_type val ) { if (is_initialized()) - assign_value(val, is_reference_predicate() ); + assign_value(val); else construct(val); } @@ -419,7 +270,7 @@ class optional_base : public optional_tag void assign ( rval_reference_type val ) { if (is_initialized()) - assign_value( boost::move(val), is_reference_predicate() ); + assign_value( boost::move(val) ); else construct( boost::move(val) ); } #endif @@ -471,14 +322,14 @@ class optional_base : public optional_tag void construct ( argument_type val ) { - ::new (m_storage.address()) internal_type(val) ; + ::new (m_storage.address()) value_type(val) ; m_initialized = true ; } #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES void construct ( rval_reference_type val ) { - ::new (m_storage.address()) internal_type( types::move(val) ) ; + ::new (m_storage.address()) value_type( boost::move(val) ) ; m_initialized = true ; } #endif @@ -491,7 +342,7 @@ class optional_base : public optional_tag void emplace_assign ( Args&&... args ) { destroy(); - ::new (m_storage.address()) internal_type( boost::forward(args)... ); + ::new (m_storage.address()) value_type( boost::forward(args)... ); m_initialized = true ; } #elif (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) @@ -499,14 +350,14 @@ class optional_base : public optional_tag void emplace_assign ( Arg&& arg ) { destroy(); - ::new (m_storage.address()) internal_type( boost::forward(arg) ); + ::new (m_storage.address()) value_type( boost::forward(arg) ); m_initialized = true ; } void emplace_assign () { destroy(); - ::new (m_storage.address()) internal_type(); + ::new (m_storage.address()) value_type(); m_initialized = true ; } #else @@ -514,7 +365,7 @@ class optional_base : public optional_tag void emplace_assign ( const Arg& arg ) { destroy(); - ::new (m_storage.address()) internal_type( arg ); + ::new (m_storage.address()) value_type( arg ); m_initialized = true ; } @@ -522,14 +373,14 @@ class optional_base : public optional_tag void emplace_assign ( Arg& arg ) { destroy(); - ::new (m_storage.address()) internal_type( arg ); + ::new (m_storage.address()) value_type( arg ); m_initialized = true ; } void emplace_assign () { destroy(); - ::new (m_storage.address()) internal_type(); + ::new (m_storage.address()) value_type(); m_initialized = true ; } #endif @@ -541,7 +392,6 @@ class optional_base : public optional_tag template void construct ( Expr&& factory, in_place_factory_base const* ) { - BOOST_STATIC_ASSERT ( ::boost::mpl::not_::value ) ; boost_optional_detail::construct(factory, m_storage.address()); m_initialized = true ; } @@ -550,7 +400,6 @@ class optional_base : public optional_tag template void construct ( Expr&& factory, typed_in_place_factory_base const* ) { - BOOST_STATIC_ASSERT ( ::boost::mpl::not_::value ) ; factory.apply(m_storage.address()) ; m_initialized = true ; } @@ -575,7 +424,6 @@ class optional_base : public optional_tag template void construct ( Expr const& factory, in_place_factory_base const* ) { - BOOST_STATIC_ASSERT ( ::boost::mpl::not_::value ) ; boost_optional_detail::construct(factory, m_storage.address()); m_initialized = true ; } @@ -584,7 +432,6 @@ class optional_base : public optional_tag template void construct ( Expr const& factory, typed_in_place_factory_base const* ) { - BOOST_STATIC_ASSERT ( ::boost::mpl::not_::value ) ; factory.apply(m_storage.address()) ; m_initialized = true ; } @@ -615,7 +462,7 @@ class optional_base : public optional_tag template void construct ( Expr&& expr, void const* ) { - new (m_storage.address()) internal_type(boost::forward(expr)) ; + new (m_storage.address()) value_type(boost::forward(expr)) ; m_initialized = true ; } @@ -626,7 +473,7 @@ class optional_base : public optional_tag template void assign_expr_to_initialized ( Expr&& expr, void const* ) { - assign_value(boost::forward(expr), is_reference_predicate()); + assign_value( boost::forward(expr) ); } #else // Constructs using any expression implicitly convertible to the single argument @@ -636,7 +483,7 @@ class optional_base : public optional_tag template void construct ( Expr const& expr, void const* ) { - new (m_storage.address()) internal_type(expr) ; + new (m_storage.address()) value_type(expr) ; m_initialized = true ; } @@ -647,7 +494,7 @@ class optional_base : public optional_tag template void assign_expr_to_initialized ( Expr const& expr, void const* ) { - assign_value(expr, is_reference_predicate()); + assign_value(expr); } #endif @@ -674,7 +521,7 @@ class optional_base : public optional_tag { // An exception can be thrown here. // It it happens, THIS will be left uninitialized. - new (m_storage.address()) internal_type(types::move(expr.get())) ; + new (m_storage.address()) value_type(boost::move(expr.get())) ; m_initialized = true ; } } @@ -687,78 +534,77 @@ class optional_base : public optional_tag { // An exception can be thrown here. // It it happens, THIS will be left uninitialized. - new (m_storage.address()) internal_type(expr.get()) ; + new (m_storage.address()) value_type(expr.get()) ; m_initialized = true ; } } #endif #endif // defined BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION - void assign_value ( argument_type val, is_not_reference_tag ) { get_impl() = val; } - void assign_value ( argument_type val, is_reference_tag ) { construct(val); } + void assign_value ( argument_type val ) { get_impl() = val; } #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES - void assign_value ( rval_reference_type val, is_not_reference_tag ) { get_impl() = static_cast(val); } - void assign_value ( rval_reference_type val, is_reference_tag ) { construct( static_cast(val) ); } + void assign_value ( rval_reference_type val ) { get_impl() = static_cast(val); } #endif void destroy() { if ( m_initialized ) - destroy_impl(is_reference_predicate()) ; + destroy_impl() ; } - reference_const_type get_impl() const { return dereference(get_object(), is_reference_predicate() ) ; } - reference_type get_impl() { return dereference(get_object(), is_reference_predicate() ) ; } + reference_const_type get_impl() const { return m_storage.ref() ; } + reference_type get_impl() { return m_storage.ref() ; } - pointer_const_type get_ptr_impl() const { return cast_ptr(get_object(), is_reference_predicate() ) ; } - pointer_type get_ptr_impl() { return cast_ptr(get_object(), is_reference_predicate() ) ; } + pointer_const_type get_ptr_impl() const { return m_storage.ptr_ref(); } + pointer_type get_ptr_impl() { return m_storage.ptr_ref(); } private : - // internal_type can be either T or reference_content -#if defined(BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS) - // This workaround is supposed to silence GCC warnings about broken strict aliasing rules - internal_type const* get_object() const - { - union { void const* ap_pvoid; internal_type const* as_ptype; } caster = { m_storage.address() }; - return caster.as_ptype; - } - internal_type * get_object() - { - union { void* ap_pvoid; internal_type* as_ptype; } caster = { m_storage.address() }; - return caster.as_ptype; - } +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1600) + void destroy_impl ( ) { m_storage.ptr_ref()->~T() ; m_initialized = false ; } #else - internal_type const* get_object() const { return static_cast(m_storage.address()); } - internal_type * get_object() { return static_cast (m_storage.address()); } + void destroy_impl ( ) { m_storage.ref().T::~T() ; m_initialized = false ; } #endif - // reference_content lacks an implicit conversion to T&, so the following is needed to obtain a proper reference. - reference_const_type dereference( internal_type const* p, is_not_reference_tag ) const { return *p ; } - reference_type dereference( internal_type* p, is_not_reference_tag ) { return *p ; } - reference_const_type dereference( internal_type const* p, is_reference_tag ) const { return p->get() ; } - reference_type dereference( internal_type* p, is_reference_tag ) { return p->get() ; } - -#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581)) - void destroy_impl ( is_not_reference_tag ) { get_ptr_impl()->internal_type::~internal_type() ; m_initialized = false ; } -#else - void destroy_impl ( is_not_reference_tag ) { get_ptr_impl()->~T() ; m_initialized = false ; } -#endif - - void destroy_impl ( is_reference_tag ) { m_initialized = false ; } - - // If T is of reference type, trying to get a pointer to the held value must result in a compile-time error. - // Decent compilers should disallow conversions from reference_content* to T*, but just in case, - // the following olverloads are used to filter out the case and guarantee an error in case of T being a reference. - pointer_const_type cast_ptr( internal_type const* p, is_not_reference_tag ) const { return p ; } - pointer_type cast_ptr( internal_type * p, is_not_reference_tag ) { return p ; } - pointer_const_type cast_ptr( internal_type const* p, is_reference_tag ) const { return &p->get() ; } - pointer_type cast_ptr( internal_type * p, is_reference_tag ) { return &p->get() ; } - bool m_initialized ; storage_type m_storage ; } ; +// definition of metafunciton is_optional_val_init_candidate +template +struct is_optional_related + : boost::conditional< boost::is_base_of::type>::value + || boost::is_same::type, none_t>::value, + boost::true_type, boost::false_type>::type +{}; + +#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40500) + // this condition is a copy paste from is_constructible.hpp + +template +struct is_convertible_to_T_or_factory + : boost::conditional< boost::is_base_of::type>::value + || boost::is_base_of::type>::value + || boost::is_constructible::value + , boost::true_type, boost::false_type>::type +{}; + +#else + +#define BOOST_OPTIONAL_DETAIL_NO_IS_CONSTRUCTIBLE_TRAIT + +template +struct is_convertible_to_T_or_factory : boost::true_type +{}; + +#endif // is_convertible condition + +template +struct is_optional_val_init_candidate + : boost::conditional< !is_optional_related::value && is_convertible_to_T_or_factory::value + , boost::true_type, boost::false_type>::type +{}; + } // namespace optional_detail template @@ -797,7 +643,7 @@ class optional : public optional_detail::optional_base // Creates an optional initialized with 'move(val)'. // Can throw if T::T(T &&) does optional ( rval_reference_type val ) : base( boost::forward(val) ) - {optional_detail::prevent_binding_rvalue_ref_to_optional_lvalue_ref();} + {} #endif // Creates an optional initialized with 'val' IFF cond is true, otherwise creates an uninitialized optional. @@ -847,12 +693,10 @@ class optional : public optional_detail::optional_base template explicit optional ( Expr&& expr, - BOOST_DEDUCED_TYPENAME boost::disable_if_c< - (boost::is_base_of::type>::value) || - boost::is_same::type, none_t>::value >::type* = 0 + BOOST_DEDUCED_TYPENAME boost::enable_if< optional_detail::is_optional_val_init_candidate >::type* = 0 ) : base(boost::forward(expr),boost::addressof(expr)) - {optional_detail::prevent_binding_rvalue_ref_to_optional_lvalue_ref();} + {} #else template @@ -873,23 +717,22 @@ class optional : public optional_detail::optional_base {} #endif - // No-throw (assuming T::~T() doesn't) - ~optional() {} +#if BOOST_WORKAROUND(_MSC_VER, <= 1600) + // On old MSVC compilers the implicitly declared dtor is not called + ~optional() {} +#endif + + #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_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES template - BOOST_DEDUCED_TYPENAME boost::disable_if_c< - boost::is_base_of::type>::value || - boost::is_same::type, none_t>::value, - optional& - >::type + BOOST_DEDUCED_TYPENAME boost::enable_if, optional&>::type operator= ( Expr&& expr ) { - optional_detail::prevent_binding_rvalue_ref_to_optional_lvalue_ref(); this->assign_expr(boost::forward(expr),boost::addressof(expr)); return *this ; } @@ -957,7 +800,6 @@ class optional : public optional_detail::optional_base // Assigns from a T (deep-moves the rhs value) optional& operator= ( rval_reference_type val ) { - optional_detail::prevent_binding_rvalue_ref_to_optional_lvalue_ref(); this->assign( boost::move(val) ) ; return *this ; } @@ -1040,7 +882,7 @@ class optional : public optional_detail::optional_base #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 base::types::move(this->get()) ; } + reference_type_of_temporary_wrapper operator *() && { return boost::move(this->get()) ; } #else reference_const_type operator *() const { return this->get() ; } reference_type operator *() { return this->get() ; } @@ -1066,7 +908,7 @@ class optional : public optional_detail::optional_base reference_type_of_temporary_wrapper value() && { if (this->is_initialized()) - return base::types::move(this->get()) ; + return boost::move(this->get()) ; else throw_exception(bad_optional_access()); } @@ -1104,7 +946,7 @@ class optional : public optional_detail::optional_base value_type value_or ( U&& v ) && { if (this->is_initialized()) - return base::types::move(get()); + return boost::move(get()); else return boost::forward(v); } @@ -1152,7 +994,7 @@ class optional : public optional_detail::optional_base value_type value_or_eval ( F f ) && { if (this->is_initialized()) - return base::types::move(get()); + return boost::move(get()); else return f(); } @@ -1172,6 +1014,12 @@ class optional : public optional_detail::optional_base BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT() } ; +} // namespace boost + +#endif // BOOST_OPTIONAL_CONFIG_USE_OLD_IMPLEMENTATION_OF_OPTIONAL + +namespace boost { + #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES template class optional @@ -1180,6 +1028,14 @@ class optional } ; #endif +} // namespace boost + +#ifndef BOOST_OPTIONAL_CONFIG_DONT_SPECIALIZE_OPTIONAL_REFS +# include +#endif + +namespace boost { + // Returns optional(v) template inline @@ -1268,6 +1124,10 @@ get_pointer ( optional& opt ) return opt.get_ptr() ; } +} // namespace boost + +namespace boost { + // The following declaration prevents a bug where operator safe-bool is used upon streaming optional object if you forget the IO header. template std::basic_ostream& @@ -1277,291 +1137,9 @@ operator<<(std::basic_ostream& os, optional_detail::optiona 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. - - -// -// optional vs optional cases -// - -template -inline -bool operator == ( optional const& x, optional const& y ) -{ return equal_pointees(x,y); } - -template -inline -bool operator < ( optional const& x, optional const& y ) -{ return less_pointees(x,y); } - -template -inline -bool operator != ( optional const& x, optional const& y ) -{ return !( x == y ) ; } - -template -inline -bool operator > ( optional const& x, optional const& y ) -{ return y < x ; } - -template -inline -bool operator <= ( optional const& x, optional const& y ) -{ return !( y < x ) ; } - -template -inline -bool operator >= ( optional const& x, optional const& y ) -{ return !( x < y ) ; } - - -// -// optional vs T cases -// -template -inline -bool operator == ( optional const& x, T const& y ) -{ return equal_pointees(x, optional(y)); } - -template -inline -bool operator < ( optional const& x, T const& y ) -{ return less_pointees(x, optional(y)); } - -template -inline -bool operator != ( optional const& x, T const& y ) -{ return !( x == y ) ; } - -template -inline -bool operator > ( optional const& x, T const& y ) -{ return y < x ; } - -template -inline -bool operator <= ( optional const& x, T const& y ) -{ return !( y < x ) ; } - -template -inline -bool operator >= ( optional const& x, T const& y ) -{ return !( x < y ) ; } - -// -// T vs optional cases -// - -template -inline -bool operator == ( T const& x, optional const& y ) -{ return equal_pointees( optional(x), y ); } - -template -inline -bool operator < ( T const& x, optional const& y ) -{ return less_pointees( optional(x), y ); } - -template -inline -bool operator != ( T const& x, optional const& y ) -{ return !( x == y ) ; } - -template -inline -bool operator > ( T const& x, optional const& y ) -{ return y < x ; } - -template -inline -bool operator <= ( T const& x, optional const& y ) -{ return !( y < x ) ; } - -template -inline -bool operator >= ( T const& x, optional const& y ) -{ return !( x < y ) ; } - - -// -// optional vs none cases -// - -template -inline -bool operator == ( optional const& x, none_t ) BOOST_NOEXCEPT -{ return !x; } - -template -inline -bool operator < ( optional const& x, none_t ) -{ return less_pointees(x,optional() ); } - -template -inline -bool operator != ( optional const& x, none_t ) BOOST_NOEXCEPT -{ return bool(x); } - -template -inline -bool operator > ( optional const& x, none_t y ) -{ return y < x ; } - -template -inline -bool operator <= ( optional const& x, none_t y ) -{ return !( y < x ) ; } - -template -inline -bool operator >= ( optional const& x, none_t y ) -{ return !( x < y ) ; } - -// -// none vs optional cases -// - -template -inline -bool operator == ( none_t , optional const& y ) BOOST_NOEXCEPT -{ return !y; } - -template -inline -bool operator < ( none_t , optional const& y ) -{ return less_pointees(optional() ,y); } - -template -inline -bool operator != ( none_t, optional const& y ) BOOST_NOEXCEPT -{ return bool(y); } - -template -inline -bool operator > ( none_t x, optional const& y ) -{ return y < x ; } - -template -inline -bool operator <= ( none_t x, optional const& y ) -{ return !( y < x ) ; } - -template -inline -bool operator >= ( none_t x, optional const& y ) -{ return !( x < y ) ; } - -namespace optional_detail { - -template struct swap_selector; - -template<> -struct swap_selector -{ - template - static void optional_swap ( optional& x, optional& y ) - { - const bool hasX = !!x; - const bool hasY = !!y; - - if ( !hasX && !hasY ) - return; - - if( !hasX ) - x.emplace(); - else if ( !hasY ) - y.emplace(); - - // Boost.Utility.Swap will take care of ADL and workarounds for broken compilers - boost::swap(x.get(),y.get()); - - if( !hasX ) - y = boost::none ; - else if( !hasY ) - x = boost::none ; - } -}; - -#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES -template<> -struct swap_selector -{ - template - static void optional_swap ( optional& x, optional& y ) - //BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible::value && BOOST_NOEXCEPT_EXPR(boost::swap(*x, *y))) - { - if(x) - { - if (y) - { - boost::swap(*x, *y); - } - else - { - y = boost::move(*x); - x = boost::none; - } - } - else - { - if (y) - { - x = boost::move(*y); - y = boost::none; - } - } - } -}; -#else -template<> -struct swap_selector -{ - template - static void optional_swap ( optional& x, optional& y ) - { - const bool hasX = !!x; - const bool hasY = !!y; - - if ( !hasX && hasY ) - { - x = y.get(); - y = boost::none ; - } - else if ( hasX && !hasY ) - { - y = x.get(); - x = boost::none ; - } - else if ( hasX && hasY ) - { - // Boost.Utility.Swap will take care of ADL and workarounds for broken compilers - boost::swap(x.get(),y.get()); - } - } -}; -#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 -struct optional_swap_should_use_default_constructor : boost::false_type {} ; - -#else - -template -struct optional_swap_should_use_default_constructor : has_nothrow_default_constructor {} ; - -#endif //BOOST_NO_CXX11_RVALUE_REFERENCES - -template inline void swap ( optional& x, optional& y ) - //BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible::value && BOOST_NOEXCEPT_EXPR(boost::swap(*x, *y))) -{ - optional_detail::swap_selector::value>::optional_swap(x, y); -} - } // namespace boost -#endif +#include +#include + +#endif // header guard diff --git a/include/boost/optional/optional_fwd.hpp b/include/boost/optional/optional_fwd.hpp index fb59682..c41a34d 100644 --- a/include/boost/optional/optional_fwd.hpp +++ b/include/boost/optional/optional_fwd.hpp @@ -1,4 +1,5 @@ // Copyright (C) 2003, 2008 Fernando Luis Cacciola Carballal. +// Copyright (C) 2016 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 @@ -15,15 +16,25 @@ #ifndef BOOST_OPTIONAL_OPTIONAL_FWD_FLC_19NOV2002_HPP #define BOOST_OPTIONAL_OPTIONAL_FWD_FLC_19NOV2002_HPP +#include namespace boost { template class optional ; -template void swap ( optional& , optional& ); +// This forward is needed to refer to namespace scope swap from the member swap +template void swap ( optional& , optional& ) ; template struct optional_swap_should_use_default_constructor ; +#ifndef BOOST_OPTIONAL_CONFIG_DONT_SPECIALIZE_OPTIONAL_REFS + +template class optional ; + +template void swap ( optional& , optional& ) BOOST_NOEXCEPT; + +#endif + } // namespace boost #endif diff --git a/meta/libraries.json b/meta/libraries.json index 4bdac31..2c60271 100644 --- a/meta/libraries.json +++ b/meta/libraries.json @@ -7,7 +7,7 @@ ], "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" + "Data" ], "maintainers": [ "Fernando Cacciola ", diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 6b4e857..20be6cf 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -39,6 +39,8 @@ import testing ; [ run optional_test_emplace.cpp ] [ run optional_test_minimum_requirements.cpp ] [ run optional_test_msvc_bug_workaround.cpp ] + [ compile optional_test_sfinae_friendly_value_ctor.cpp ] + [ compile-fail optional_test_ref_convert_assign_const_int_prevented.cpp ] [ compile-fail optional_test_fail1.cpp ] [ compile-fail optional_test_fail3a.cpp ] [ compile-fail optional_test_fail3b.cpp ] @@ -60,5 +62,11 @@ import testing ; [ 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 ] + [ run optional_xconfig_NO_PROPER_ASSIGN_FROM_CONST_INT_pass.cpp ] + [ run-fail optional_xconfig_NO_PROPER_ASSIGN_FROM_CONST_INT_fail.cpp ] + [ run optional_xconfig_NO_PROPER_CONVERT_FROM_CONST_INT_pass.cpp ] + [ run-fail optional_xconfig_NO_PROPER_CONVERT_FROM_CONST_INT_fail.cpp ] + [ run optional_xconfig_NO_LEGAL_CONVERT_FROM_REF_pass.cpp ] + [ compile-fail optional_xconfig_NO_LEGAL_CONVERT_FROM_REF_fail.cpp ] ; } diff --git a/test/optional_ref_assign_test_defs.hpp b/test/optional_ref_assign_test_defs.hpp index 292d0fc..1b2a1b0 100644 --- a/test/optional_ref_assign_test_defs.hpp +++ b/test/optional_ref_assign_test_defs.hpp @@ -163,26 +163,11 @@ void test_rebinding_assignment_semantics() BOOST_TEST_EQ(val(v), 2); } -template +template void test_converting_assignment() { typename concrete_type_of::type v1(1), v2(2), v3(3); - optional 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 -void test_converting_assignment_for_noconst_const() -{ - typename concrete_type_of::type v1(1), v2(2), v3(3); - optional oA(v1), oB(none); + optional oA(v1), oB(none); oA = v2; BOOST_TEST(oA); @@ -194,4 +179,3 @@ void test_converting_assignment_for_noconst_const() } #endif //BOOST_OPTIONAL_TEST_OPTIONAL_REF_ASSIGN_TEST_DEFS_AK_07JAN2015_HPP - diff --git a/test/optional_test_emplace.cpp b/test/optional_test_emplace.cpp index 0aa6674..1877a54 100644 --- a/test/optional_test_emplace.cpp +++ b/test/optional_test_emplace.cpp @@ -24,7 +24,7 @@ using boost::optional; using boost::none; -#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) class Guard { @@ -90,7 +90,7 @@ void test_emplace() #endif -#if (!defined BOOST_NO_CXX11_RVALUE_REFERENCES) +#if (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) struct ThrowOnMove @@ -120,7 +120,7 @@ struct Thrower private: Thrower(Thrower const&); -#if (!defined BOOST_NO_CXX11_RVALUE_REFERENCES) +#if (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) Thrower(Thrower&&); #endif }; @@ -192,10 +192,10 @@ void test_emplace() int main() { -#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) test_emplace(); #endif -#if (!defined BOOST_NO_CXX11_RVALUE_REFERENCES) +#if (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) test_no_moves_on_emplacement(); #endif test_clear_on_throw(); diff --git a/test/optional_test_move.cpp b/test/optional_test_move.cpp index 51aa970..1558c34 100644 --- a/test/optional_test_move.cpp +++ b/test/optional_test_move.cpp @@ -24,7 +24,7 @@ using boost::none; //#ifndef BOOST_OPTIONAL_NO_CONVERTING_ASSIGNMENT //#ifndef BOOST_OPTIONAL_NO_CONVERTING_COPY_CTOR -#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES enum State { @@ -334,7 +334,7 @@ void test_optional_ref_to_movables() int main() { -#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES test_move_ctor_from_U(); test_move_ctor_form_T(); test_move_ctor_from_optional_T(); diff --git a/test/optional_test_noexcept_move.cpp b/test/optional_test_noexcept_move.cpp index 9ce927f..0675844 100644 --- a/test/optional_test_noexcept_move.cpp +++ b/test/optional_test_noexcept_move.cpp @@ -20,7 +20,7 @@ using boost::optional; -#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES #ifndef BOOST_NO_CXX11_NOEXCEPT // these 4 classes have different noexcept signatures in move operations @@ -106,7 +106,7 @@ void test_noexcept_optional_with_operator() // compile-time test } #endif // !defned BOOST_NO_CXX11_NOEXCEPT -#endif // !defined BOOST_NO_CXX11_RVALUE_REFERENCES +#endif // !defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES int main() { diff --git a/test/optional_test_ref_assign_portable_minimum.cpp b/test/optional_test_ref_assign_portable_minimum.cpp index 2a548ab..9ee0a0f 100644 --- a/test/optional_test_ref_assign_portable_minimum.cpp +++ b/test/optional_test_ref_assign_portable_minimum.cpp @@ -38,7 +38,7 @@ void test_optional_ref_assignment() int main() { test_optional_ref_assignment(); - //test_optional_ref_assignment(); + test_optional_ref_assignment(); return boost::report_errors(); } diff --git a/test/optional_test_ref_convert_assign_const_int.cpp b/test/optional_test_ref_convert_assign_const_int.cpp index 30d37a6..fb44aa1 100644 --- a/test/optional_test_ref_convert_assign_const_int.cpp +++ b/test/optional_test_ref_convert_assign_const_int.cpp @@ -23,8 +23,8 @@ int main() { - test_converting_assignment(); - test_converting_assignment_for_noconst_const(); - +#ifndef BOOST_OPTIONAL_CONFIG_NO_PROPER_ASSIGN_FROM_CONST_INT + test_converting_assignment(); +#endif return boost::report_errors(); } diff --git a/test/optional_test_ref_convert_assign_const_int_prevented.cpp b/test/optional_test_ref_convert_assign_const_int_prevented.cpp new file mode 100644 index 0000000..a08ca7a --- /dev/null +++ b/test/optional_test_ref_convert_assign_const_int_prevented.cpp @@ -0,0 +1,32 @@ +// 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() +{ +#ifdef BOOST_OPTIONAL_CONFIG_NO_PROPER_ASSIGN_FROM_CONST_INT + test_converting_assignment(); +#else + BOOST_STATIC_ASSERT(false, "EXPECTED TEST COMPILE-TIME FAILURE"); +#endif + return boost::report_errors(); +} diff --git a/test/optional_test_ref_convert_assign_mutable_int.cpp b/test/optional_test_ref_convert_assign_mutable_int.cpp index 4338e52..56a6e80 100644 --- a/test/optional_test_ref_convert_assign_mutable_int.cpp +++ b/test/optional_test_ref_convert_assign_mutable_int.cpp @@ -23,7 +23,8 @@ int main() { - test_converting_assignment(); + test_converting_assignment(); + test_converting_assignment(); return boost::report_errors(); } diff --git a/test/optional_test_ref_convert_assign_non_int.cpp b/test/optional_test_ref_convert_assign_non_int.cpp index d59e46e..80566b2 100644 --- a/test/optional_test_ref_convert_assign_non_int.cpp +++ b/test/optional_test_ref_convert_assign_non_int.cpp @@ -25,15 +25,15 @@ template void test_all_const_cases() { - test_converting_assignment(); - test_converting_assignment(); - test_converting_assignment_for_noconst_const(); + test_converting_assignment(); + test_converting_assignment(); + test_converting_assignment(); } int main() { test_all_const_cases(); - //test_all_const_cases(); + test_all_const_cases(); return boost::report_errors(); } diff --git a/test/optional_test_ref_converting_ctor.cpp b/test/optional_test_ref_converting_ctor.cpp index d7df3dc..735c354 100644 --- a/test/optional_test_ref_converting_ctor.cpp +++ b/test/optional_test_ref_converting_ctor.cpp @@ -101,7 +101,7 @@ int main() { test_all_const_cases(); test_all_const_cases(); - //test_all_const_cases(); + test_all_const_cases(); return boost::report_errors(); } diff --git a/test/optional_test_ref_portable_minimum.cpp b/test/optional_test_ref_portable_minimum.cpp index e8439c9..5bd7d11 100644 --- a/test/optional_test_ref_portable_minimum.cpp +++ b/test/optional_test_ref_portable_minimum.cpp @@ -199,11 +199,11 @@ void test_direct_init_for() BOOST_TEST_EQ(val(v), 7); } -template +template void test_clearing_the_value() { typename concrete_type_of::type v(2); - optional o1(v), o2(v); + optional o1(v), o2(v); BOOST_TEST(o1); BOOST_TEST(o1 != none); @@ -220,11 +220,11 @@ void test_clearing_the_value() BOOST_TEST_EQ(val(v), 2); } -template +template void test_equality() { typename concrete_type_of::type v1(1), v2(2), v2_(2), v3(3); - optional o1(v1), o2(v2), o2_(v2_), o3(v3), o3_(v3), oN, oN_; + optional 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); @@ -256,11 +256,11 @@ void test_equality() BOOST_TEST( (o2 != oN)); } -template +template void test_order() { typename concrete_type_of::type v1(1), v2(2), v2_(2), v3(3); - optional o1(v1), o2(v2), o2_(v2_), o3(v3), o3_(v3), oN, oN_; + optional 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)); @@ -399,13 +399,35 @@ void test_order() BOOST_TEST(!(o3_ < oN_)); } -template +template void test_swap() { typename concrete_type_of::type v1(1), v2(2); - optional o1(v1), o1_(v1), o2(v2), o2_(v2), oN, oN_; + optional o1(v1), o1_(v1), o2(v2), o2_(v2), oN, oN_; - // swap(o1, o1); DOESN'T WORK + swap(o1, o1); + BOOST_TEST(o1); + BOOST_TEST(boost::addressof(*o1) == boost::addressof(v1)); + + swap(oN, oN_); + BOOST_TEST(!oN); + BOOST_TEST(!oN_); + + swap(o1, oN); + BOOST_TEST(!o1); + BOOST_TEST(oN); + BOOST_TEST(boost::addressof(*oN) == boost::addressof(v1)); + + swap(oN, o1); + BOOST_TEST(!oN); + BOOST_TEST(o1); + BOOST_TEST(boost::addressof(*o1) == boost::addressof(v1)); + + swap(o1_, o2_); + BOOST_TEST(o1_); + BOOST_TEST(o2_); + BOOST_TEST(boost::addressof(*o1_) == boost::addressof(v2)); + BOOST_TEST(boost::addressof(*o2_) == boost::addressof(v1)); } template @@ -413,11 +435,11 @@ void test_optional_ref() { test_not_containing_value_for(); test_direct_init_for(); - test_clearing_the_value(); + test_clearing_the_value(); test_arrow(); - test_equality(); - test_order(); - test_swap(); + test_equality(); + test_order(); + test_swap(); } template @@ -426,23 +448,27 @@ void test_optional_const_ref() test_not_containing_value_for(); test_direct_init_for_const(); test_direct_init_for_noconst_const(); - test_clearing_the_value(); + test_clearing_the_value(); + test_clearing_the_value(); test_arrow_const(); test_arrow_noconst_const(); - test_equality(); - test_order(); - //test_swap(); + test_equality(); + test_equality(); + test_order(); + test_order(); + test_swap(); + test_swap(); } int main() { test_optional_ref(); test_optional_ref(); - //test_optional_ref(); + test_optional_ref(); test_optional_const_ref(); test_optional_const_ref(); - //test_optional_const_ref(); + test_optional_const_ref(); return boost::report_errors(); } diff --git a/test/optional_test_sfinae_friendly_value_ctor.cpp b/test/optional_test_sfinae_friendly_value_ctor.cpp new file mode 100644 index 0000000..d7af15d --- /dev/null +++ b/test/optional_test_sfinae_friendly_value_ctor.cpp @@ -0,0 +1,38 @@ +// 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 + +using boost::optional; + +#if (!defined BOOST_OPTIONAL_DETAIL_NO_IS_CONSTRUCTIBLE_TRAIT) + +struct X {}; +struct Y {}; + +struct Resource +{ + explicit Resource(const X&) {} +}; + +BOOST_STATIC_ASSERT(( boost::is_constructible::value)); +BOOST_STATIC_ASSERT((!boost::is_constructible::value)); + +BOOST_STATIC_ASSERT(( boost::is_constructible, const X&>::value)); +BOOST_STATIC_ASSERT((!boost::is_constructible, const Y&>::value)); + +#endif + +int main() { } diff --git a/test/optional_test_swap.cpp b/test/optional_test_swap.cpp index dac7ae1..2feed25 100644 --- a/test/optional_test_swap.cpp +++ b/test/optional_test_swap.cpp @@ -23,6 +23,11 @@ #include "boost/core/lightweight_test.hpp" +#if __cplusplus < 201103L +#include +#else +#include +#endif using boost::optional; using boost::none; @@ -202,13 +207,13 @@ namespace boost { // template <> struct optional_swap_should_use_default_constructor< - optional_swap_test::class_whose_default_ctor_should_be_used> : mpl::true_ {} ; + optional_swap_test::class_whose_default_ctor_should_be_used> : true_type {} ; template <> struct optional_swap_should_use_default_constructor< - optional_swap_test::class_whose_default_ctor_should_not_be_used> : mpl::false_ {} ; + optional_swap_test::class_whose_default_ctor_should_not_be_used> : false_type {} ; template struct optional_swap_should_use_default_constructor< - optional_swap_test::template_whose_default_ctor_should_be_used > : mpl::true_ {} ; + optional_swap_test::template_whose_default_ctor_should_be_used > : true_type {} ; // diff --git a/test/optional_test_value_access.cpp b/test/optional_test_value_access.cpp index 1759588..47ec5cc 100644 --- a/test/optional_test_value_access.cpp +++ b/test/optional_test_value_access.cpp @@ -175,7 +175,7 @@ void test_const_move() } -#ifndef BOOST_NO_CXX11_REF_QUALIFIERS +#if (!defined BOOST_NO_CXX11_REF_QUALIFIERS) && (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) struct MoveOnly { explicit MoveOnly(int){} diff --git a/test/optional_xconfig_HACK_TO_LIST_PREDEFINED_MACROS.cpp b/test/optional_xconfig_HACK_TO_LIST_PREDEFINED_MACROS.cpp new file mode 100644 index 0000000..e6b6ba0 --- /dev/null +++ b/test/optional_xconfig_HACK_TO_LIST_PREDEFINED_MACROS.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 + +#include "boost/core/lightweight_test.hpp" +#include "boost/optional/detail/optional_config.hpp" +#include + +int main() +{ +#if defined(__GNUC__) + + std::string emptys; + +#ifdef BOOST_INTEL_CXX_VERSION + BOOST_TEST_EQ(emptys, "HAS INTEL INSIDE"); +#else + BOOST_TEST_EQ(emptys, "NO INTEL INSIDE"); +#endif + +#if !defined BOOST_NO_CXX11_RVALUE_REFERENCES + BOOST_TEST_EQ(emptys, "HAS RVALUE REFS"); +#else + BOOST_TEST_EQ(emptys, "NO RVALUE REFS"); +#endif + + int empty = -1; + BOOST_TEST_EQ(empty, __GNUC__); + BOOST_TEST_EQ(empty, __GNUC_MINOR__); + BOOST_TEST_EQ(empty, __GNUC_PATCHLEVEL__); + BOOST_TEST_EQ(empty, __cplusplus); +#endif + return boost::report_errors(); +} diff --git a/test/optional_xconfig_NO_LEGAL_CONVERT_FROM_REF_fail.cpp b/test/optional_xconfig_NO_LEGAL_CONVERT_FROM_REF_fail.cpp new file mode 100644 index 0000000..8cc1e70 --- /dev/null +++ b/test/optional_xconfig_NO_LEGAL_CONVERT_FROM_REF_fail.cpp @@ -0,0 +1,37 @@ +// 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/core/ignore_unused.hpp" +#include "boost/core/lightweight_test.hpp" +#include "boost/optional/detail/optional_config.hpp" + +#if (defined BOOST_NO_CXX11_RVALUE_REFERENCES) || (!defined BOOST_OPTIONAL_CONFIG_NO_LEGAL_CONVERT_FROM_REF) + +static_assert(false, "failed as requested"); + +#else + +struct S {}; + +struct Binder +{ + S& ref_; + template Binder (R&&r) : ref_(r) {} +}; + +int main() +{ + S s ; + Binder b = s; + boost::ignore_unused(b); +} + +#endif diff --git a/test/optional_xconfig_NO_LEGAL_CONVERT_FROM_REF_pass.cpp b/test/optional_xconfig_NO_LEGAL_CONVERT_FROM_REF_pass.cpp new file mode 100644 index 0000000..a6edbc6 --- /dev/null +++ b/test/optional_xconfig_NO_LEGAL_CONVERT_FROM_REF_pass.cpp @@ -0,0 +1,38 @@ +// 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/core/ignore_unused.hpp" +#include "boost/core/lightweight_test.hpp" +#include "boost/optional/detail/optional_config.hpp" + +#if (defined BOOST_NO_CXX11_RVALUE_REFERENCES) || (defined BOOST_OPTIONAL_CONFIG_NO_LEGAL_CONVERT_FROM_REF) + +int main() { return 0; } + +#else + +struct S {}; + +struct Binder +{ + S& ref_; + template Binder (R&&r) : ref_(r) {} +}; + +int main() +{ + S s ; + Binder b = s; + boost::ignore_unused(b); + return 0; +} + +#endif diff --git a/test/optional_xconfig_NO_PROPER_ASSIGN_FROM_CONST_INT_fail.cpp b/test/optional_xconfig_NO_PROPER_ASSIGN_FROM_CONST_INT_fail.cpp new file mode 100644 index 0000000..7bf6d92 --- /dev/null +++ b/test/optional_xconfig_NO_PROPER_ASSIGN_FROM_CONST_INT_fail.cpp @@ -0,0 +1,42 @@ +// 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/core/lightweight_test.hpp" +#include "boost/optional/detail/optional_config.hpp" + +#ifndef BOOST_OPTIONAL_CONFIG_NO_PROPER_ASSIGN_FROM_CONST_INT + +int main() +{ + BOOST_ERROR("failed as requested"); + return boost::report_errors(); +} + +#else + +const int global_i = 0; + +struct Binder +{ + void operator=(const int& i) + { + BOOST_TEST(&i == &global_i); + } +}; + +int main() +{ + Binder s; + s = global_i; + return boost::report_errors(); +} + +#endif diff --git a/test/optional_xconfig_NO_PROPER_ASSIGN_FROM_CONST_INT_pass.cpp b/test/optional_xconfig_NO_PROPER_ASSIGN_FROM_CONST_INT_pass.cpp new file mode 100644 index 0000000..942b856 --- /dev/null +++ b/test/optional_xconfig_NO_PROPER_ASSIGN_FROM_CONST_INT_pass.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 + +#include "boost/core/lightweight_test.hpp" +#include "boost/optional/detail/optional_config.hpp" + +#ifndef BOOST_OPTIONAL_CONFIG_NO_PROPER_ASSIGN_FROM_CONST_INT + +const int global_i = 0; + +struct Binder +{ + void operator=(const int& i) + { + BOOST_TEST(&i == &global_i); + } +}; + +int main() +{ + Binder s; + s = global_i; + return boost::report_errors(); +} + +#else + +int main() +{ + return boost::report_errors(); +} + +#endif diff --git a/test/optional_xconfig_NO_PROPER_CONVERT_FROM_CONST_INT_fail.cpp b/test/optional_xconfig_NO_PROPER_CONVERT_FROM_CONST_INT_fail.cpp new file mode 100644 index 0000000..07bb1b6 --- /dev/null +++ b/test/optional_xconfig_NO_PROPER_CONVERT_FROM_CONST_INT_fail.cpp @@ -0,0 +1,43 @@ +// 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/core/ignore_unused.hpp" +#include "boost/core/lightweight_test.hpp" +#include "boost/optional/detail/optional_config.hpp" + +#ifndef BOOST_OPTIONAL_CONFIG_NO_PROPER_CONVERT_FROM_CONST_INT + +int main() +{ + BOOST_ERROR("failed as requested"); + return boost::report_errors(); +} + +#else + +const int global_i = 0; + +struct Binder +{ + Binder(const int& i) + { + BOOST_TEST(&i == &global_i); + } +}; + +int main() +{ + Binder b = global_i; + boost::ignore_unused(b); + return boost::report_errors(); +} + +#endif diff --git a/test/optional_xconfig_NO_PROPER_CONVERT_FROM_CONST_INT_pass.cpp b/test/optional_xconfig_NO_PROPER_CONVERT_FROM_CONST_INT_pass.cpp new file mode 100644 index 0000000..b71554e --- /dev/null +++ b/test/optional_xconfig_NO_PROPER_CONVERT_FROM_CONST_INT_pass.cpp @@ -0,0 +1,42 @@ +// 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/core/ignore_unused.hpp" +#include "boost/core/lightweight_test.hpp" +#include "boost/optional/detail/optional_config.hpp" + +#ifndef BOOST_OPTIONAL_CONFIG_NO_PROPER_CONVERT_FROM_CONST_INT + +const int global_i = 0; + +struct Binder +{ + Binder(const int& i) + { + BOOST_TEST(&i == &global_i); + } +}; + +int main() +{ + Binder b = global_i; + boost::ignore_unused(b); + return boost::report_errors(); +} + +#else + +int main() +{ + return boost::report_errors(); +} + +#endif