passenger 6.2.1 → 6.2.2

data/src/cxx_supportlib/vendor-modified/boost/none_t.hpp

@@ -25,7 +25,7 @@
 
 #elif defined(BOOST_NO_CXX11_REF_QUALIFIERS) || defined(BOOST_NO_CXX11_NOEXCEPT) || defined(BOOST_NO_CXX11_DEFAULTED_MOVES)
 
-BOOST_PRAGMA_MESSAGE("C++03 support is deprecated in Boost.Optional 1.83 and will be removed in Boost.Optional 1.88.")
+BOOST_PRAGMA_MESSAGE("C++03 support is deprecated in Boost.Optional 1.83 and will be removed in Boost.Optional 1.92.")
 
 #endif
 
@@ -46,6 +46,11 @@ struct none_t
 {
   struct init_tag{};
   explicit BOOST_CONSTEXPR none_t(init_tag){} // to disable default constructor
+
+#ifndef BOOST_OPTIONAL_DISABLE_EQUALITY_FOR_NONE
+  friend BOOST_CONSTEXPR bool operator==(none_t, none_t) { return true; }
+  friend BOOST_CONSTEXPR bool operator!=(none_t, none_t) { return false; }
+#endif
 };
 
 #endif // old implementation workarounds

data/src/cxx_supportlib/vendor-modified/boost/optional/detail/optional_common_defs.hpp

@@ -0,0 +1,188 @@
+// Copyright (C) 2024 Ryan Malcolm Underwood.
+// Copyright (C) 2026 Andrzej Krzemieński.
+//
+// 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 authors at:
+//  akrzemi1@gmail.com
+//  typenametea@gmail.com
+//
+//
+// This header provides definitions required by any specialization of
+// optional<>.
+
+#ifndef BOOST_OPTIONAL_DETAIL_OPTIONAL_COMMON_DEFS_01FEB2026_HPP
+#define BOOST_OPTIONAL_DETAIL_OPTIONAL_COMMON_DEFS_01FEB2026_HPP
+
+
+#include <boost/config.hpp>
+#include <boost/core/addressof.hpp>
+#include <type_traits>
+#include <boost/optional/detail/optional_factory_support.hpp>
+
+#ifndef BOOST_OPTIONAL_USES_UNION_IMPLEMENTATION
+#include <boost/type_traits/decay.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+#endif
+
+// This is needed for C++11, where constexpr functions must contain a single expression.
+// We want to assert and then return.
+#if defined NDEBUG
+# define BOOST_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR) (EXPR)
+#else
+# define BOOST_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR) ((CHECK) ? (EXPR) : ([]{BOOST_ASSERT(!(#CHECK));}(), (EXPR)))
+#endif
+
+#ifdef BOOST_OPTIONAL_USES_UNION_IMPLEMENTATION
+# define BOOST_OPTIONAL_DECAY(T) typename ::std::decay<T>::type
+# define BOOST_OPTIONAL_IS_TAGGED(TAG, U) ::std::is_base_of<TAG, BOOST_OPTIONAL_DECAY(U)>
+#else
+# define BOOST_OPTIONAL_DECAY(T) BOOST_DEDUCED_TYPENAME boost::decay<T>::type
+# define BOOST_OPTIONAL_IS_TAGGED(TAG, U) boost::is_base_of<TAG, BOOST_OPTIONAL_DECAY(U)>
+#endif
+
+namespace boost {
+
+template <typename T> class optional;
+
+
+// Boost-wide tags for recognizing "factories": a C++03 workaround
+// for perfect forwarding.
+class in_place_factory_base;
+class typed_in_place_factory_base;
+
+} // namespace boost
+
+
+// Traits for recognizing in-place factories
+namespace boost { namespace optional_detail {
+
+template <typename U>
+struct is_in_place_factory : BOOST_OPTIONAL_IS_TAGGED(boost::in_place_factory_base, U) {};
+
+template <typename U>
+struct is_typed_in_place_factory : BOOST_OPTIONAL_IS_TAGGED(boost::typed_in_place_factory_base, U) {};
+
+}}
+
+
+
+/** This is a set of declarations that repeat those from the Standard Library
+    header <utility> but without having to drag its entire content. They also
+    add missing capabilities, like constexpr, in older compiler versions.
+ */
+namespace boost { namespace optional_detail {
+
+template <typename T>
+T declval_();
+
+template <class T>
+inline constexpr T&& forward_(typename ::std::remove_reference<T>::type& t) noexcept
+{
+  return static_cast<T&&>(t);
+}
+
+template <class T>
+inline constexpr T&& forward_(typename ::std::remove_reference<T>::type&& t) noexcept
+{
+  static_assert(!::std::is_lvalue_reference<T>::value, "Can not forward an rvalue as an lvalue.");
+  return static_cast<T&&>(t);
+}
+
+template <class T>
+inline constexpr typename ::std::remove_reference<T>::type&& move_(T&& t) noexcept
+{
+  return static_cast<typename ::std::remove_reference<T>::type&&>(t);
+}
+
+}} // namespace boost::optional_detail
+
+
+/** This is a set of declarations that are not part of this library's interface.
+    They are implementation details.
+ */
+namespace boost { namespace optional_detail {
+
+/** This struct is used for tagging types that want to be recognized as
+    `optional`. If your class inherits directly or indirectly from `optional_tag`
+    the type traits and overloads will treat it as `optional<>`.
+ */
+struct optional_tag {};
+
+/** `optional_value_type`: given type `X`:
+    * if `X` is an instance of `boost::optional`, returns its value_type,
+    * otherwise we get a SFINAE-able error.
+ */
+template <typename X>
+struct optional_value_type
+{
+};
+
+template <typename U>
+struct optional_value_type< ::boost::optional<U> >
+{
+  typedef U type;
+};
+
+
+/** This is an approximation of a 1-argument C++17 std::invoke_result.
+ */
+template <typename F, typename Ref, typename Rslt = decltype(declval_<F>()(declval_<Ref>()))>
+struct result_of
+{
+  typedef Rslt type;
+};
+
+/** This type trait returns the following given the expression `f(ref)`:
+     * if the result is a specialization of `boost::optional`: its value_type,
+     * otherwise a SFINAE-able error.
+ */
+template <typename F, typename Ref, typename Rslt = typename optional_value_type<typename result_of<F, Ref>::type>::type>
+struct result_value_type
+{
+  typedef Rslt type;
+};
+
+}} // namespace boost::optional_detail
+
+
+/** The following two tags are intended to be used by library users.
+    The additional namespace is used in order to prevent the ADL from
+    dragging all functions from namespace `boost` in any unqualified name lookup
+    when these tags are involved.
+ */
+namespace boost {
+
+namespace optional_ns {
+
+/// a tag for in-place initialization of contained value
+struct in_place_init_t
+{
+  struct init_tag{};
+  BOOST_CONSTEXPR explicit in_place_init_t(init_tag){}
+};
+BOOST_INLINE_CONSTEXPR in_place_init_t in_place_init ((in_place_init_t::init_tag()));
+
+/// a tag for conditional in-place initialization of contained value
+struct in_place_init_if_t
+{
+  struct init_tag{};
+  BOOST_CONSTEXPR explicit in_place_init_if_t(init_tag){}
+};
+BOOST_INLINE_CONSTEXPR in_place_init_if_t in_place_init_if ((in_place_init_if_t::init_tag()));
+
+} // namespace optional_ns
+
+using optional_ns::in_place_init_t;
+using optional_ns::in_place_init;
+using optional_ns::in_place_init_if_t;
+using optional_ns::in_place_init_if;
+
+} // namespace boost
+
+
+#endif // BOOST_OPTIONAL_DETAIL_OPTIONAL_COMMON_DEFS_01FEB2026_HPP

data/src/cxx_supportlib/vendor-modified/boost/optional/detail/optional_factory_support.hpp

@@ -27,10 +27,4 @@ namespace boost_optional_detail
   }
 }
 
-namespace boost
-{
-  class in_place_factory_base ;
-  class typed_in_place_factory_base ;
-}
-
 #endif // header guard

data/src/cxx_supportlib/vendor-modified/boost/optional/detail/optional_hash.hpp

@@ -12,7 +12,7 @@
 #ifndef BOOST_OPTIONAL_DETAIL_OPTIONAL_HASH_AJK_20MAY2022_HPP
 #define BOOST_OPTIONAL_DETAIL_OPTIONAL_HASH_AJK_20MAY2022_HPP
 
-#include <boost/optional/optional_fwd.hpp>
+//#include <boost/optional/optional_fwd.hpp>
 #include <boost/config.hpp>
 
 #if !defined(BOOST_OPTIONAL_CONFIG_DO_NOT_SPECIALIZE_STD_HASH) && !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)

data/src/cxx_supportlib/vendor-modified/boost/optional/detail/optional_nonmember_interface.hpp

@@ -0,0 +1,117 @@
+// Copyright (C) 2003, 2008 Fernando Luis Cacciola Carballal.
+// Copyright (C) 2014 - 2026 Andrzej Krzemieński.
+//
+// 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 authors at:
+//  fernando_cacciola@hotmail.com
+//  akrzemi1@gmail.com
+//
+// You can file a GitHub issue  at:
+//  https://github.com/boostorg/optional/issues
+
+
+// This header provides definitions rof nonmember functions that still constitute
+// the interface for class optional<>.
+
+#ifndef BOOST_OPTIONAL_DETAIL_OPTIONAL_NONMEMBER_INTERFACE_01FEB2026_HPP
+#define BOOST_OPTIONAL_DETAIL_OPTIONAL_NONMEMBER_INTERFACE_01FEB2026_HPP
+
+namespace boost {
+
+
+template <class T>
+inline BOOST_CXX14_CONSTEXPR
+optional<BOOST_OPTIONAL_DECAY(T)> make_optional ( T && v  )
+{
+  return optional<BOOST_OPTIONAL_DECAY(T)>(optional_detail::forward_<T>(v));
+}
+
+// Returns optional<T>(cond,v)
+template <class T>
+inline BOOST_CXX14_CONSTEXPR
+optional<BOOST_OPTIONAL_DECAY(T)> make_optional ( bool cond, T && v )
+{
+  return optional<BOOST_OPTIONAL_DECAY(T)>(cond,optional_detail::forward_<T>(v));
+}
+
+
+// Returns a reference to the value if this is initialized, otherwise, the behaviour is UNDEFINED.
+// No-throw
+template <class T>
+inline BOOST_CXX14_CONSTEXPR
+BOOST_DEDUCED_TYPENAME optional<T>::reference_const_type
+get ( optional<T> const& opt )
+{
+  return opt.get() ;
+}
+
+template <class T>
+inline BOOST_CXX14_CONSTEXPR
+BOOST_DEDUCED_TYPENAME optional<T>::reference_type
+get ( optional<T>& opt )
+{
+  return opt.get() ;
+}
+
+// Returns a pointer to the value if this is initialized, otherwise, returns NULL.
+// No-throw
+template<class T>
+inline BOOST_CXX14_CONSTEXPR
+BOOST_DEDUCED_TYPENAME optional<T>::pointer_const_type
+get ( optional<T> const* opt )
+{
+  return opt->get_ptr() ;
+}
+
+template<class T>
+inline BOOST_CXX14_CONSTEXPR
+BOOST_DEDUCED_TYPENAME optional<T>::pointer_type
+get ( optional<T>* opt )
+{
+  return opt->get_ptr() ;
+}
+
+// Returns a reference to the value if this is initialized, otherwise, the behaviour is UNDEFINED.
+// No-throw
+template<class T>
+inline BOOST_CXX14_CONSTEXPR
+BOOST_DEDUCED_TYPENAME optional<T>::reference_const_type
+get_optional_value_or ( optional<T> const& opt, BOOST_DEDUCED_TYPENAME optional<T>::reference_const_type v )
+{
+  return opt.get_value_or(v) ;
+}
+
+template<class T>
+inline BOOST_CXX14_CONSTEXPR
+BOOST_DEDUCED_TYPENAME optional<T>::reference_type
+get_optional_value_or ( optional<T>& opt, BOOST_DEDUCED_TYPENAME optional<T>::reference_type v )
+{
+  return opt.get_value_or(v) ;
+}
+
+// Returns a pointer to the value if this is initialized, otherwise, returns NULL.
+// No-throw
+template<class T>
+inline BOOST_CXX14_CONSTEXPR
+BOOST_DEDUCED_TYPENAME optional<T>::pointer_const_type
+get_pointer ( optional<T> const& opt )
+{
+  return opt.get_ptr() ;
+}
+
+template<class T>
+inline BOOST_CXX14_CONSTEXPR
+BOOST_DEDUCED_TYPENAME optional<T>::pointer_type
+get_pointer ( optional<T>& opt )
+{
+  return opt.get_ptr() ;
+}
+
+} // namespace boost
+
+#endif // BOOST_OPTIONAL_DETAIL_OPTIONAL_NONMEMBER_INTERFACE_01FEB2026_HPP

data/src/cxx_supportlib/vendor-modified/boost/optional/detail/optional_reference_spec.hpp

@@ -13,9 +13,21 @@
 #define BOOST_OPTIONAL_DETAIL_OPTIONAL_REFERENCE_SPEC_AJK_03OCT2015_HPP
 
 #ifdef BOOST_OPTIONAL_CONFIG_NO_PROPER_ASSIGN_FROM_CONST_INT
+#ifndef BOOST_OPTIONAL_USES_UNION_IMPLEMENTATION
 #include <boost/type_traits/is_integral.hpp>
 #include <boost/type_traits/is_const.hpp>
 #endif
+#endif
+
+#ifdef BOOST_OPTIONAL_USES_UNION_IMPLEMENTATION
+# define BOOST_OPTIONAL_TT_PREFIX ::std
+#else
+# define BOOST_OPTIONAL_TT_PREFIX boost
+# define BOOST_OPTIONAL_REQUIRES(...) BOOST_DEDUCED_TYPENAME boost::enable_if_c<__VA_ARGS__::value, bool>::type = false
+#endif
+
+# define BOOST_OPTIONAL_TT_TYPE(...) BOOST_DEDUCED_TYPENAME BOOST_OPTIONAL_TT_PREFIX::__VA_ARGS__::type
+# define BOOST_OPTIONAL_TT_PRED(...) BOOST_OPTIONAL_TT_PREFIX::__VA_ARGS__::value
 
 # if 1
 
@@ -29,17 +41,17 @@ template <class From>
 void prevent_binding_rvalue()
 {
 #ifndef BOOST_OPTIONAL_CONFIG_ALLOW_BINDING_TO_RVALUES
-    static_assert(boost::is_lvalue_reference<From>::value,
+    static_assert(BOOST_OPTIONAL_TT_PRED(is_lvalue_reference<From>),
                   "binding rvalue references to optional lvalue references is disallowed");
 #endif
 }
 
 template <class T>
-BOOST_DEDUCED_TYPENAME boost::remove_reference<T>::type& forward_reference(T&& r)
+BOOST_OPTIONAL_TT_TYPE(remove_reference<T>)& forward_reference(T&& r)
 {
-    static_assert(boost::is_lvalue_reference<T>::value,
+    static_assert(BOOST_OPTIONAL_TT_PRED(is_lvalue_reference<T>),
                   "binding rvalue references to optional lvalue references is disallowed");
-    return optional_detail::forward<T>(r);
+    return optional_detail::forward_<T>(r);
 }
 
 #endif // BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
@@ -48,14 +60,14 @@ BOOST_DEDUCED_TYPENAME boost::remove_reference<T>::type& forward_reference(T&& r
 template <class T>
 struct is_const_integral
 {
-  static const bool value = boost::is_const<T>::value && boost::is_integral<T>::value;
+  static const bool value = BOOST_OPTIONAL_TT_PRED(is_const<T>) && BOOST_OPTIONAL_TT_PRED(is_integral<T>);
 };
 
 template <class T>
 struct is_const_integral_bad_for_conversion
 {
 #if (!defined BOOST_OPTIONAL_CONFIG_ALLOW_BINDING_TO_RVALUES) && (defined BOOST_OPTIONAL_CONFIG_NO_PROPER_CONVERT_FROM_CONST_INT)
-  static const bool value = boost::is_const<T>::value && boost::is_integral<T>::value;
+  static const bool value = is_const_integral<T>::value;
 #else
   static const bool value = false;
 #endif
@@ -90,15 +102,15 @@ struct is_optional_< ::boost::optional<U> >
 template <class T>
 struct is_no_optional
 {
-  static const bool value = !is_optional_<BOOST_DEDUCED_TYPENAME boost::decay<T>::type>::value;
+  static const bool value = !is_optional_<BOOST_OPTIONAL_DECAY(T)>::value;
 };
 
 
 template <class T, class U>
   struct is_same_decayed
   {
-    static const bool value = ::boost::is_same<T, BOOST_DEDUCED_TYPENAME ::boost::remove_reference<U>::type>::value
-                           || ::boost::is_same<T, const BOOST_DEDUCED_TYPENAME ::boost::remove_reference<U>::type>::value;
+    static const bool value = BOOST_OPTIONAL_TT_PRED(is_same<T, BOOST_OPTIONAL_TT_TYPE(remove_reference<U>)>)
+                           || BOOST_OPTIONAL_TT_PRED(is_same<T, const BOOST_OPTIONAL_TT_TYPE(remove_reference<U>)>);
   };
 
 template <class T, class U>
@@ -123,152 +135,165 @@ public:
     typedef T* pointer_type;
     typedef T* pointer_const_type;
 
-    optional() BOOST_NOEXCEPT : ptr_() {}
-    optional(none_t) BOOST_NOEXCEPT : ptr_() {}
+    BOOST_CONSTEXPR optional() BOOST_NOEXCEPT : ptr_() {}
+    BOOST_CONSTEXPR optional(none_t) BOOST_NOEXCEPT : ptr_() {}
 
     template <class U>
-        explicit optional(const optional<U&>& rhs) BOOST_NOEXCEPT : ptr_(rhs.get_ptr()) {}
-    optional(const optional& rhs) BOOST_NOEXCEPT : ptr_(rhs.get_ptr()) {}
+    BOOST_CONSTEXPR explicit optional(const optional<U&>& rhs) BOOST_NOEXCEPT : ptr_(rhs.get_ptr()) {}
+    BOOST_CONSTEXPR optional(const optional& rhs) BOOST_NOEXCEPT : ptr_(rhs.get_ptr()) {}
 
     // the following two implement a 'conditionally explicit' constructor: condition is a hack for buggy compilers with screwed conversion construction from const int
+    template <class U,
+              BOOST_OPTIONAL_REQUIRES(detail::is_same_decayed<T, U>),
+              BOOST_OPTIONAL_REQUIRES(detail::is_const_integral_bad_for_conversion<U>)>
+    BOOST_CONSTEXPR explicit
+    optional(U& rhs) BOOST_NOEXCEPT
+    : ptr_(boost::addressof(rhs)) {}
+
+    template <class U,
+              BOOST_OPTIONAL_REQUIRES(detail::is_same_decayed<T, U>),
+              BOOST_OPTIONAL_REQUIRES(!detail::is_const_integral_bad_for_conversion<U>)>
+    BOOST_CONSTEXPR
+    optional(U& rhs) BOOST_NOEXCEPT
+    : ptr_(boost::addressof(rhs)) {}
+
+    BOOST_CXX14_CONSTEXPR optional& operator=(const optional& rhs) BOOST_NOEXCEPT { ptr_ = rhs.get_ptr(); return *this; }
     template <class U>
-      explicit optional(U& rhs, BOOST_DEDUCED_TYPENAME boost::enable_if_c<detail::is_same_decayed<T, U>::value && detail::is_const_integral_bad_for_conversion<U>::value, bool>::type = true) BOOST_NOEXCEPT
-      : ptr_(boost::addressof(rhs)) {}
-
-    template <class U>
-      optional(U& rhs, BOOST_DEDUCED_TYPENAME boost::enable_if_c<detail::is_same_decayed<T, U>::value && !detail::is_const_integral_bad_for_conversion<U>::value, bool>::type = true) BOOST_NOEXCEPT
-      : ptr_(boost::addressof(rhs)) {}
-
-    optional& operator=(const optional& rhs) BOOST_NOEXCEPT { ptr_ = rhs.get_ptr(); return *this; }
-    template <class U>
-        optional& operator=(const optional<U&>& rhs) BOOST_NOEXCEPT { ptr_ = rhs.get_ptr(); return *this; }
-    optional& operator=(none_t) BOOST_NOEXCEPT { ptr_ = 0; return *this; }
+        BOOST_CXX14_CONSTEXPR optional& operator=(const optional<U&>& rhs) BOOST_NOEXCEPT { ptr_ = rhs.get_ptr(); return *this; }
+    BOOST_CXX14_CONSTEXPR 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_; }
+    BOOST_CXX14_CONSTEXPR void swap(optional& rhs) BOOST_NOEXCEPT { ::std::swap(ptr_, rhs.ptr_); }
+    constexpr T& get() const { return BOOST_OPTIONAL_ASSERTED_EXPRESSION(ptr_, *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_; }
+    constexpr T* get_ptr() const BOOST_NOEXCEPT { return ptr_; }
+    constexpr T* operator->() const { return BOOST_OPTIONAL_ASSERTED_EXPRESSION(ptr_, ptr_); }
+    constexpr T& operator*() const { return BOOST_OPTIONAL_ASSERTED_EXPRESSION(ptr_, *ptr_); }
 
-    T& value() const
+    constexpr T& value() const
     {
-      if (this->is_initialized())
-        return this->get();
-      else
-        throw_exception(bad_optional_access());
+      return this->is_initialized() ?
+             this->get() :
+             (boost::throw_exception(boost::bad_optional_access()), this->get());
     }
 
-    explicit operator bool() const BOOST_NOEXCEPT { return ptr_ != 0; }
+    constexpr explicit operator bool() const BOOST_NOEXCEPT { return ptr_ != 0; }
 
-    void reset() BOOST_NOEXCEPT { ptr_ = 0; }
+    BOOST_CXX14_CONSTEXPR void reset() BOOST_NOEXCEPT { ptr_ = 0; }
 
-    bool is_initialized() const BOOST_NOEXCEPT { return ptr_ != 0; }
-    bool has_value() const BOOST_NOEXCEPT { return ptr_ != 0; }
+    constexpr bool is_initialized() const BOOST_NOEXCEPT { return ptr_ != 0; }
+    constexpr bool has_value() const BOOST_NOEXCEPT { return ptr_ != 0; }
 
     template <typename F>
-    optional<typename optional_detail::result_of<F, reference_const_type>::type>
+    constexpr optional<typename optional_detail::result_of<F, reference_const_type>::type>
     map(F f) const
     {
-      if (this->has_value())
-        return f(this->get());
-      else
-        return none;
+      return this->has_value() ?
+             f(get()) :
+             optional<typename optional_detail::result_of<F, reference_const_type>::type>();
     }
 
     template <typename F>
-    optional<typename optional_detail::result_value_type<F, reference_const_type>::type>
+    constexpr optional<typename optional_detail::result_value_type<F, reference_const_type>::type>
     flat_map(F f) const
       {
-        if (this->has_value())
-          return f(get());
-        else
-          return none;
+        return this->has_value() ?
+               f(get()) :
+               optional<typename optional_detail::result_value_type<F, reference_const_type>::type>();
       }
 
 #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
 
     optional(T&& /* rhs */) BOOST_NOEXCEPT { detail::prevent_binding_rvalue<T&&>(); }
 
-    template <class R>
-        optional(R&& r, BOOST_DEDUCED_TYPENAME boost::enable_if<detail::no_unboxing_cond<T, R>, bool>::type = true) BOOST_NOEXCEPT
+    template <class R, BOOST_OPTIONAL_REQUIRES(detail::no_unboxing_cond<T, R>)>
+        BOOST_CXX14_CONSTEXPR optional(R&& r) BOOST_NOEXCEPT
         : ptr_(boost::addressof(r)) { detail::prevent_binding_rvalue<R>(); }
 
-    template <class R>
-        optional(bool cond, R&& r, BOOST_DEDUCED_TYPENAME boost::enable_if<detail::is_no_optional<R>, bool>::type = true) BOOST_NOEXCEPT
+    template <class R, BOOST_OPTIONAL_REQUIRES(detail::is_no_optional<R>)>
+        BOOST_CXX14_CONSTEXPR optional(bool cond, R&& r) BOOST_NOEXCEPT
         : ptr_(cond ? boost::addressof(r) : 0) { detail::prevent_binding_rvalue<R>(); }
 
-    template <class R>
-        BOOST_DEDUCED_TYPENAME boost::enable_if<detail::is_no_optional<R>, optional<T&>&>::type
+    template <class R, BOOST_OPTIONAL_REQUIRES(detail::is_no_optional<R>)>
+        BOOST_CXX14_CONSTEXPR optional<T&>&
         operator=(R&& r) BOOST_NOEXCEPT { detail::prevent_binding_rvalue<R>(); ptr_ = boost::addressof(r); return *this; }
 
-    template <class R>
-        void emplace(R&& r, BOOST_DEDUCED_TYPENAME boost::enable_if<detail::is_no_optional<R>, bool>::type = true) BOOST_NOEXCEPT
+    template <class R, BOOST_OPTIONAL_REQUIRES(detail::is_no_optional<R>)>
+        BOOST_CXX14_CONSTEXPR void emplace(R&& r) BOOST_NOEXCEPT
         { detail::prevent_binding_rvalue<R>(); ptr_ = boost::addressof(r); }
 
-    template <class R>
-      T& get_value_or(R&& r, BOOST_DEDUCED_TYPENAME boost::enable_if<detail::is_no_optional<R>, bool>::type = true) const BOOST_NOEXCEPT
+    template <class R, BOOST_OPTIONAL_REQUIRES(detail::is_no_optional<R>)>
+      BOOST_CXX14_CONSTEXPR T& get_value_or(R&& r) const BOOST_NOEXCEPT
       { detail::prevent_binding_rvalue<R>(); return ptr_ ? *ptr_ : r; }
 
-    template <class R>
-        T& value_or(R&& r, BOOST_DEDUCED_TYPENAME boost::enable_if<detail::is_no_optional<R>, bool>::type = true) const BOOST_NOEXCEPT
+    template <class R, BOOST_OPTIONAL_REQUIRES(detail::is_no_optional<R>)>
+        BOOST_CXX14_CONSTEXPR T& value_or(R&& r) const BOOST_NOEXCEPT
         { detail::prevent_binding_rvalue<R>(); return ptr_ ? *ptr_ : r; }
 
-    template <class R>
-      void reset(R&& r, BOOST_DEDUCED_TYPENAME boost::enable_if<detail::is_no_optional<R>, bool>::type = true) BOOST_NOEXCEPT
+    template <class R, BOOST_OPTIONAL_REQUIRES(detail::is_no_optional<R>)>
+      BOOST_CXX14_CONSTEXPR void reset(R&& r) BOOST_NOEXCEPT
       { detail::prevent_binding_rvalue<R>(); ptr_ = boost::addressof(r); }
 
     template <class F>
-        T& value_or_eval(F f) const { return ptr_ ? *ptr_ : detail::forward_reference(f()); }
+        BOOST_CXX14_CONSTEXPR T& value_or_eval(F f) const { return ptr_ ? *ptr_ : detail::forward_reference(f()); }
 
 #else  // BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
 
 
     // the following two implement a 'conditionally explicit' constructor
-    template <class U>
-      explicit optional(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if_c<detail::no_unboxing_cond<T, U>::value && detail::is_const_integral_bad_for_conversion<U>::value, bool>::type = true) BOOST_NOEXCEPT
+    template <class U,
+              BOOST_OPTIONAL_REQUIRES(detail::no_unboxing_cond<T, U>),
+              BOOST_OPTIONAL_REQUIRES(detail::is_const_integral_bad_for_conversion<U>)>
+      BOOST_CXX14_CONSTEXPR explicit optional(U& v) BOOST_NOEXCEPT
       : ptr_(boost::addressof(v)) { }
 
-    template <class U>
-      optional(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if_c<detail::no_unboxing_cond<T, U>::value && !detail::is_const_integral_bad_for_conversion<U>::value, bool>::type = true) BOOST_NOEXCEPT
+    template <class U,
+              BOOST_OPTIONAL_REQUIRES(detail::no_unboxing_cond<T, U>),
+              BOOST_OPTIONAL_REQUIRES(!detail::is_const_integral_bad_for_conversion<U>)>
+      BOOST_CXX14_CONSTEXPR optional(U& v) BOOST_NOEXCEPT
       : ptr_(boost::addressof(v)) { }
 
-    template <class U>
-      optional(bool cond, U& v, BOOST_DEDUCED_TYPENAME boost::enable_if<detail::is_no_optional<U>, bool>::type = true) BOOST_NOEXCEPT : ptr_(cond ? boost::addressof(v) : 0) {}
+    template <class U,
+              BOOST_OPTIONAL_REQUIRES(detail::is_no_optional<U>)>
+      BOOST_CXX14_CONSTEXPR optional(bool cond, U& v) BOOST_NOEXCEPT : ptr_(cond ? boost::addressof(v) : 0) {}
 
-    template <class U>
-      BOOST_DEDUCED_TYPENAME boost::enable_if<detail::is_no_optional<U>, optional<T&>&>::type
-      operator=(U& v) BOOST_NOEXCEPT
+    template <class U,
+              BOOST_OPTIONAL_REQUIRES(detail::is_no_optional<U>)>
+      BOOST_CXX14_CONSTEXPR
+      optional<T&>& operator=(U& v) BOOST_NOEXCEPT
       {
         detail::prevent_assignment_from_false_const_integral<U>();
         ptr_ = boost::addressof(v); return *this;
       }
 
-    template <class U>
-        void emplace(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if<detail::is_no_optional<U>, bool>::type = true) BOOST_NOEXCEPT
+    template <class U,
+              BOOST_OPTIONAL_REQUIRES(detail::is_no_optional<U>)>
+        BOOST_CXX14_CONSTEXPR void emplace(U& v) BOOST_NOEXCEPT
         { ptr_ = boost::addressof(v); }
 
-    template <class U>
-      T& get_value_or(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if<detail::is_no_optional<U>, bool>::type = true) const BOOST_NOEXCEPT
+    template <class U,
+              BOOST_OPTIONAL_REQUIRES(detail::is_no_optional<U>)>
+      BOOST_CXX14_CONSTEXPR T& get_value_or(U& v) const BOOST_NOEXCEPT
       { return ptr_ ? *ptr_ : v; }
 
-    template <class U>
-        T& value_or(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if<detail::is_no_optional<U>, bool>::type = true) const BOOST_NOEXCEPT
-        { return ptr_ ? *ptr_ : v; }
+    template <class U,
+              BOOST_OPTIONAL_REQUIRES(detail::is_no_optional<U>)>
+      BOOST_CXX14_CONSTEXPR T& value_or(U& v) const BOOST_NOEXCEPT
+      { return ptr_ ? *ptr_ : v; }
 
-    template <class U>
-      void reset(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if<detail::is_no_optional<U>, bool>::type = true) BOOST_NOEXCEPT
+    template <class U,
+              BOOST_OPTIONAL_REQUIRES(detail::is_no_optional<U>)>
+      BOOST_CXX14_CONSTEXPR void reset(U& v) BOOST_NOEXCEPT
       { ptr_ = boost::addressof(v); }
 
     template <class F>
-      T& value_or_eval(F f) const { return ptr_ ? *ptr_ : f(); }
+      BOOST_CXX14_CONSTEXPR T& value_or_eval(F f) const { return ptr_ ? *ptr_ : f(); }
 
 #endif // BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
 };
 
 template <class T>
-  void swap ( optional<T&>& x, optional<T&>& y) BOOST_NOEXCEPT
+  BOOST_CXX14_CONSTEXPR void swap ( optional<T&>& x, optional<T&>& y) BOOST_NOEXCEPT
 {
   x.swap(y);
 }