passenger 6.1.0 → 6.1.1

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

@@ -5,7 +5,7 @@
  *
  * Copyright (c) 2011 Helge Bahmann
  * Copyright (c) 2013 Tim Blechmann
- * Copyright (c) 2014, 2020 Andrey Semashev
+ * Copyright (c) 2014, 2020-2025 Andrey Semashev
  */
 /*!
  * \file   atomic/atomic.hpp
@@ -17,14 +17,14 @@
 #define BOOST_ATOMIC_ATOMIC_HPP_INCLUDED_
 
 #include <cstddef>
-#include <boost/cstdint.hpp>
+#include <cstdint>
+#include <type_traits>
 #include <boost/memory_order.hpp>
 #include <boost/atomic/capabilities.hpp>
 #include <boost/atomic/detail/config.hpp>
 #include <boost/atomic/detail/classify.hpp>
 #include <boost/atomic/detail/atomic_impl.hpp>
 #include <boost/atomic/detail/type_traits/is_trivially_copyable.hpp>
-#include <boost/atomic/detail/type_traits/is_nothrow_default_constructible.hpp>
 #include <boost/atomic/detail/header.hpp>
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
@@ -40,141 +40,131 @@ class atomic :
     public atomics::detail::base_atomic< T, typename atomics::detail::classify< T >::type, false >
 {
 private:
-    typedef atomics::detail::base_atomic< T, typename atomics::detail::classify< T >::type, false > base_type;
-    typedef typename base_type::value_arg_type value_arg_type;
+    using base_type = atomics::detail::base_atomic< T, typename atomics::detail::classify< T >::type, false >;
+    using value_arg_type = typename base_type::value_arg_type;
 
 public:
-    typedef typename base_type::value_type value_type;
+    using value_type = typename base_type::value_type;
 
     static_assert(sizeof(value_type) > 0u, "boost::atomic<T> requires T to be a complete type");
-#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_IS_TRIVIALLY_COPYABLE)
     static_assert(atomics::detail::is_trivially_copyable< value_type >::value, "boost::atomic<T> requires T to be a trivially copyable type");
-#endif
 
 public:
-    BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_UNION_INIT atomic() BOOST_NOEXCEPT_IF(atomics::detail::is_nothrow_default_constructible< value_type >::value) : base_type()
-    {
-    }
+    atomic() = default;
 
-    BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_UNION_INIT atomic(value_arg_type v) BOOST_NOEXCEPT : base_type(v)
+    BOOST_FORCEINLINE constexpr atomic(value_arg_type v) noexcept : base_type(v)
     {
     }
 
-    BOOST_FORCEINLINE value_type operator= (value_arg_type v) BOOST_NOEXCEPT
+    atomic(atomic const&) = delete;
+    atomic& operator= (atomic const&) = delete;
+    atomic& operator= (atomic const&) volatile = delete;
+
+    BOOST_FORCEINLINE value_type operator= (value_arg_type v) noexcept
     {
         this->store(v);
         return v;
     }
 
-    BOOST_FORCEINLINE value_type operator= (value_arg_type v) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type operator= (value_arg_type v) volatile noexcept
     {
         this->store(v);
         return v;
     }
 
-    BOOST_FORCEINLINE operator value_type() const volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE operator value_type() const volatile noexcept
     {
         return this->load();
     }
-
-    BOOST_DELETED_FUNCTION(atomic(atomic const&))
-    BOOST_DELETED_FUNCTION(atomic& operator= (atomic const&))
-    BOOST_DELETED_FUNCTION(atomic& operator= (atomic const&) volatile)
 };
 
-typedef atomic< char > atomic_char;
-typedef atomic< unsigned char > atomic_uchar;
-typedef atomic< signed char > atomic_schar;
-typedef atomic< uint8_t > atomic_uint8_t;
-typedef atomic< int8_t > atomic_int8_t;
-typedef atomic< unsigned short > atomic_ushort;
-typedef atomic< short > atomic_short;
-typedef atomic< uint16_t > atomic_uint16_t;
-typedef atomic< int16_t > atomic_int16_t;
-typedef atomic< unsigned int > atomic_uint;
-typedef atomic< int > atomic_int;
-typedef atomic< uint32_t > atomic_uint32_t;
-typedef atomic< int32_t > atomic_int32_t;
-typedef atomic< unsigned long > atomic_ulong;
-typedef atomic< long > atomic_long;
-typedef atomic< uint64_t > atomic_uint64_t;
-typedef atomic< int64_t > atomic_int64_t;
-#ifdef BOOST_HAS_LONG_LONG
-typedef atomic< boost::ulong_long_type > atomic_ullong;
-typedef atomic< boost::long_long_type > atomic_llong;
-#endif
-typedef atomic< void* > atomic_address;
-typedef atomic< bool > atomic_bool;
-typedef atomic< wchar_t > atomic_wchar_t;
-#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811
-typedef atomic< char8_t > atomic_char8_t;
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR16_T)
-typedef atomic< char16_t > atomic_char16_t;
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR32_T)
-typedef atomic< char32_t > atomic_char32_t;
-#endif
-
-typedef atomic< int_least8_t > atomic_int_least8_t;
-typedef atomic< uint_least8_t > atomic_uint_least8_t;
-typedef atomic< int_least16_t > atomic_int_least16_t;
-typedef atomic< uint_least16_t > atomic_uint_least16_t;
-typedef atomic< int_least32_t > atomic_int_least32_t;
-typedef atomic< uint_least32_t > atomic_uint_least32_t;
-typedef atomic< int_least64_t > atomic_int_least64_t;
-typedef atomic< uint_least64_t > atomic_uint_least64_t;
-typedef atomic< int_fast8_t > atomic_int_fast8_t;
-typedef atomic< uint_fast8_t > atomic_uint_fast8_t;
-typedef atomic< int_fast16_t > atomic_int_fast16_t;
-typedef atomic< uint_fast16_t > atomic_uint_fast16_t;
-typedef atomic< int_fast32_t > atomic_int_fast32_t;
-typedef atomic< uint_fast32_t > atomic_uint_fast32_t;
-typedef atomic< int_fast64_t > atomic_int_fast64_t;
-typedef atomic< uint_fast64_t > atomic_uint_fast64_t;
-typedef atomic< intmax_t > atomic_intmax_t;
-typedef atomic< uintmax_t > atomic_uintmax_t;
+using atomic_char = atomic< char >;
+using atomic_uchar = atomic< unsigned char >;
+using atomic_schar = atomic< signed char >;
+using atomic_ushort = atomic< unsigned short >;
+using atomic_short = atomic< short >;
+using atomic_uint = atomic< unsigned int >;
+using atomic_int = atomic< int >;
+using atomic_ulong = atomic< unsigned long >;
+using atomic_long = atomic< long >;
+using atomic_ullong = atomic< unsigned long long >;
+using atomic_llong = atomic< long long >;
+using atomic_address = atomic< void* >;
+using atomic_bool = atomic< bool >;
+using atomic_wchar_t = atomic< wchar_t >;
+#if defined(__cpp_char8_t) && (__cpp_char8_t >= 201811)
+using atomic_char8_t = atomic< char8_t >;
+#endif
+using atomic_char16_t = atomic< char16_t >;
+using atomic_char32_t = atomic< char32_t >;
+
+using atomic_uint8_t = atomic< std::uint8_t >;
+using atomic_int8_t = atomic< std::int8_t >;
+using atomic_uint16_t = atomic< std::uint16_t >;
+using atomic_int16_t = atomic< std::int16_t >;
+using atomic_uint32_t = atomic< std::uint32_t >;
+using atomic_int32_t = atomic< std::int32_t >;
+using atomic_uint64_t = atomic< std::uint64_t >;
+using atomic_int64_t = atomic< std::int64_t >;
+using atomic_int_least8_t = atomic< std::int_least8_t >;
+using atomic_uint_least8_t = atomic< std::uint_least8_t >;
+using atomic_int_least16_t = atomic< std::int_least16_t >;
+using atomic_uint_least16_t = atomic< std::uint_least16_t >;
+using atomic_int_least32_t = atomic< std::int_least32_t >;
+using atomic_uint_least32_t = atomic< std::uint_least32_t >;
+using atomic_int_least64_t = atomic< std::int_least64_t >;
+using atomic_uint_least64_t = atomic< std::uint_least64_t >;
+using atomic_int_fast8_t = atomic< std::int_fast8_t >;
+using atomic_uint_fast8_t = atomic< std::uint_fast8_t >;
+using atomic_int_fast16_t = atomic< std::int_fast16_t >;
+using atomic_uint_fast16_t = atomic< std::uint_fast16_t >;
+using atomic_int_fast32_t = atomic< std::int_fast32_t >;
+using atomic_uint_fast32_t = atomic< std::uint_fast32_t >;
+using atomic_int_fast64_t = atomic< std::int_fast64_t >;
+using atomic_uint_fast64_t = atomic< std::uint_fast64_t >;
+using atomic_intmax_t = atomic< std::intmax_t >;
+using atomic_uintmax_t = atomic< std::uintmax_t >;
 
 #if !defined(BOOST_ATOMIC_NO_FLOATING_POINT)
-typedef atomic< float > atomic_float_t;
-typedef atomic< double > atomic_double_t;
-typedef atomic< long double > atomic_long_double_t;
+using atomic_float_t = atomic< float >;
+using atomic_double_t = atomic< double >;
+using atomic_long_double_t = atomic< long double >;
 #endif
 
-typedef atomic< std::size_t > atomic_size_t;
-typedef atomic< std::ptrdiff_t > atomic_ptrdiff_t;
+using atomic_size_t = atomic< std::size_t >;
+using atomic_ptrdiff_t = atomic< std::ptrdiff_t >;
 
-#if defined(BOOST_HAS_INTPTR_T)
-typedef atomic< boost::intptr_t > atomic_intptr_t;
-typedef atomic< boost::uintptr_t > atomic_uintptr_t;
+#if defined(UINTPTR_MAX)
+using atomic_intptr_t = atomic< std::intptr_t >;
+using atomic_uintptr_t = atomic< std::uintptr_t >;
 #endif
 
 // Select the lock-free atomic types that has natively supported waiting/notifying operations.
 // Prefer 32-bit types the most as those have the best performance on current 32 and 64-bit architectures.
 #if BOOST_ATOMIC_INT32_LOCK_FREE == 2 && BOOST_ATOMIC_HAS_NATIVE_INT32_WAIT_NOTIFY == 2
-typedef atomic< uint32_t > atomic_unsigned_lock_free;
-typedef atomic< int32_t > atomic_signed_lock_free;
+using atomic_unsigned_lock_free = atomic< std::uint32_t >;
+using atomic_signed_lock_free = atomic< std::int32_t >;
 #elif BOOST_ATOMIC_INT64_LOCK_FREE == 2 && BOOST_ATOMIC_HAS_NATIVE_INT64_WAIT_NOTIFY == 2
-typedef atomic< uint64_t > atomic_unsigned_lock_free;
-typedef atomic< int64_t > atomic_signed_lock_free;
+using atomic_unsigned_lock_free = atomic< std::uint64_t >;
+using atomic_signed_lock_free = atomic< std::int64_t >;
 #elif BOOST_ATOMIC_INT16_LOCK_FREE == 2 && BOOST_ATOMIC_HAS_NATIVE_INT16_WAIT_NOTIFY == 2
-typedef atomic< uint16_t > atomic_unsigned_lock_free;
-typedef atomic< int16_t > atomic_signed_lock_free;
+using atomic_unsigned_lock_free = atomic< std::uint16_t >;
+using atomic_signed_lock_free = atomic< std::int16_t >;
 #elif BOOST_ATOMIC_INT8_LOCK_FREE == 2 && BOOST_ATOMIC_HAS_NATIVE_INT8_WAIT_NOTIFY == 2
-typedef atomic< uint8_t > atomic_unsigned_lock_free;
-typedef atomic< int8_t > atomic_signed_lock_free;
+using atomic_unsigned_lock_free = atomic< std::uint8_t >;
+using atomic_signed_lock_free = atomic< std::int8_t >;
 #elif BOOST_ATOMIC_INT32_LOCK_FREE == 2
-typedef atomic< uint32_t > atomic_unsigned_lock_free;
-typedef atomic< int32_t > atomic_signed_lock_free;
+using atomic_unsigned_lock_free = atomic< std::uint32_t >;
+using atomic_signed_lock_free = atomic< std::int32_t >;
 #elif BOOST_ATOMIC_INT64_LOCK_FREE == 2
-typedef atomic< uint64_t > atomic_unsigned_lock_free;
-typedef atomic< int64_t > atomic_signed_lock_free;
+using atomic_unsigned_lock_free = atomic< std::uint64_t >;
+using atomic_signed_lock_free = atomic< std::int64_t >;
 #elif BOOST_ATOMIC_INT16_LOCK_FREE == 2
-typedef atomic< uint16_t > atomic_unsigned_lock_free;
-typedef atomic< int16_t > atomic_signed_lock_free;
+using atomic_unsigned_lock_free = atomic< std::uint16_t >;
+using atomic_signed_lock_free = atomic< std::int16_t >;
 #elif BOOST_ATOMIC_INT8_LOCK_FREE == 2
-typedef atomic< uint8_t > atomic_unsigned_lock_free;
-typedef atomic< int8_t > atomic_signed_lock_free;
+using atomic_unsigned_lock_free = atomic< std::uint8_t >;
+using atomic_signed_lock_free = atomic< std::int8_t >;
 #else
 #define BOOST_ATOMIC_DETAIL_NO_LOCK_FREE_TYPEDEFS
 #endif
@@ -186,37 +176,31 @@ using atomics::atomic;
 using atomics::atomic_char;
 using atomics::atomic_uchar;
 using atomics::atomic_schar;
-using atomics::atomic_uint8_t;
-using atomics::atomic_int8_t;
 using atomics::atomic_ushort;
 using atomics::atomic_short;
-using atomics::atomic_uint16_t;
-using atomics::atomic_int16_t;
 using atomics::atomic_uint;
 using atomics::atomic_int;
-using atomics::atomic_uint32_t;
-using atomics::atomic_int32_t;
 using atomics::atomic_ulong;
 using atomics::atomic_long;
-using atomics::atomic_uint64_t;
-using atomics::atomic_int64_t;
-#ifdef BOOST_HAS_LONG_LONG
 using atomics::atomic_ullong;
 using atomics::atomic_llong;
-#endif
 using atomics::atomic_address;
 using atomics::atomic_bool;
 using atomics::atomic_wchar_t;
 #if defined(__cpp_char8_t) && __cpp_char8_t >= 201811
 using atomics::atomic_char8_t;
 #endif
-#if !defined(BOOST_NO_CXX11_CHAR16_T)
 using atomics::atomic_char16_t;
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR32_T)
 using atomics::atomic_char32_t;
-#endif
 
+using atomics::atomic_uint8_t;
+using atomics::atomic_int8_t;
+using atomics::atomic_uint16_t;
+using atomics::atomic_int16_t;
+using atomics::atomic_uint32_t;
+using atomics::atomic_int32_t;
+using atomics::atomic_uint64_t;
+using atomics::atomic_int64_t;
 using atomics::atomic_int_least8_t;
 using atomics::atomic_uint_least8_t;
 using atomics::atomic_int_least16_t;
@@ -245,7 +229,7 @@ using atomics::atomic_long_double_t;
 using atomics::atomic_size_t;
 using atomics::atomic_ptrdiff_t;
 
-#if defined(BOOST_HAS_INTPTR_T)
+#if defined(UINTPTR_MAX)
 using atomics::atomic_intptr_t;
 using atomics::atomic_uintptr_t;
 #endif

data/src/cxx_supportlib/vendor-modified/boost/atomic/atomic_flag.hpp

@@ -5,7 +5,7 @@
  *
  * Copyright (c) 2011 Helge Bahmann
  * Copyright (c) 2013 Tim Blechmann
- * Copyright (c) 2014, 2020 Andrey Semashev
+ * Copyright (c) 2014, 2020-2025 Andrey Semashev
  */
 /*!
  * \file   atomic/atomic_flag.hpp
@@ -29,7 +29,7 @@ namespace boost {
 namespace atomics {
 
 //! Atomic flag
-typedef atomics::detail::atomic_flag_impl< false > atomic_flag;
+using atomic_flag = atomics::detail::atomic_flag_impl< false >;
 
 } // namespace atomics
 

data/src/cxx_supportlib/vendor-modified/boost/atomic/atomic_ref.hpp

@@ -3,7 +3,7 @@
  * (See accompanying file LICENSE_1_0.txt or copy at
  * http://www.boost.org/LICENSE_1_0.txt)
  *
- * Copyright (c) 2020-2021 Andrey Semashev
+ * Copyright (c) 2020-2025 Andrey Semashev
  */
 /*!
  * \file   atomic/atomic_ref.hpp
@@ -14,6 +14,7 @@
 #ifndef BOOST_ATOMIC_ATOMIC_REF_HPP_INCLUDED_
 #define BOOST_ATOMIC_ATOMIC_REF_HPP_INCLUDED_
 
+#include <type_traits>
 #include <boost/assert.hpp>
 #include <boost/memory_order.hpp>
 #include <boost/atomic/capabilities.hpp>
@@ -37,40 +38,39 @@ class atomic_ref :
     public atomics::detail::base_atomic_ref< T, typename atomics::detail::classify< T >::type, false >
 {
 private:
-    typedef atomics::detail::base_atomic_ref< T, typename atomics::detail::classify< T >::type, false > base_type;
-    typedef typename base_type::value_arg_type value_arg_type;
+    using base_type = atomics::detail::base_atomic_ref< T, typename atomics::detail::classify< T >::type, false >;
+    using value_arg_type = typename base_type::value_arg_type;
 
 public:
-    typedef typename base_type::value_type value_type;
+    using value_type = typename base_type::value_type;
 
     static_assert(sizeof(value_type) > 0u, "boost::atomic_ref<T> requires T to be a complete type");
-#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_IS_TRIVIALLY_COPYABLE)
     static_assert(atomics::detail::is_trivially_copyable< value_type >::value, "boost::atomic_ref<T> requires T to be a trivially copyable type");
-#endif
 
 private:
-    typedef typename base_type::storage_type storage_type;
+    using storage_type = typename base_type::storage_type;
 
 public:
-    BOOST_DEFAULTED_FUNCTION(atomic_ref(atomic_ref const& that) BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_DECL, BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_IMPL : base_type(static_cast< base_type const& >(that)) {})
-    BOOST_FORCEINLINE explicit atomic_ref(value_type& v) BOOST_NOEXCEPT : base_type(v)
+    atomic_ref(atomic_ref const&) = default;
+
+    BOOST_FORCEINLINE explicit atomic_ref(value_type& v) noexcept : base_type(v)
     {
         // Check that referenced object alignment satisfies required alignment
         BOOST_ASSERT((((atomics::detail::uintptr_t)this->m_value) & (base_type::required_alignment - 1u)) == 0u);
     }
 
-    BOOST_FORCEINLINE value_type operator= (value_arg_type v) const BOOST_NOEXCEPT
+    atomic_ref& operator= (atomic_ref const&) = delete;
+
+    BOOST_FORCEINLINE value_type operator= (value_arg_type v) const noexcept
     {
         this->store(v);
         return v;
     }
 
-    BOOST_FORCEINLINE operator value_type() const BOOST_NOEXCEPT
+    BOOST_FORCEINLINE operator value_type() const noexcept
     {
         return this->load();
     }
-
-    BOOST_DELETED_FUNCTION(atomic_ref& operator= (atomic_ref const&))
 };
 
 #if !defined(BOOST_NO_CXX17_DEDUCTION_GUIDES)
@@ -80,7 +80,7 @@ atomic_ref(T&) -> atomic_ref< T >;
 
 //! Atomic reference factory function
 template< typename T >
-BOOST_FORCEINLINE atomic_ref< T > make_atomic_ref(T& value) BOOST_NOEXCEPT
+BOOST_FORCEINLINE atomic_ref< T > make_atomic_ref(T& value) noexcept
 {
     return atomic_ref< T >(value);
 }

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/addressof.hpp

@@ -3,7 +3,7 @@
  * (See accompanying file LICENSE_1_0.txt or copy at
  * http://www.boost.org/LICENSE_1_0.txt)
  *
- * Copyright (c) 2018 Andrey Semashev
+ * Copyright (c) 2018, 2025 Andrey Semashev
  */
 /*!
  * \file   atomic/detail/addressof.hpp
@@ -40,9 +40,9 @@ namespace detail {
 template< typename T >
 BOOST_FORCEINLINE
 #if defined(BOOST_ATOMIC_DETAIL_HAS_BUILTIN_ADDRESSOF)
-BOOST_CONSTEXPR
+constexpr
 #endif
-T* addressof(T& value) BOOST_NOEXCEPT
+T* addressof(T& value) noexcept
 {
 #if defined(BOOST_ATOMIC_DETAIL_HAS_BUILTIN_ADDRESSOF)
     return __builtin_addressof(value);

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/atomic_flag_impl.hpp

@@ -5,7 +5,7 @@
  *
  * Copyright (c) 2011 Helge Bahmann
  * Copyright (c) 2013 Tim Blechmann
- * Copyright (c) 2014, 2020 Andrey Semashev
+ * Copyright (c) 2014, 2020-2025 Andrey Semashev
  */
 /*!
  * \file   atomic/detail/atomic_flag_impl.hpp
@@ -16,8 +16,12 @@
 #ifndef BOOST_ATOMIC_DETAIL_ATOMIC_FLAG_IMPL_HPP_INCLUDED_
 #define BOOST_ATOMIC_DETAIL_ATOMIC_FLAG_IMPL_HPP_INCLUDED_
 
+#include <chrono>
+#include <utility>
+#include <type_traits>
 #include <boost/assert.hpp>
 #include <boost/memory_order.hpp>
+#include <boost/atomic/wait_result.hpp>
 #include <boost/atomic/detail/config.hpp>
 #include <boost/atomic/detail/core_operations.hpp>
 #include <boost/atomic/detail/wait_operations.hpp>
@@ -37,53 +41,52 @@ namespace boost {
 namespace atomics {
 namespace detail {
 
-#if defined(BOOST_ATOMIC_DETAIL_NO_CXX11_CONSTEXPR_UNION_INIT) || defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
-#define BOOST_ATOMIC_NO_ATOMIC_FLAG_INIT
-#else
 #define BOOST_ATOMIC_FLAG_INIT {}
-#endif
 
 //! Atomic flag implementation
 template< bool IsInterprocess >
 struct atomic_flag_impl
 {
     // Prefer 4-byte storage as most platforms support waiting/notifying operations without a lock pool for 32-bit integers
-    typedef atomics::detail::core_operations< 4u, false, IsInterprocess > core_operations;
-    typedef atomics::detail::wait_operations< core_operations > wait_operations;
-    typedef typename core_operations::storage_type storage_type;
+    using core_operations = atomics::detail::core_operations< 4u, false, IsInterprocess >;
+    using wait_operations = atomics::detail::wait_operations< core_operations >;
+    using storage_type = typename core_operations::storage_type;
 
-    static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = core_operations::is_always_lock_free;
-    static BOOST_CONSTEXPR_OR_CONST bool always_has_native_wait_notify = wait_operations::always_has_native_wait_notify;
+    static constexpr bool is_always_lock_free = core_operations::is_always_lock_free;
+    static constexpr bool always_has_native_wait_notify = wait_operations::always_has_native_wait_notify;
 
     BOOST_ATOMIC_DETAIL_ALIGNED_VAR_TPL(core_operations::storage_alignment, storage_type, m_storage);
 
-    BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_UNION_INIT atomic_flag_impl() BOOST_NOEXCEPT : m_storage(0u)
+    BOOST_FORCEINLINE constexpr atomic_flag_impl() noexcept : m_storage(0u)
     {
     }
 
-    BOOST_FORCEINLINE bool is_lock_free() const volatile BOOST_NOEXCEPT
+    atomic_flag_impl(atomic_flag_impl const&) = delete;
+    atomic_flag_impl& operator= (atomic_flag_impl const&) = delete;
+
+    BOOST_FORCEINLINE bool is_lock_free() const volatile noexcept
     {
         return is_always_lock_free;
     }
 
-    BOOST_FORCEINLINE bool has_native_wait_notify() const volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool has_native_wait_notify() const volatile noexcept
     {
         return wait_operations::has_native_wait_notify(m_storage);
     }
 
-    BOOST_FORCEINLINE bool test(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool test(memory_order order = memory_order_seq_cst) const volatile noexcept
     {
         BOOST_ASSERT(order != memory_order_release);
         BOOST_ASSERT(order != memory_order_acq_rel);
         return !!core_operations::load(m_storage, order);
     }
 
-    BOOST_FORCEINLINE bool test_and_set(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool test_and_set(memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return core_operations::test_and_set(m_storage, order);
     }
 
-    BOOST_FORCEINLINE void clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE void clear(memory_order order = memory_order_seq_cst) volatile noexcept
     {
         BOOST_ASSERT(order != memory_order_consume);
         BOOST_ASSERT(order != memory_order_acquire);
@@ -91,7 +94,7 @@ struct atomic_flag_impl
         core_operations::clear(m_storage, order);
     }
 
-    BOOST_FORCEINLINE bool wait(bool old_val, memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool wait(bool old_val, memory_order order = memory_order_seq_cst) const volatile noexcept
     {
         BOOST_ASSERT(order != memory_order_release);
         BOOST_ASSERT(order != memory_order_acq_rel);
@@ -99,25 +102,50 @@ struct atomic_flag_impl
         return !!wait_operations::wait(m_storage, static_cast< storage_type >(old_val), order);
     }
 
-    BOOST_FORCEINLINE void notify_one() volatile BOOST_NOEXCEPT
+    template< typename Clock, typename Duration >
+    BOOST_FORCEINLINE wait_result< bool >
+    wait_until(bool old_val, std::chrono::time_point< Clock, Duration > timeout, memory_order order = memory_order_seq_cst) const volatile
+        noexcept(noexcept(wait_operations::wait_until(
+            std::declval< storage_type const volatile& >(), std::declval< storage_type >(), timeout, order, std::declval< bool& >())))
+    {
+        BOOST_ASSERT(order != memory_order_release);
+        BOOST_ASSERT(order != memory_order_acq_rel);
+
+        bool timed_out = false;
+        storage_type new_value = wait_operations::wait_until(m_storage, static_cast< storage_type >(old_val), timeout, order, timed_out);
+        return wait_result< bool >(!!new_value, timed_out);
+    }
+
+    template< typename Rep, typename Period >
+    BOOST_FORCEINLINE wait_result< bool >
+    wait_for(bool old_val, std::chrono::duration< Rep, Period > timeout, memory_order order = memory_order_seq_cst) const volatile
+        noexcept(noexcept(wait_operations::wait_for(
+            std::declval< storage_type const volatile& >(), std::declval< storage_type >(), timeout, order, std::declval< bool& >())))
+    {
+        BOOST_ASSERT(order != memory_order_release);
+        BOOST_ASSERT(order != memory_order_acq_rel);
+
+        bool timed_out = false;
+        storage_type new_value = wait_operations::wait_for(m_storage, static_cast< storage_type >(old_val), timeout, order, timed_out);
+        return wait_result< bool >(!!new_value, timed_out);
+    }
+
+    BOOST_FORCEINLINE void notify_one() volatile noexcept
     {
         wait_operations::notify_one(m_storage);
     }
 
-    BOOST_FORCEINLINE void notify_all() volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE void notify_all() volatile noexcept
     {
         wait_operations::notify_all(m_storage);
     }
-
-    BOOST_DELETED_FUNCTION(atomic_flag_impl(atomic_flag_impl const&))
-    BOOST_DELETED_FUNCTION(atomic_flag_impl& operator= (atomic_flag_impl const&))
 };
 
 #if defined(BOOST_NO_CXX17_INLINE_VARIABLES)
 template< bool IsInterprocess >
-BOOST_CONSTEXPR_OR_CONST bool atomic_flag_impl< IsInterprocess >::is_always_lock_free;
+constexpr bool atomic_flag_impl< IsInterprocess >::is_always_lock_free;
 template< bool IsInterprocess >
-BOOST_CONSTEXPR_OR_CONST bool atomic_flag_impl< IsInterprocess >::always_has_native_wait_notify;
+constexpr bool atomic_flag_impl< IsInterprocess >::always_has_native_wait_notify;
 #endif
 
 } // namespace detail