passenger 6.0.26 → 6.1.0

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

@@ -1,5 +1,5 @@
 // Copyright (C) 2003, Fernando Luis Cacciola Carballal.
-// Copyright (C) 2014, 2015 Andrzej Krzemienski.
+// Copyright (C) 2014, 2024 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
@@ -16,10 +16,16 @@
 #include <boost/config.hpp>
 #include <boost/config/pragma_message.hpp>
 
-#if defined (BOOST_NO_CXX11_RVALUE_REFERENCES) || defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_NO_CXX11_REF_QUALIFIERS) \
-|| defined(BOOST_NO_CXX11_LAMBDAS) || defined(BOOST_NO_CXX11_DECLTYPE_N3276) || defined(BOOST_NO_CXX11_NOEXCEPT) || defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) || defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) || defined(BOOST_NO_CXX11_DEFAULTED_MOVES) || defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
+#if defined (BOOST_NO_CXX11_RVALUE_REFERENCES) || defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) \
+|| defined(BOOST_NO_CXX11_LAMBDAS) || defined(BOOST_NO_CXX11_DECLTYPE_N3276)  \
+|| defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) || defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) \
+|| defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) || defined(BOOST_NO_CXX11_STATIC_ASSERT)
 
-BOOST_PRAGMA_MESSAGE("C++03 support is deprecated in Boost.Optional 1.83 and will be removed in Boost.Optional 1.86.")
+#error "Boost.Optional requires some C++11 features since version 1.87. If you have an older C++ version use Boost.Optional version 1.86 or earlier."
+
+#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.")
 
 #endif
 

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

@@ -12,19 +12,14 @@
 #ifndef BOOST_OPTIONAL_DETAIL_EXPERIMENTAL_TRAITS_04NOV2017_HPP
 #define BOOST_OPTIONAL_DETAIL_EXPERIMENTAL_TRAITS_04NOV2017_HPP
 
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/predef.h>
 #include <boost/type_traits.hpp>
-  
+
 // The condition to use POD implementation
 
 #ifdef BOOST_OPTIONAL_CONFIG_NO_POD_SPEC
 # define BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES
 #elif defined BOOST_OPTIONAL_CONFIG_NO_SPEC_FOR_TRIVIAL_TYPES
 # define BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES
-#elif !defined BOOST_HAS_TRIVIAL_CONSTRUCTOR
-# define BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES
 #elif !defined BOOST_HAS_TRIVIAL_MOVE_ASSIGN
 # define BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES
 #elif !defined BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR
@@ -35,37 +30,14 @@
 # define BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES
 #elif !defined BOOST_HAS_TRIVIAL_DESTRUCTOR
 # define BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES
-#elif BOOST_WORKAROUND(BOOST_GCC, < 50000)
-# define BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES
 #endif
 
-// GCC 5 or higher, or clang with libc++ or clang with libstdc++ 5 or higher
-#if __cplusplus >= 201103L
-#  if BOOST_WORKAROUND(BOOST_GCC, >= 50000)
-#    define BOOST_OPTIONAL_DETAIL_USE_STD_TYPE_TRAITS
-#  elif (defined BOOST_CLANG)
-#    if BOOST_LIB_STD_CXX > 0
-#      define BOOST_OPTIONAL_DETAIL_USE_STD_TYPE_TRAITS
-#    elif BOOST_LIB_STD_GNU >= 441200023 && BOOST_LIB_STD_GNU != 450600023 && BOOST_LIB_STD_GNU != 450600026 && BOOST_LIB_STD_GNU != 460800003 && BOOST_LIB_STD_GNU != 450400026 && BOOST_LIB_STD_GNU != 460700026
-#      define BOOST_OPTIONAL_DETAIL_USE_STD_TYPE_TRAITS
-#    endif
-#  endif
-#endif  
-
 
-#ifndef BOOST_OPTIONAL_DETAIL_USE_STD_TYPE_TRAITS
-#  define BOOST_OPTIONAL_DETAIL_HAS_TRIVIAL_CTOR(T) BOOST_HAS_TRIVIAL_CONSTRUCTOR(T)
-#else
-#  include <type_traits>
-#  define BOOST_OPTIONAL_DETAIL_HAS_TRIVIAL_CTOR(T) std::is_trivially_default_constructible<T>::value
-#endif
-  
-  
 namespace boost { namespace optional_detail {
-  
+
 #ifndef BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES
 template <typename T>
-struct is_type_trivially_copyable
+struct is_trivially_semiregular
   : boost::conditional<(boost::has_trivial_copy_constructor<T>::value &&
                         boost::has_trivial_move_constructor<T>::value &&
                         boost::has_trivial_destructor<T>::value &&
@@ -75,30 +47,13 @@ struct is_type_trivially_copyable
 {};
 #else
 template <typename T>
-struct is_type_trivially_copyable
+struct is_trivially_semiregular
 : boost::conditional<(boost::is_scalar<T>::value && !boost::is_const<T>::value && !boost::is_volatile<T>::value),
                      boost::true_type, boost::false_type>::type
 {};
 #endif
 
 
-
-#ifndef BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES  
-template <typename T>
-struct optional_uses_direct_storage_for_
-  : boost::conditional< (is_type_trivially_copyable<T>::value && BOOST_OPTIONAL_DETAIL_HAS_TRIVIAL_CTOR(T)) ||
-                        (boost::is_scalar<T>::value && !boost::is_const<T>::value && !boost::is_volatile<T>::value)
-                      , boost::true_type, boost::false_type>::type
-{};
-#else
-template <typename T>
-struct optional_uses_direct_storage_for_
-  : boost::conditional<(boost::is_scalar<T>::value && !boost::is_const<T>::value && !boost::is_volatile<T>::value)
-                      , boost::true_type, boost::false_type>::type
-{};
-#endif
-
-
 }} // boost::optional_detail
 
 #endif

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

@@ -60,9 +60,8 @@ class aligned_storage
     T *      ptr_ref()       { return static_cast<T *>     (address()); }
 #endif
 
-    T const& ref() const { return *ptr_ref(); }
-    T &      ref()       { return *ptr_ref(); }
-  
+    T const& ref() const { return *boost::core::launder(ptr_ref()); }
+    T &      ref()       { return *boost::core::launder(ptr_ref()); }
 } ;
 
 } // namespace optional_detail

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

@@ -14,9 +14,9 @@
 #define BOOST_OPTIONAL_DETAIL_OPTIONAL_CONFIG_AJK_28JAN2015_HPP
 
 #include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/config/workaround.hpp>
 
-#if (defined BOOST_NO_CXX11_RVALUE_REFERENCES) || (defined BOOST_OPTIONAL_CONFIG_NO_RVALUE_REFERENCES)
+#if (defined BOOST_OPTIONAL_CONFIG_NO_RVALUE_REFERENCES)
 # define BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
 #endif
 
@@ -55,7 +55,7 @@
 #if (defined(_MSC_VER) && _MSC_VER <= 1800)
 // on MSVC 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. 
+// to a temporary.
 # define BOOST_OPTIONAL_CONFIG_NO_PROPER_ASSIGN_FROM_CONST_INT
 #endif
 
@@ -82,7 +82,7 @@
 
 #endif // defined(__GNUC__)
 
-#if (defined __GNUC__) && (!defined BOOST_NO_CXX11_RVALUE_REFERENCES)
+#if (defined __GNUC__)
 // On some initial rvalue reference implementations GCC does it in a strange way,
 // preferring perfect-forwarding constructor to implicit copy constructor.
 
@@ -132,4 +132,13 @@
 #endif
 
 
+#ifdef BOOST_NO_CXX11_REF_QUALIFIERS
+# define BOOST_OPTIONAL_CONST_REF_QUAL const
+# define BOOST_OPTIONAL_REF_QUAL
+#else
+# define BOOST_OPTIONAL_CONST_REF_QUAL const&
+# define BOOST_OPTIONAL_REF_QUAL &
+#endif
+
+
 #endif // header guard

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

@@ -1,4 +1,4 @@
-// Copyright (C) 2015-2018 Andrzej Krzemienski.
+// Copyright (C) 2015-2024 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,17 +29,17 @@ template <class From>
 void prevent_binding_rvalue()
 {
 #ifndef BOOST_OPTIONAL_CONFIG_ALLOW_BINDING_TO_RVALUES
-    BOOST_STATIC_ASSERT_MSG(boost::is_lvalue_reference<From>::value, 
-                            "binding rvalue references to optional lvalue references is disallowed");
-#endif    
+    static_assert(boost::is_lvalue_reference<From>::value,
+                  "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_STATIC_ASSERT_MSG(boost::is_lvalue_reference<T>::value, 
-                            "binding rvalue references to optional lvalue references is disallowed");
-    return boost::forward<T>(r);
+    static_assert(boost::is_lvalue_reference<T>::value,
+                  "binding rvalue references to optional lvalue references is disallowed");
+    return optional_detail::forward<T>(r);
 }
 
 #endif // BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
@@ -68,10 +68,10 @@ void prevent_assignment_from_false_const_integral()
 #ifdef BOOST_OPTIONAL_CONFIG_NO_PROPER_ASSIGN_FROM_CONST_INT
     // MSVC compiler without rvalue references: we need to disable the assignment from
     // const integral lvalue reference, as it may be an invalid temporary
-    BOOST_STATIC_ASSERT_MSG(!is_const_integral<From>::value, 
-                            "binding const lvalue references to integral types is disabled in this compiler");
+    static_assert(!is_const_integral<From>::value,
+                  "binding const lvalue references to integral types is disabled in this compiler");
+#endif
 #endif
-#endif   
 }
 
 
@@ -114,7 +114,7 @@ template <class T>
 class optional<T&> : public optional_detail::optional_tag
 {
     T* ptr_;
-    
+
 public:
     typedef T& value_type;
     typedef T& reference_type;
@@ -122,19 +122,19 @@ public:
     typedef T& rval_reference_type;
     typedef T* pointer_type;
     typedef T* pointer_const_type;
-    
+
     optional() BOOST_NOEXCEPT : ptr_() {}
-    optional(none_t) BOOST_NOEXCEPT : ptr_() {}  
+    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()) {}
-    
+
     // 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>
       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)) {}
@@ -143,15 +143,15 @@ public:
     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; }
-    
-    
+
+
     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
     {
       if (this->is_initialized())
@@ -159,17 +159,17 @@ public:
       else
         throw_exception(bad_optional_access());
     }
-    
-    bool operator!() const BOOST_NOEXCEPT { return ptr_ == 0; }  
-    BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()
-      
+
+    explicit operator bool() const BOOST_NOEXCEPT { return ptr_ != 0; }
+
     void reset() BOOST_NOEXCEPT { ptr_ = 0; }
 
     bool is_initialized() const BOOST_NOEXCEPT { return ptr_ != 0; }
     bool has_value() const BOOST_NOEXCEPT { return ptr_ != 0; }
-    
+
     template <typename F>
-    optional<typename boost::result_of<F(T&)>::type> map(F f) const
+    optional<typename optional_detail::result_of<F, reference_const_type>::type>
+    map(F f) const
     {
       if (this->has_value())
         return f(this->get());
@@ -178,61 +178,62 @@ public:
     }
 
     template <typename F>
-    optional<typename optional_detail::optional_value_type<typename boost::result_of<F(T&)>::type>::type> flat_map(F f) const
+    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;
       }
-    
-#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES   
- 
+
+#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
         : 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
         : 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
         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
         { 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
       { 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
         { 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
       { 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()); }
-      
+
 #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
       : 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
       : 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) {}
 
@@ -247,26 +248,26 @@ public:
     template <class U>
         void emplace(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if<detail::is_no_optional<U>, bool>::type = true) 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
       { 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>
       void reset(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if<detail::is_no_optional<U>, bool>::type = true) BOOST_NOEXCEPT
       { ptr_ = boost::addressof(v); }
-      
+
     template <class F>
       T& value_or_eval(F f) const { return ptr_ ? *ptr_ : f(); }
-      
+
 #endif // BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
 };
 
-template <class T> 
+template <class T>
   void swap ( optional<T&>& x, optional<T&>& y) BOOST_NOEXCEPT
 {
   x.swap(y);

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

@@ -1,5 +1,5 @@
 // Copyright (C) 2003, 2008 Fernando Luis Cacciola Carballal.
-// Copyright (C) 2015 Andrzej Krzemienski.
+// Copyright (C) 2015, 2024 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
@@ -16,7 +16,8 @@
 namespace boost {
 
 // optional's relational operators ( ==, !=, <, >, <=, >= ) have deep-semantics (compare values).
-// WARNING: This is UNLIKE pointers. Use equal_pointees()/less_pointees() in generic code instead.
+// WARNING: This is UNLIKE pointers. Use equal_pointees()/less_pointees() in generic code instead,
+// to obtain the same semantic for pointers.
 
 
 //
@@ -31,7 +32,7 @@ bool operator == ( optional<T> const& x, optional<T> const& y )
 template<class T>
 inline
 bool operator < ( optional<T> const& x, optional<T> const& y )
-{ return less_pointees(x,y); }
+{ return !y ? false : (!x ? true : (*x) < (*y)); }
 
 template<class T>
 inline
@@ -60,12 +61,12 @@ bool operator >= ( optional<T> const& x, optional<T> const& y )
 template<class T>
 inline
 bool operator == ( optional<T> const& x, T const& y )
-{ return equal_pointees(x, optional<T>(y)); }
+{ return x && (*x == y); }
 
 template<class T>
 inline
 bool operator < ( optional<T> const& x, T const& y )
-{ return less_pointees(x, optional<T>(y)); }
+{ return (!x) || (*x < y); }
 
 template<class T>
 inline
@@ -94,12 +95,12 @@ bool operator >= ( optional<T> const& x, T const& y )
 template<class T>
 inline
 bool operator == ( T const& x, optional<T> const& y )
-{ return equal_pointees( optional<T>(x), y ); }
+{ return y && (x == *y); }
 
 template<class T>
 inline
 bool operator < ( T const& x, optional<T> const& y )
-{ return less_pointees( optional<T>(x), y ); }
+{ return y && (x < *y); }
 
 template<class T>
 inline
@@ -133,8 +134,8 @@ bool operator == ( optional<T> const& x, none_t ) BOOST_NOEXCEPT
 
 template<class T>
 inline
-bool operator < ( optional<T> const& x, none_t )
-{ return less_pointees(x,optional<T>() ); }
+bool operator < ( optional<T> const&, none_t )
+{ return false; }
 
 template<class T>
 inline
@@ -168,7 +169,7 @@ bool operator == ( none_t , optional<T> const& y ) BOOST_NOEXCEPT
 template<class T>
 inline
 bool operator < ( none_t , optional<T> const& y )
-{ return less_pointees(optional<T>() ,y); }
+{ return bool(y); }
 
 template<class T>
 inline
@@ -193,4 +194,3 @@ bool operator >= ( none_t x, optional<T> const& y )
 } // namespace boost
 
 #endif // header guard
-

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

@@ -54,7 +54,7 @@ struct swap_selector<true>
 #endif
 
 #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
-# define BOOST_OPTIONAL_DETAIL_MOVE(EXPR_) boost::move(EXPR_)
+# define BOOST_OPTIONAL_DETAIL_MOVE(EXPR_) optional_detail::move(EXPR_)
 #else
 # define BOOST_OPTIONAL_DETAIL_MOVE(EXPR_) EXPR_
 #endif
@@ -63,7 +63,7 @@ template <>
 struct swap_selector<false>
 {
     template <class T>
-    static void optional_swap ( optional<T>& x, optional<T>& y ) 
+    static void optional_swap ( optional<T>& x, optional<T>& y )
     //BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value && BOOST_NOEXCEPT_EXPR(boost::core::invoke_swap(*x, *y)))
     {
         if (x)
@@ -91,7 +91,7 @@ struct swap_selector<false>
 
 } // namespace optional_detail
 
-#if (!defined BOOST_NO_CXX11_RVALUE_REFERENCES) && (!defined BOOST_CONFIG_RESTORE_OBSOLETE_SWAP_IMPLEMENTATION)
+#if (!defined BOOST_CONFIG_RESTORE_OBSOLETE_SWAP_IMPLEMENTATION)
 
 template<class T>
 struct optional_swap_should_use_default_constructor : boost::false_type {} ;