make optional constexpr in C++14

Author: akrzemi1

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-2024 Andrzej Krzemieński]
+    [copyright 2014-2026 Andrzej Krzemieński]
     [category miscellaneous]
     [id optional]
     [dirname optional]

doc/01_quick_start.qbk

@@ -124,7 +124,6 @@ Suppose we want to implement a ['lazy load] optimization. This is because we do
 
 `optional`'s default constructor creates an uninitialized optional. No call to `Resource`'s default constructor is attempted. `Resource` doesn't have to be __STD_DEFAULT_CONSTRUCTIBLE__. In function `getResource` we first check if `resource_` is initialized. This time we do not use the contextual conversion to `bool`, but a comparison with `boost::none`. These two ways are equivalent. Function `emplace` initializes the optional in-place by perfect-forwarding the arguments to the constructor of `Resource`. No copy- or move-construction is involved here. `Resource` doesn't even have to be `MoveConstructible`.
 
-[note Function `emplace` is only available on compilers that support rvalue references and variadic templates. If your compiler does not support these features and you still need to avoid any move-constructions, use [link boost_optional.design.in_place_factories In-Place Factories].]
 
 [endsect]
 

doc/17_in_place_factories.qbk

@@ -136,4 +136,6 @@ In-place factories can be used generically by the wrapper and user as follows:
 
 The factories are implemented in the headers: __IN_PLACE_FACTORY_HPP__ and __TYPED_IN_PLACE_FACTORY_HPP__
 
+[caution The support for in-place factories is deprecated. Use constructor taking `in_place_init` tag and function `.emplace()` instead.]
+
 [endsect]

doc/27_ref_optional_synopsis.qbk

@@ -95,10 +95,10 @@
     namespace boost {
 
     class in_place_init_t { /* see below */ } ;
-    const in_place_init_t in_place_init ( /* see below */ ) ;
+    inline constexpr in_place_init_t in_place_init ( /* see below */ ) ;
 
     class in_place_init_if_t { /*see below*/ } ;
-    const in_place_init_if_t in_place_init_if ( /*see below*/ ) ;
+    inline constexpr  in_place_init_if_t in_place_init_if ( /*see below*/ ) ;
 
     }
 
@@ -123,33 +123,33 @@ They are empty, trivially copyable classes with disabled default constructor.
         typedef T *       pointer_type ;
         typedef T const*  pointer_const_type ;
 
-        optional () noexcept ; ``[link reference_optional_constructor __GO_TO__]``
+        constexpr optional () noexcept ; ``[link reference_optional_constructor __GO_TO__]``
 
-        optional ( none_t ) noexcept ; ``[link reference_optional_constructor_none_t __GO_TO__]``
+        constexpr optional ( none_t ) noexcept ; ``[link reference_optional_constructor_none_t __GO_TO__]``
 
-        optional ( T const& v ) ; ``[link reference_optional_constructor_value __GO_TO__]``
+        constexpr optional ( T const& v ) ; ``[link reference_optional_constructor_value __GO_TO__]``
 
-        optional ( T&& v ) ; ``[link reference_optional_constructor_move_value __GO_TO__]``
+        constexpr optional ( T&& v ) ; ``[link reference_optional_constructor_move_value __GO_TO__]``
 
-        optional ( bool condition, T const& v ) ; ``[link reference_optional_constructor_bool_value __GO_TO__]``
+        constexpr optional ( bool condition, T const& v ) ; ``[link reference_optional_constructor_bool_value __GO_TO__]``
 
-        optional ( optional const& rhs ) ; ``[link reference_optional_constructor_optional __GO_TO__]``
+        constexpr optional ( optional const& rhs ) ; ``[link reference_optional_constructor_optional __GO_TO__]``
 
-        optional ( optional&& rhs ) noexcept(``['see below]``) ; ``[link reference_optional_move_constructor_optional __GO_TO__]``
+        constexpr optional ( optional&& rhs ) noexcept(``['see below]``) ; ``[link reference_optional_move_constructor_optional __GO_TO__]``
 
-        template<class U> explicit optional ( optional<U> const& rhs ) ; ``[link reference_optional_constructor_other_optional __GO_TO__]``
+        template<class U> constexpr explicit optional ( optional<U> const& rhs ) ; ``[link reference_optional_constructor_other_optional __GO_TO__]``
 
-        template<class U> explicit optional ( optional<U>&& rhs ) ; ``[link reference_optional_move_constructor_other_optional __GO_TO__]``
+        template<class U> constexpr explicit optional ( optional<U>&& rhs ) ; ``[link reference_optional_move_constructor_other_optional __GO_TO__]``
 
-        template<class... Args> explicit optional ( in_place_init_t, Args&&... args ) ; ``[link reference_optional_in_place_init __GO_TO__]``
+        template<class... Args> constexpr explicit optional ( in_place_init_t, Args&&... args ) ; ``[link reference_optional_in_place_init __GO_TO__]``
 
-        template<class... Args> explicit optional ( in_place_init_if_t, bool condition, Args&&... args ) ; ``[link reference_optional_in_place_init_if __GO_TO__]``
+        template<class... Args> constexpr explicit optional ( in_place_init_if_t, bool condition, Args&&... args ) ; ``[link reference_optional_in_place_init_if __GO_TO__]``
 
         template<class InPlaceFactory> explicit optional ( InPlaceFactory const& f ) ; ``[link reference_optional_constructor_factory __GO_TO__]``
 
         template<class TypedInPlaceFactory> explicit optional ( TypedInPlaceFactory const& f ) ; ``[link reference_optional_constructor_factory __GO_TO__]``
 
-        optional& operator = ( none_t ) noexcept ; ``[link reference_optional_operator_equal_none_t __GO_TO__]``
+        constexpr optional& operator = ( none_t ) noexcept ; ``[link reference_optional_operator_equal_none_t __GO_TO__]``
 
         optional& operator = ( T const& v ) ; ``[link reference_optional_operator_equal_value __GO_TO__]``
 
@@ -169,52 +169,50 @@ They are empty, trivially copyable classes with disabled default constructor.
 
         template<class TypedInPlaceFactory> optional& operator = ( TypedInPlaceFactory const& f ) ; ``[link reference_optional_operator_equal_factory __GO_TO__]``
 
-        T const& get() const ; ``[link reference_optional_get __GO_TO__]``
-        T&       get() ; ``[link reference_optional_get __GO_TO__]``
+        constexpr T const& get() const ; ``[link reference_optional_get __GO_TO__]``
+        constexpr T&       get() ; ``[link reference_optional_get __GO_TO__]``
 
-        T const* operator ->() const ; ``[link reference_optional_operator_arrow __GO_TO__]``
-        T*       operator ->() ; ``[link reference_optional_operator_arrow __GO_TO__]``
+        constexpr T const* operator ->() const ; ``[link reference_optional_operator_arrow __GO_TO__]``
+        constexpr T*       operator ->() ; ``[link reference_optional_operator_arrow __GO_TO__]``
 
-        T const& operator *() const& ; ``[link reference_optional_operator_asterisk __GO_TO__]``
-        T&       operator *() & ; ``[link reference_optional_operator_asterisk __GO_TO__]``
-        T&&      operator *() && ; ``[link reference_optional_operator_asterisk_move __GO_TO__]``
+        constexpr T const& operator *() const& ; ``[link reference_optional_operator_asterisk __GO_TO__]``
+        constexpr T&       operator *() & ; ``[link reference_optional_operator_asterisk __GO_TO__]``
+        constexpr T&&      operator *() && ; ``[link reference_optional_operator_asterisk_move __GO_TO__]``
 
-        T const& value() const& ; ``[link reference_optional_value __GO_TO__]``
-        T&       value() & ; ``[link reference_optional_value __GO_TO__]``
-        T&&      value() && ; ``[link reference_optional_value_move __GO_TO__]``
+        constexpr T const& value() const& ; ``[link reference_optional_value __GO_TO__]``
+        constexpr T&       value() & ; ``[link reference_optional_value __GO_TO__]``
+        constexpr T&&      value() && ; ``[link reference_optional_value_move __GO_TO__]``
 
-        template<class U> T value_or( U && v ) const& ; ``[link reference_optional_value_or __GO_TO__]``
-        template<class U> T value_or( U && v ) && ; ``[link reference_optional_value_or_move __GO_TO__]``
+        template<class U> constexpr T value_or( U && v ) const& ; ``[link reference_optional_value_or __GO_TO__]``
+        template<class U> constexpr T value_or( U && v ) && ; ``[link reference_optional_value_or_move __GO_TO__]``
 
-        template<class F> T value_or_eval( F f ) const& ; ``[link reference_optional_value_or_call __GO_TO__]``
-        template<class F> T value_or_eval( F f ) && ; ``[link reference_optional_value_or_call_move __GO_TO__]``
+        template<class F> constexpr T value_or_eval( F f ) const& ; ``[link reference_optional_value_or_call __GO_TO__]``
+        template<class F> constexpr T value_or_eval( F f ) && ; ``[link reference_optional_value_or_call_move __GO_TO__]``
 
-        template<class F> auto map( F f ) const& -> ``['see below]``; ``[link reference_optional_map __GO_TO__]``
-        template<class F> auto map( F f ) & -> ``['see below]``; ``[link reference_optional_map __GO_TO__]``
-        template<class F> auto map( F f ) && -> ``['see below]``; ``[link reference_optional_map_move __GO_TO__]``
+        template<class F> constexpr auto map( F f ) const& -> ``['see below]``; ``[link reference_optional_map __GO_TO__]``
+        template<class F> constexpr auto map( F f ) & -> ``['see below]``; ``[link reference_optional_map __GO_TO__]``
+        template<class F> constexpr auto map( F f ) && -> ``['see below]``; ``[link reference_optional_map_move __GO_TO__]``
 
-        template<class F> auto flat_map( F f ) const& -> ``['see below]``; ``[link reference_optional_flat_map __GO_TO__]``
-        template<class F> auto flat_map( F f ) & -> ``['see below]``; ``[link reference_optional_flat_map __GO_TO__]``
-        template<class F> auto flat_map( F f ) && -> ``['see below]``; ``[link reference_optional_flat_map_move __GO_TO__]``
+        template<class F> constexpr auto flat_map( F f ) const& -> ``['see below]``; ``[link reference_optional_flat_map __GO_TO__]``
+        template<class F> constexpr auto flat_map( F f ) & -> ``['see below]``; ``[link reference_optional_flat_map __GO_TO__]``
+        template<class F> constexpr auto flat_map( F f ) && -> ``['see below]``; ``[link reference_optional_flat_map_move __GO_TO__]``
 
         T const* get_ptr() const ; ``[link reference_optional_get_ptr __GO_TO__]``
         T*       get_ptr() ; ``[link reference_optional_get_ptr __GO_TO__]``
 
-        bool has_value() const noexcept ; ``[link reference_optional_operator_bool __GO_TO__]``
-
-        explicit operator bool() const noexcept ; ``[link reference_optional_operator_bool __GO_TO__]``
+        constexpr bool has_value() const noexcept ; ``[link reference_optional_operator_bool __GO_TO__]``
 
-        bool operator!() const noexcept ; ``[link reference_optional_operator_not __GO_TO__]``
+        constexpr explicit operator bool() const noexcept ; ``[link reference_optional_operator_bool __GO_TO__]``
 
-        void reset() noexcept ; ``[link reference_optional_reset __GO_TO__]``
+        constexpr void reset() noexcept ; ``[link reference_optional_reset __GO_TO__]``
 
         // deprecated methods
 
         // (deprecated)
         void reset ( T const& ) ; ``[link reference_optional_reset_value __GO_TO__]``
 
         // (deprecated)
-        bool is_initialized() const ; ``[link reference_optional_is_initialized __GO_TO__]``
+        constexpr bool is_initialized() const ; ``[link reference_optional_is_initialized __GO_TO__]``
 
         // (deprecated)
         T const& get_value_or( T const& default ) const ; ``[link reference_optional_get_value_or_value __GO_TO__]``
@@ -239,9 +237,9 @@ They are empty, trivially copyable classes with disabled default constructor.
         typedef T* pointer_type;
         typedef T* pointer_const_type;   // no const propagation
 
-        optional () noexcept ; ``[link reference_optional_ref_default_ctor __GO_TO__]``
+        constexpr optional () noexcept ; ``[link reference_optional_ref_default_ctor __GO_TO__]``
 
-        optional ( none_t ) noexcept ; ``[link reference_optional_ref_default_ctor __GO_TO__]``
+        constexpr optional ( none_t ) noexcept ; ``[link reference_optional_ref_default_ctor __GO_TO__]``
 
         template<class R> optional(R&& r) noexcept ;  ``[link reference_optional_ref_value_ctor __GO_TO__]``