passenger 6.1.0 → 6.1.1

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/atomic_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-2025 Andrey Semashev
  */
 /*!
  * \file   atomic/detail/atomic_impl.hpp
@@ -17,8 +17,12 @@
 #define BOOST_ATOMIC_DETAIL_ATOMIC_IMPL_HPP_INCLUDED_
 
 #include <cstddef>
+#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/intptr.hpp>
 #include <boost/atomic/detail/storage_traits.hpp>
@@ -30,11 +34,8 @@
 #include <boost/atomic/detail/memory_order_utils.hpp>
 #include <boost/atomic/detail/aligned_variable.hpp>
 #include <boost/atomic/detail/type_traits/is_signed.hpp>
-#include <boost/atomic/detail/type_traits/is_nothrow_default_constructible.hpp>
-#include <boost/atomic/detail/type_traits/is_trivially_default_constructible.hpp>
 #include <boost/atomic/detail/type_traits/alignment_of.hpp>
-#include <boost/atomic/detail/type_traits/conditional.hpp>
-#include <boost/atomic/detail/type_traits/integral_constant.hpp>
+#include <boost/atomic/detail/type_traits/is_trivially_default_constructible.hpp>
 #if !defined(BOOST_ATOMIC_NO_FLOATING_POINT)
 #include <boost/atomic/detail/bitwise_fp_cast.hpp>
 #include <boost/atomic/detail/fp_operations.hpp>
@@ -46,8 +47,8 @@
 #pragma once
 #endif
 
-#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_CONSTEXPR_UNION_INIT) && !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_CONSTEXPR_BITWISE_CAST)
-#define BOOST_ATOMIC_DETAIL_CONSTEXPR_ATOMIC_CTOR BOOST_CONSTEXPR
+#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_CONSTEXPR_BITWISE_CAST)
+#define BOOST_ATOMIC_DETAIL_CONSTEXPR_ATOMIC_CTOR constexpr
 #else
 #define BOOST_ATOMIC_DETAIL_CONSTEXPR_ATOMIC_CTOR
 #endif
@@ -65,63 +66,65 @@ template< typename T, bool Signed, bool Interprocess >
 class base_atomic_common
 {
 public:
-    typedef T value_type;
+    using value_type = T;
 
 protected:
-    typedef atomics::detail::core_operations< storage_size_of< value_type >::value, Signed, Interprocess > core_operations;
-    typedef atomics::detail::wait_operations< core_operations > wait_operations;
-    typedef typename atomics::detail::conditional< sizeof(value_type) <= sizeof(void*), value_type, value_type const& >::type value_arg_type;
-    typedef typename core_operations::storage_type storage_type;
+    using core_operations = atomics::detail::core_operations< storage_size_of< value_type >::value, Signed, Interprocess >;
+    using wait_operations = atomics::detail::wait_operations< core_operations >;
+    using value_arg_type = typename std::conditional< sizeof(value_type) <= sizeof(void*), value_type, value_type const& >::type;
+    using storage_type = typename core_operations::storage_type;
 
 protected:
-    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_alignment = atomics::detail::alignment_of< value_type >::value <= core_operations::storage_alignment ? core_operations::storage_alignment : atomics::detail::alignment_of< value_type >::value;
+    static constexpr std::size_t storage_alignment =
+        atomics::detail::alignment_of< value_type >::value <= core_operations::storage_alignment ?
+            core_operations::storage_alignment : atomics::detail::alignment_of< value_type >::value;
 
 public:
-    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;
 
 protected:
     BOOST_ATOMIC_DETAIL_ALIGNED_VAR_TPL(storage_alignment, storage_type, m_storage);
 
 public:
-    BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_UNION_INIT base_atomic_common() BOOST_NOEXCEPT : m_storage()
+    BOOST_FORCEINLINE constexpr base_atomic_common() noexcept : m_storage()
     {
     }
 
-    BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_UNION_INIT explicit base_atomic_common(storage_type v) BOOST_NOEXCEPT : m_storage(v)
+    BOOST_FORCEINLINE constexpr explicit base_atomic_common(storage_type v) noexcept : m_storage(v)
     {
     }
 
-    BOOST_FORCEINLINE value_type& value() BOOST_NOEXCEPT { return *reinterpret_cast< value_type* >(&m_storage); }
-    BOOST_FORCEINLINE value_type volatile& value() volatile BOOST_NOEXCEPT { return *reinterpret_cast< volatile value_type* >(&m_storage); }
-    BOOST_FORCEINLINE value_type const& value() const BOOST_NOEXCEPT { return *reinterpret_cast< const value_type* >(&m_storage); }
-    BOOST_FORCEINLINE value_type const volatile& value() const volatile BOOST_NOEXCEPT { return *reinterpret_cast< const volatile value_type* >(&m_storage); }
+    BOOST_FORCEINLINE value_type& value() noexcept { return *reinterpret_cast< value_type* >(&m_storage); }
+    BOOST_FORCEINLINE value_type volatile& value() volatile noexcept { return *reinterpret_cast< volatile value_type* >(&m_storage); }
+    BOOST_FORCEINLINE value_type const& value() const noexcept { return *reinterpret_cast< const value_type* >(&m_storage); }
+    BOOST_FORCEINLINE value_type const volatile& value() const volatile noexcept { return *reinterpret_cast< const volatile value_type* >(&m_storage); }
 
 protected:
-    BOOST_FORCEINLINE storage_type& storage() BOOST_NOEXCEPT { return m_storage; }
-    BOOST_FORCEINLINE storage_type volatile& storage() volatile BOOST_NOEXCEPT { return m_storage; }
-    BOOST_FORCEINLINE storage_type const& storage() const BOOST_NOEXCEPT { return m_storage; }
-    BOOST_FORCEINLINE storage_type const volatile& storage() const volatile BOOST_NOEXCEPT { return m_storage; }
+    BOOST_FORCEINLINE storage_type& storage() noexcept { return m_storage; }
+    BOOST_FORCEINLINE storage_type volatile& storage() volatile noexcept { return m_storage; }
+    BOOST_FORCEINLINE storage_type const& storage() const noexcept { return m_storage; }
+    BOOST_FORCEINLINE storage_type const volatile& storage() const volatile noexcept { return m_storage; }
 
 public:
-    BOOST_FORCEINLINE bool is_lock_free() const volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool is_lock_free() const volatile noexcept
     {
         // C++17 requires all instances of atomic<> return a value consistent with is_always_lock_free here.
         // Boost.Atomic also enforces the required alignment of the atomic storage, so we can always return is_always_lock_free.
         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(this->storage());
     }
 
-    BOOST_FORCEINLINE void notify_one() volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE void notify_one() volatile noexcept
     {
         wait_operations::notify_one(this->storage());
     }
 
-    BOOST_FORCEINLINE void notify_all() volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE void notify_all() volatile noexcept
     {
         wait_operations::notify_all(this->storage());
     }
@@ -129,9 +132,9 @@ public:
 
 #if defined(BOOST_NO_CXX17_INLINE_VARIABLES)
 template< typename T, bool Signed, bool Interprocess >
-BOOST_CONSTEXPR_OR_CONST bool base_atomic_common< T, Signed, Interprocess >::is_always_lock_free;
+constexpr bool base_atomic_common< T, Signed, Interprocess >::is_always_lock_free;
 template< typename T, bool Signed, bool Interprocess >
-BOOST_CONSTEXPR_OR_CONST bool base_atomic_common< T, Signed, Interprocess >::always_has_native_wait_notify;
+constexpr bool base_atomic_common< T, Signed, Interprocess >::always_has_native_wait_notify;
 #endif
 
 
@@ -143,15 +146,15 @@ class base_atomic_generic< T, Interprocess, true > :
     public base_atomic_common< T, false, Interprocess >
 {
 private:
-    typedef base_atomic_common< T, false, Interprocess > base_type;
+    using base_type = base_atomic_common< T, false, Interprocess >;
 
 protected:
-    typedef typename base_type::storage_type storage_type;
-    typedef typename base_type::value_arg_type value_arg_type;
+    using storage_type = typename base_type::storage_type;
+    using value_arg_type = typename base_type::value_arg_type;
 
 public:
-    BOOST_DEFAULTED_FUNCTION(base_atomic_generic() BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_DECL, BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_IMPL {})
-    BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_ATOMIC_CTOR explicit base_atomic_generic(value_arg_type v) BOOST_NOEXCEPT :
+    base_atomic_generic() = default;
+    BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_ATOMIC_CTOR explicit base_atomic_generic(value_arg_type v) noexcept :
         base_type(atomics::detail::bitwise_cast< storage_type >(v))
     {
     }
@@ -162,17 +165,17 @@ class base_atomic_generic< T, Interprocess, false > :
     public base_atomic_common< T, false, Interprocess >
 {
 private:
-    typedef base_atomic_common< T, false, Interprocess > base_type;
+    using base_type = base_atomic_common< T, false, Interprocess >;
 
 public:
-    typedef typename base_type::value_type value_type;
+    using value_type = typename base_type::value_type;
 
 protected:
-    typedef typename base_type::storage_type storage_type;
-    typedef typename base_type::value_arg_type value_arg_type;
+    using storage_type = typename base_type::storage_type;
+    using value_arg_type = typename base_type::value_arg_type;
 
 public:
-    BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_ATOMIC_CTOR explicit base_atomic_generic(value_arg_type v = value_type()) BOOST_NOEXCEPT :
+    BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_ATOMIC_CTOR explicit base_atomic_generic(value_arg_type v = value_type()) noexcept :
         base_type(atomics::detail::bitwise_cast< storage_type >(v))
     {
     }
@@ -188,34 +191,41 @@ class base_atomic< T, void, Interprocess > :
     public base_atomic_generic< T, Interprocess >
 {
 private:
-    typedef base_atomic_generic< T, Interprocess > base_type;
+    using base_type = base_atomic_generic< T, Interprocess >;
 
 public:
-    typedef typename base_type::value_type value_type;
+    using value_type = typename base_type::value_type;
 
 protected:
-    typedef typename base_type::core_operations core_operations;
-    typedef typename base_type::wait_operations wait_operations;
-    typedef typename base_type::storage_type storage_type;
-    typedef typename base_type::value_arg_type value_arg_type;
+    using core_operations = typename base_type::core_operations;
+    using wait_operations = typename base_type::wait_operations;
+    using storage_type = typename base_type::storage_type;
+    using value_arg_type = typename base_type::value_arg_type;
 
 private:
+    using cxchg_use_bitwise_cast =
 #if !defined(BOOST_ATOMIC_DETAIL_STORAGE_TYPE_MAY_ALIAS) || !defined(BOOST_ATOMIC_NO_CLEAR_PADDING)
-    typedef atomics::detail::true_type cxchg_use_bitwise_cast;
+        std::true_type;
 #else
-    typedef atomics::detail::integral_constant< bool, sizeof(value_type) != sizeof(storage_type) || atomics::detail::alignment_of< value_type >::value <= core_operations::storage_alignment > cxchg_use_bitwise_cast;
+        std::integral_constant<
+            bool,
+            sizeof(value_type) != sizeof(storage_type) || atomics::detail::alignment_of< value_type >::value <= core_operations::storage_alignment
+        >;
 #endif
 
 public:
-    BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_ATOMIC_CTOR base_atomic() BOOST_NOEXCEPT_IF(atomics::detail::is_nothrow_default_constructible< value_type >::value) : base_type()
+    BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_ATOMIC_CTOR base_atomic() noexcept(std::is_nothrow_default_constructible< value_type >::value) : base_type()
     {
     }
 
-    BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_ATOMIC_CTOR explicit base_atomic(value_arg_type v) BOOST_NOEXCEPT : base_type(v)
+    BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_ATOMIC_CTOR explicit base_atomic(value_arg_type v) noexcept : base_type(v)
     {
     }
 
-    BOOST_FORCEINLINE void store(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    base_atomic(base_atomic const&) = delete;
+    base_atomic& operator=(base_atomic const&) = delete;
+
+    BOOST_FORCEINLINE void store(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         BOOST_ASSERT(order != memory_order_consume);
         BOOST_ASSERT(order != memory_order_acquire);
@@ -224,7 +234,7 @@ public:
         core_operations::store(this->storage(), atomics::detail::bitwise_cast< storage_type >(v), order);
     }
 
-    BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile noexcept
     {
         BOOST_ASSERT(order != memory_order_release);
         BOOST_ASSERT(order != memory_order_acq_rel);
@@ -232,12 +242,12 @@ public:
         return atomics::detail::bitwise_cast< value_type >(core_operations::load(this->storage(), order));
     }
 
-    BOOST_FORCEINLINE value_type exchange(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type exchange(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return atomics::detail::bitwise_cast< value_type >(core_operations::exchange(this->storage(), atomics::detail::bitwise_cast< storage_type >(v), order));
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile noexcept
     {
         BOOST_ASSERT(failure_order != memory_order_release);
         BOOST_ASSERT(failure_order != memory_order_acq_rel);
@@ -246,12 +256,12 @@ public:
         return compare_exchange_strong_impl(expected, desired, success_order, failure_order, cxchg_use_bitwise_cast());
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return compare_exchange_strong(expected, desired, order, atomics::detail::deduce_failure_order(order));
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile noexcept
     {
         BOOST_ASSERT(failure_order != memory_order_release);
         BOOST_ASSERT(failure_order != memory_order_acq_rel);
@@ -260,12 +270,12 @@ public:
         return compare_exchange_weak_impl(expected, desired, success_order, failure_order, cxchg_use_bitwise_cast());
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return compare_exchange_weak(expected, desired, order, atomics::detail::deduce_failure_order(order));
     }
 
-    BOOST_FORCEINLINE value_type wait(value_arg_type old_val, memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type wait(value_arg_type 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);
@@ -273,32 +283,65 @@ public:
         return atomics::detail::bitwise_cast< value_type >(wait_operations::wait(this->storage(), atomics::detail::bitwise_cast< storage_type >(old_val), order));
     }
 
-    BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&))
-    BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&))
+    template< typename Clock, typename Duration >
+    BOOST_FORCEINLINE wait_result< value_type >
+    wait_until(value_arg_type 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(this->storage(), atomics::detail::bitwise_cast< storage_type >(old_val), timeout, order, timed_out);
+        return wait_result< value_type >(atomics::detail::bitwise_cast< value_type >(new_value), timed_out);
+    }
+
+    template< typename Rep, typename Period >
+    BOOST_FORCEINLINE wait_result< value_type >
+    wait_for(value_arg_type 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(this->storage(), atomics::detail::bitwise_cast< storage_type >(old_val), timeout, order, timed_out);
+        return wait_result< value_type >(atomics::detail::bitwise_cast< value_type >(new_value), timed_out);
+    }
 
 private:
-    BOOST_FORCEINLINE bool compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::false_type) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool
+    compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, std::false_type) volatile noexcept
     {
-        return core_operations::compare_exchange_strong(this->storage(), reinterpret_cast< storage_type& >(expected), atomics::detail::bitwise_cast< storage_type >(desired), success_order, failure_order);
+        return core_operations::compare_exchange_strong(
+            this->storage(), reinterpret_cast< storage_type& >(expected), atomics::detail::bitwise_cast< storage_type >(desired), success_order, failure_order);
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::true_type) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool
+    compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, std::true_type) volatile noexcept
     {
         storage_type old_value = atomics::detail::bitwise_cast< storage_type >(expected);
-        const bool res = core_operations::compare_exchange_strong(this->storage(), old_value, atomics::detail::bitwise_cast< storage_type >(desired), success_order, failure_order);
+        const bool res = core_operations::compare_exchange_strong(
+            this->storage(), old_value, atomics::detail::bitwise_cast< storage_type >(desired), success_order, failure_order);
         expected = atomics::detail::bitwise_cast< value_type >(old_value);
         return res;
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::false_type) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool
+    compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, std::false_type) volatile noexcept
     {
-        return core_operations::compare_exchange_weak(this->storage(), reinterpret_cast< storage_type& >(expected), atomics::detail::bitwise_cast< storage_type >(desired), success_order, failure_order);
+        return core_operations::compare_exchange_weak(
+            this->storage(), reinterpret_cast< storage_type& >(expected), atomics::detail::bitwise_cast< storage_type >(desired), success_order, failure_order);
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::true_type) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool
+    compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, std::true_type) volatile noexcept
     {
         storage_type old_value = atomics::detail::bitwise_cast< storage_type >(expected);
-        const bool res = core_operations::compare_exchange_weak(this->storage(), old_value, atomics::detail::bitwise_cast< storage_type >(desired), success_order, failure_order);
+        const bool res = core_operations::compare_exchange_weak(
+            this->storage(), old_value, atomics::detail::bitwise_cast< storage_type >(desired), success_order, failure_order);
         expected = atomics::detail::bitwise_cast< value_type >(old_value);
         return res;
     }
@@ -311,31 +354,39 @@ class base_atomic< T, const int, Interprocess > :
     public base_atomic_common< T, false, Interprocess >
 {
 private:
-    typedef base_atomic_common< T, false, Interprocess > base_type;
+    using base_type = base_atomic_common< T, false, Interprocess >;
 
 public:
-    typedef typename base_type::value_type value_type;
+    using value_type = typename base_type::value_type;
 
 protected:
-    typedef typename base_type::core_operations core_operations;
-    typedef typename base_type::wait_operations wait_operations;
-    typedef typename base_type::storage_type storage_type;
-    typedef typename base_type::value_arg_type value_arg_type;
+    using core_operations = typename base_type::core_operations;
+    using wait_operations = typename base_type::wait_operations;
+    using extra_operations = atomics::detail::extra_operations< core_operations >;
+    using storage_type = typename base_type::storage_type;
+    using value_arg_type = typename base_type::value_arg_type;
 
 private:
+    using cxchg_use_bitwise_cast =
 #if !defined(BOOST_ATOMIC_DETAIL_STORAGE_TYPE_MAY_ALIAS) || !defined(BOOST_ATOMIC_NO_CLEAR_PADDING)
-    typedef atomics::detail::true_type cxchg_use_bitwise_cast;
+        std::true_type;
 #else
-    typedef atomics::detail::integral_constant< bool, sizeof(value_type) != sizeof(storage_type) || atomics::detail::alignment_of< value_type >::value <= core_operations::storage_alignment > cxchg_use_bitwise_cast;
+        std::integral_constant<
+            bool,
+            sizeof(value_type) != sizeof(storage_type) || atomics::detail::alignment_of< value_type >::value <= core_operations::storage_alignment
+        >;
 #endif
 
 public:
-    BOOST_DEFAULTED_FUNCTION(base_atomic() BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_DECL, BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_IMPL {})
-    BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_UNION_INIT explicit base_atomic(value_arg_type v) BOOST_NOEXCEPT : base_type(static_cast< storage_type >(v))
+    base_atomic() = default;
+    BOOST_FORCEINLINE constexpr explicit base_atomic(value_arg_type v) noexcept : base_type(static_cast< storage_type >(v))
     {
     }
 
-    BOOST_FORCEINLINE void store(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    base_atomic(base_atomic const&) = delete;
+    base_atomic& operator=(base_atomic const&) = delete;
+
+    BOOST_FORCEINLINE void store(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         BOOST_ASSERT(order != memory_order_consume);
         BOOST_ASSERT(order != memory_order_acquire);
@@ -344,7 +395,7 @@ public:
         core_operations::store(this->storage(), static_cast< storage_type >(v), order);
     }
 
-    BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile noexcept
     {
         BOOST_ASSERT(order != memory_order_release);
         BOOST_ASSERT(order != memory_order_acq_rel);
@@ -352,12 +403,12 @@ public:
         return atomics::detail::bitwise_cast< value_type >(core_operations::load(this->storage(), order));
     }
 
-    BOOST_FORCEINLINE value_type exchange(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type exchange(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return atomics::detail::bitwise_cast< value_type >(core_operations::exchange(this->storage(), static_cast< storage_type >(v), order));
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile noexcept
     {
         BOOST_ASSERT(failure_order != memory_order_release);
         BOOST_ASSERT(failure_order != memory_order_acq_rel);
@@ -366,12 +417,12 @@ public:
         return compare_exchange_strong_impl(expected, desired, success_order, failure_order, cxchg_use_bitwise_cast());
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return compare_exchange_strong(expected, desired, order, atomics::detail::deduce_failure_order(order));
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile noexcept
     {
         BOOST_ASSERT(failure_order != memory_order_release);
         BOOST_ASSERT(failure_order != memory_order_acq_rel);
@@ -380,12 +431,125 @@ public:
         return compare_exchange_weak_impl(expected, desired, success_order, failure_order, cxchg_use_bitwise_cast());
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return compare_exchange_weak(expected, desired, order, atomics::detail::deduce_failure_order(order));
     }
 
-    BOOST_FORCEINLINE value_type wait(value_arg_type old_val, memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type fetch_and(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
+    {
+        return atomics::detail::bitwise_cast< value_type >(core_operations::fetch_and(this->storage(), static_cast< storage_type >(v), order));
+    }
+
+    BOOST_FORCEINLINE value_type fetch_or(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
+    {
+        return atomics::detail::bitwise_cast< value_type >(core_operations::fetch_or(this->storage(), static_cast< storage_type >(v), order));
+    }
+
+    BOOST_FORCEINLINE value_type fetch_xor(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
+    {
+        return atomics::detail::bitwise_cast< value_type >(core_operations::fetch_xor(this->storage(), static_cast< storage_type >(v), order));
+    }
+
+    BOOST_FORCEINLINE value_type fetch_complement(memory_order order = memory_order_seq_cst) volatile noexcept
+    {
+        return atomics::detail::bitwise_cast< value_type >(extra_operations::fetch_complement(this->storage(), order));
+    }
+
+    BOOST_FORCEINLINE value_type bitwise_and(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
+    {
+        return atomics::detail::bitwise_cast< value_type >(extra_operations::bitwise_and(this->storage(), static_cast< storage_type >(v), order));
+    }
+
+    BOOST_FORCEINLINE value_type bitwise_or(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
+    {
+        return atomics::detail::bitwise_cast< value_type >(extra_operations::bitwise_or(this->storage(), static_cast< storage_type >(v), order));
+    }
+
+    BOOST_FORCEINLINE value_type bitwise_xor(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
+    {
+        return atomics::detail::bitwise_cast< value_type >(extra_operations::bitwise_xor(this->storage(), static_cast< storage_type >(v), order));
+    }
+
+    BOOST_FORCEINLINE value_type bitwise_complement(memory_order order = memory_order_seq_cst) volatile noexcept
+    {
+        return atomics::detail::bitwise_cast< value_type >(extra_operations::bitwise_complement(this->storage(), order));
+    }
+
+    BOOST_FORCEINLINE void opaque_and(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
+    {
+        extra_operations::opaque_and(this->storage(), static_cast< storage_type >(v), order);
+    }
+
+    BOOST_FORCEINLINE void opaque_or(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
+    {
+        extra_operations::opaque_or(this->storage(), static_cast< storage_type >(v), order);
+    }
+
+    BOOST_FORCEINLINE void opaque_xor(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
+    {
+        extra_operations::opaque_xor(this->storage(), static_cast< storage_type >(v), order);
+    }
+
+    BOOST_FORCEINLINE void opaque_complement(memory_order order = memory_order_seq_cst) volatile noexcept
+    {
+        extra_operations::opaque_complement(this->storage(), order);
+    }
+
+    BOOST_FORCEINLINE bool and_and_test(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
+    {
+        return extra_operations::and_and_test(this->storage(), static_cast< storage_type >(v), order);
+    }
+
+    BOOST_FORCEINLINE bool or_and_test(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
+    {
+        return extra_operations::or_and_test(this->storage(), static_cast< storage_type >(v), order);
+    }
+
+    BOOST_FORCEINLINE bool xor_and_test(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
+    {
+        return extra_operations::xor_and_test(this->storage(), static_cast< storage_type >(v), order);
+    }
+
+    BOOST_FORCEINLINE bool complement_and_test(memory_order order = memory_order_seq_cst) volatile noexcept
+    {
+        return extra_operations::complement_and_test(this->storage(), order);
+    }
+
+    BOOST_FORCEINLINE bool bit_test_and_set(unsigned int bit_number, memory_order order = memory_order_seq_cst) volatile noexcept
+    {
+        BOOST_ASSERT(bit_number < sizeof(value_type) * 8u);
+        return extra_operations::bit_test_and_set(this->storage(), bit_number, order);
+    }
+
+    BOOST_FORCEINLINE bool bit_test_and_reset(unsigned int bit_number, memory_order order = memory_order_seq_cst) volatile noexcept
+    {
+        BOOST_ASSERT(bit_number < sizeof(value_type) * 8u);
+        return extra_operations::bit_test_and_reset(this->storage(), bit_number, order);
+    }
+
+    BOOST_FORCEINLINE bool bit_test_and_complement(unsigned int bit_number, memory_order order = memory_order_seq_cst) volatile noexcept
+    {
+        BOOST_ASSERT(bit_number < sizeof(value_type) * 8u);
+        return extra_operations::bit_test_and_complement(this->storage(), bit_number, order);
+    }
+
+    BOOST_FORCEINLINE value_type operator&=(value_type v) volatile noexcept
+    {
+        return bitwise_and(v);
+    }
+
+    BOOST_FORCEINLINE value_type operator|=(value_type v) volatile noexcept
+    {
+        return bitwise_or(v);
+    }
+
+    BOOST_FORCEINLINE value_type operator^=(value_type v) volatile noexcept
+    {
+        return bitwise_xor(v);
+    }
+
+    BOOST_FORCEINLINE value_type wait(value_arg_type 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);
@@ -393,16 +557,44 @@ public:
         return atomics::detail::bitwise_cast< value_type >(wait_operations::wait(this->storage(), static_cast< storage_type >(old_val), order));
     }
 
-    BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&))
-    BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&))
+    template< typename Clock, typename Duration >
+    BOOST_FORCEINLINE wait_result< value_type >
+    wait_until(value_arg_type 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(this->storage(), static_cast< storage_type >(old_val), timeout, order, timed_out);
+        return wait_result< value_type >(atomics::detail::bitwise_cast< value_type >(new_value), timed_out);
+    }
+
+    template< typename Rep, typename Period >
+    BOOST_FORCEINLINE wait_result< value_type >
+    wait_for(value_arg_type 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(this->storage(), static_cast< storage_type >(old_val), timeout, order, timed_out);
+        return wait_result< value_type >(atomics::detail::bitwise_cast< value_type >(new_value), timed_out);
+    }
 
 private:
-    BOOST_FORCEINLINE bool compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::false_type) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool
+    compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, std::false_type) volatile noexcept
     {
-        return core_operations::compare_exchange_strong(this->storage(), reinterpret_cast< storage_type& >(expected), static_cast< storage_type >(desired), success_order, failure_order);
+        return core_operations::compare_exchange_strong(
+            this->storage(), reinterpret_cast< storage_type& >(expected), static_cast< storage_type >(desired), success_order, failure_order);
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::true_type) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool
+    compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, std::true_type) volatile noexcept
     {
         storage_type old_value = static_cast< storage_type >(expected);
         const bool res = core_operations::compare_exchange_strong(this->storage(), old_value, static_cast< storage_type >(desired), success_order, failure_order);
@@ -410,12 +602,15 @@ private:
         return res;
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::false_type) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool
+    compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, std::false_type) volatile noexcept
     {
-        return core_operations::compare_exchange_weak(this->storage(), reinterpret_cast< storage_type& >(expected), static_cast< storage_type >(desired), success_order, failure_order);
+        return core_operations::compare_exchange_weak(
+            this->storage(), reinterpret_cast< storage_type& >(expected), static_cast< storage_type >(desired), success_order, failure_order);
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::true_type) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool
+    compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, std::true_type) volatile noexcept
     {
         storage_type old_value = static_cast< storage_type >(expected);
         const bool res = core_operations::compare_exchange_weak(this->storage(), old_value, static_cast< storage_type >(desired), success_order, failure_order);
@@ -431,32 +626,39 @@ class base_atomic< T, int, Interprocess > :
     public base_atomic_common< T, atomics::detail::is_signed< T >::value, Interprocess >
 {
 private:
-    typedef base_atomic_common< T, atomics::detail::is_signed< T >::value, Interprocess > base_type;
+    using base_type = base_atomic_common< T, atomics::detail::is_signed< T >::value, Interprocess >;
 
 public:
-    typedef typename base_type::value_type value_type;
-    typedef value_type difference_type;
+    using value_type = typename base_type::value_type;
+    using difference_type = value_type;
 
 protected:
-    typedef typename base_type::core_operations core_operations;
-    typedef typename base_type::wait_operations wait_operations;
-    typedef atomics::detail::extra_operations< core_operations > extra_operations;
-    typedef typename base_type::storage_type storage_type;
-    typedef value_type value_arg_type;
+    using core_operations = typename base_type::core_operations;
+    using wait_operations = typename base_type::wait_operations;
+    using extra_operations = atomics::detail::extra_operations< core_operations >;
+    using storage_type = typename base_type::storage_type;
+    using value_arg_type = value_type;
 
 private:
+    using cxchg_use_bitwise_cast =
 #if !defined(BOOST_ATOMIC_DETAIL_STORAGE_TYPE_MAY_ALIAS) || !defined(BOOST_ATOMIC_NO_CLEAR_PADDING)
-    typedef atomics::detail::true_type cxchg_use_bitwise_cast;
+        std::true_type;
 #else
-    typedef atomics::detail::integral_constant< bool, sizeof(value_type) != sizeof(storage_type) || atomics::detail::alignment_of< value_type >::value <= core_operations::storage_alignment > cxchg_use_bitwise_cast;
+        std::integral_constant<
+            bool,
+            sizeof(value_type) != sizeof(storage_type) || atomics::detail::alignment_of< value_type >::value <= core_operations::storage_alignment
+        >;
 #endif
 
 public:
-    BOOST_DEFAULTED_FUNCTION(base_atomic() BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_DECL, BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_IMPL {})
-    BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_UNION_INIT explicit base_atomic(value_arg_type v) BOOST_NOEXCEPT : base_type(static_cast< storage_type >(v)) {}
+    base_atomic() = default;
+    BOOST_FORCEINLINE constexpr explicit base_atomic(value_arg_type v) noexcept : base_type(static_cast< storage_type >(v)) {}
+
+    base_atomic(base_atomic const&) = delete;
+    base_atomic& operator=(base_atomic const&) = delete;
 
     // Standard methods
-    BOOST_FORCEINLINE void store(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE void store(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         BOOST_ASSERT(order != memory_order_consume);
         BOOST_ASSERT(order != memory_order_acquire);
@@ -465,7 +667,7 @@ public:
         core_operations::store(this->storage(), static_cast< storage_type >(v), order);
     }
 
-    BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile noexcept
     {
         BOOST_ASSERT(order != memory_order_release);
         BOOST_ASSERT(order != memory_order_acq_rel);
@@ -473,22 +675,22 @@ public:
         return atomics::detail::integral_truncate< value_type >(core_operations::load(this->storage(), order));
     }
 
-    BOOST_FORCEINLINE value_type fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return atomics::detail::integral_truncate< value_type >(core_operations::fetch_add(this->storage(), static_cast< storage_type >(v), order));
     }
 
-    BOOST_FORCEINLINE value_type fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return atomics::detail::integral_truncate< value_type >(core_operations::fetch_sub(this->storage(), static_cast< storage_type >(v), order));
     }
 
-    BOOST_FORCEINLINE value_type exchange(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type exchange(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return atomics::detail::integral_truncate< value_type >(core_operations::exchange(this->storage(), static_cast< storage_type >(v), order));
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile noexcept
     {
         BOOST_ASSERT(failure_order != memory_order_release);
         BOOST_ASSERT(failure_order != memory_order_acq_rel);
@@ -497,12 +699,12 @@ public:
         return compare_exchange_strong_impl(expected, desired, success_order, failure_order, cxchg_use_bitwise_cast());
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return compare_exchange_strong(expected, desired, order, atomics::detail::deduce_failure_order(order));
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile noexcept
     {
         BOOST_ASSERT(failure_order != memory_order_release);
         BOOST_ASSERT(failure_order != memory_order_acq_rel);
@@ -511,207 +713,207 @@ public:
         return compare_exchange_weak_impl(expected, desired, success_order, failure_order, cxchg_use_bitwise_cast());
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return compare_exchange_weak(expected, desired, order, atomics::detail::deduce_failure_order(order));
     }
 
-    BOOST_FORCEINLINE value_type fetch_and(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type fetch_and(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return atomics::detail::integral_truncate< value_type >(core_operations::fetch_and(this->storage(), static_cast< storage_type >(v), order));
     }
 
-    BOOST_FORCEINLINE value_type fetch_or(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type fetch_or(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return atomics::detail::integral_truncate< value_type >(core_operations::fetch_or(this->storage(), static_cast< storage_type >(v), order));
     }
 
-    BOOST_FORCEINLINE value_type fetch_xor(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type fetch_xor(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return atomics::detail::integral_truncate< value_type >(core_operations::fetch_xor(this->storage(), static_cast< storage_type >(v), order));
     }
 
     // Boost.Atomic extensions
-    BOOST_FORCEINLINE value_type fetch_negate(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type fetch_negate(memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return atomics::detail::integral_truncate< value_type >(extra_operations::fetch_negate(this->storage(), order));
     }
 
-    BOOST_FORCEINLINE value_type fetch_complement(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type fetch_complement(memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return atomics::detail::integral_truncate< value_type >(extra_operations::fetch_complement(this->storage(), order));
     }
 
-    BOOST_FORCEINLINE value_type add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type add(difference_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return atomics::detail::integral_truncate< value_type >(extra_operations::add(this->storage(), static_cast< storage_type >(v), order));
     }
 
-    BOOST_FORCEINLINE value_type sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type sub(difference_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return atomics::detail::integral_truncate< value_type >(extra_operations::sub(this->storage(), static_cast< storage_type >(v), order));
     }
 
-    BOOST_FORCEINLINE value_type negate(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type negate(memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return atomics::detail::integral_truncate< value_type >(extra_operations::negate(this->storage(), order));
     }
 
-    BOOST_FORCEINLINE value_type bitwise_and(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type bitwise_and(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return atomics::detail::integral_truncate< value_type >(extra_operations::bitwise_and(this->storage(), static_cast< storage_type >(v), order));
     }
 
-    BOOST_FORCEINLINE value_type bitwise_or(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type bitwise_or(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return atomics::detail::integral_truncate< value_type >(extra_operations::bitwise_or(this->storage(), static_cast< storage_type >(v), order));
     }
 
-    BOOST_FORCEINLINE value_type bitwise_xor(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type bitwise_xor(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return atomics::detail::integral_truncate< value_type >(extra_operations::bitwise_xor(this->storage(), static_cast< storage_type >(v), order));
     }
 
-    BOOST_FORCEINLINE value_type bitwise_complement(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type bitwise_complement(memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return atomics::detail::integral_truncate< value_type >(extra_operations::bitwise_complement(this->storage(), order));
     }
 
-    BOOST_FORCEINLINE void opaque_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE void opaque_add(difference_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         extra_operations::opaque_add(this->storage(), static_cast< storage_type >(v), order);
     }
 
-    BOOST_FORCEINLINE void opaque_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE void opaque_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         extra_operations::opaque_sub(this->storage(), static_cast< storage_type >(v), order);
     }
 
-    BOOST_FORCEINLINE void opaque_negate(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE void opaque_negate(memory_order order = memory_order_seq_cst) volatile noexcept
     {
         extra_operations::opaque_negate(this->storage(), order);
     }
 
-    BOOST_FORCEINLINE void opaque_and(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE void opaque_and(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         extra_operations::opaque_and(this->storage(), static_cast< storage_type >(v), order);
     }
 
-    BOOST_FORCEINLINE void opaque_or(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE void opaque_or(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         extra_operations::opaque_or(this->storage(), static_cast< storage_type >(v), order);
     }
 
-    BOOST_FORCEINLINE void opaque_xor(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE void opaque_xor(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         extra_operations::opaque_xor(this->storage(), static_cast< storage_type >(v), order);
     }
 
-    BOOST_FORCEINLINE void opaque_complement(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE void opaque_complement(memory_order order = memory_order_seq_cst) volatile noexcept
     {
         extra_operations::opaque_complement(this->storage(), order);
     }
 
-    BOOST_FORCEINLINE bool add_and_test(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool add_and_test(difference_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return extra_operations::add_and_test(this->storage(), static_cast< storage_type >(v), order);
     }
 
-    BOOST_FORCEINLINE bool sub_and_test(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool sub_and_test(difference_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return extra_operations::sub_and_test(this->storage(), static_cast< storage_type >(v), order);
     }
 
-    BOOST_FORCEINLINE bool negate_and_test(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool negate_and_test(memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return extra_operations::negate_and_test(this->storage(), order);
     }
 
-    BOOST_FORCEINLINE bool and_and_test(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool and_and_test(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return extra_operations::and_and_test(this->storage(), static_cast< storage_type >(v), order);
     }
 
-    BOOST_FORCEINLINE bool or_and_test(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool or_and_test(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return extra_operations::or_and_test(this->storage(), static_cast< storage_type >(v), order);
     }
 
-    BOOST_FORCEINLINE bool xor_and_test(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool xor_and_test(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return extra_operations::xor_and_test(this->storage(), static_cast< storage_type >(v), order);
     }
 
-    BOOST_FORCEINLINE bool complement_and_test(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool complement_and_test(memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return extra_operations::complement_and_test(this->storage(), order);
     }
 
-    BOOST_FORCEINLINE bool bit_test_and_set(unsigned int bit_number, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool bit_test_and_set(unsigned int bit_number, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         BOOST_ASSERT(bit_number < sizeof(value_type) * 8u);
         return extra_operations::bit_test_and_set(this->storage(), bit_number, order);
     }
 
-    BOOST_FORCEINLINE bool bit_test_and_reset(unsigned int bit_number, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool bit_test_and_reset(unsigned int bit_number, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         BOOST_ASSERT(bit_number < sizeof(value_type) * 8u);
         return extra_operations::bit_test_and_reset(this->storage(), bit_number, order);
     }
 
-    BOOST_FORCEINLINE bool bit_test_and_complement(unsigned int bit_number, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool bit_test_and_complement(unsigned int bit_number, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         BOOST_ASSERT(bit_number < sizeof(value_type) * 8u);
         return extra_operations::bit_test_and_complement(this->storage(), bit_number, order);
     }
 
     // Operators
-    BOOST_FORCEINLINE value_type operator++(int) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type operator++(int) volatile noexcept
     {
         return fetch_add(1);
     }
 
-    BOOST_FORCEINLINE value_type operator++() volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type operator++() volatile noexcept
     {
         return add(1);
     }
 
-    BOOST_FORCEINLINE value_type operator--(int) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type operator--(int) volatile noexcept
     {
         return fetch_sub(1);
     }
 
-    BOOST_FORCEINLINE value_type operator--() volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type operator--() volatile noexcept
     {
         return sub(1);
     }
 
-    BOOST_FORCEINLINE value_type operator+=(difference_type v) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type operator+=(difference_type v) volatile noexcept
     {
         return add(v);
     }
 
-    BOOST_FORCEINLINE value_type operator-=(difference_type v) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type operator-=(difference_type v) volatile noexcept
     {
         return sub(v);
     }
 
-    BOOST_FORCEINLINE value_type operator&=(value_type v) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type operator&=(value_type v) volatile noexcept
     {
         return bitwise_and(v);
     }
 
-    BOOST_FORCEINLINE value_type operator|=(value_type v) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type operator|=(value_type v) volatile noexcept
     {
         return bitwise_or(v);
     }
 
-    BOOST_FORCEINLINE value_type operator^=(value_type v) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type operator^=(value_type v) volatile noexcept
     {
         return bitwise_xor(v);
     }
 
-    BOOST_FORCEINLINE value_type wait(value_type old_val, memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type wait(value_arg_type 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);
@@ -719,16 +921,44 @@ public:
         return atomics::detail::integral_truncate< value_type >(wait_operations::wait(this->storage(), static_cast< storage_type >(old_val), order));
     }
 
-    BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&))
-    BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&))
+    template< typename Clock, typename Duration >
+    BOOST_FORCEINLINE wait_result< value_type >
+    wait_until(value_arg_type 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(this->storage(), static_cast< storage_type >(old_val), timeout, order, timed_out);
+        return wait_result< value_type >(atomics::detail::integral_truncate< value_type >(new_value), timed_out);
+    }
+
+    template< typename Rep, typename Period >
+    BOOST_FORCEINLINE wait_result< value_type >
+    wait_for(value_arg_type 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(this->storage(), static_cast< storage_type >(old_val), timeout, order, timed_out);
+        return wait_result< value_type >(atomics::detail::integral_truncate< value_type >(new_value), timed_out);
+    }
 
 private:
-    BOOST_FORCEINLINE bool compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::false_type) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool
+    compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, std::false_type) volatile noexcept
     {
-        return core_operations::compare_exchange_strong(this->storage(), reinterpret_cast< storage_type& >(expected), static_cast< storage_type >(desired), success_order, failure_order);
+        return core_operations::compare_exchange_strong(
+            this->storage(), reinterpret_cast< storage_type& >(expected), static_cast< storage_type >(desired), success_order, failure_order);
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::true_type) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool
+    compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, std::true_type) volatile noexcept
     {
         storage_type old_value = static_cast< storage_type >(expected);
         const bool res = core_operations::compare_exchange_strong(this->storage(), old_value, static_cast< storage_type >(desired), success_order, failure_order);
@@ -736,12 +966,15 @@ private:
         return res;
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::false_type) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool
+    compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, std::false_type) volatile noexcept
     {
-        return core_operations::compare_exchange_weak(this->storage(), reinterpret_cast< storage_type& >(expected), static_cast< storage_type >(desired), success_order, failure_order);
+        return core_operations::compare_exchange_weak(
+            this->storage(), reinterpret_cast< storage_type& >(expected), static_cast< storage_type >(desired), success_order, failure_order);
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::true_type) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool
+    compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, std::true_type) volatile noexcept
     {
         storage_type old_value = static_cast< storage_type >(expected);
         const bool res = core_operations::compare_exchange_weak(this->storage(), old_value, static_cast< storage_type >(desired), success_order, failure_order);
@@ -756,30 +989,37 @@ class base_atomic< bool, int, Interprocess > :
     public base_atomic_common< bool, false, Interprocess >
 {
 private:
-    typedef base_atomic_common< bool, false, Interprocess > base_type;
+    using base_type = base_atomic_common< bool, false, Interprocess >;
 
 public:
-    typedef typename base_type::value_type value_type;
+    using value_type = typename base_type::value_type;
 
 protected:
-    typedef typename base_type::core_operations core_operations;
-    typedef typename base_type::wait_operations wait_operations;
-    typedef typename base_type::storage_type storage_type;
-    typedef value_type value_arg_type;
+    using core_operations = typename base_type::core_operations;
+    using wait_operations = typename base_type::wait_operations;
+    using storage_type = typename base_type::storage_type;
+    using value_arg_type = value_type;
 
 private:
+    using cxchg_use_bitwise_cast =
 #if !defined(BOOST_ATOMIC_DETAIL_STORAGE_TYPE_MAY_ALIAS) || !defined(BOOST_ATOMIC_NO_CLEAR_PADDING)
-    typedef atomics::detail::true_type cxchg_use_bitwise_cast;
+        std::true_type;
 #else
-    typedef atomics::detail::integral_constant< bool, sizeof(value_type) != sizeof(storage_type) || atomics::detail::alignment_of< value_type >::value <= core_operations::storage_alignment > cxchg_use_bitwise_cast;
+        std::integral_constant<
+            bool,
+            sizeof(value_type) != sizeof(storage_type) || atomics::detail::alignment_of< value_type >::value <= core_operations::storage_alignment
+        >;
 #endif
 
 public:
-    BOOST_DEFAULTED_FUNCTION(base_atomic() BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_DECL, BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_IMPL {})
-    BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_UNION_INIT explicit base_atomic(value_arg_type v) BOOST_NOEXCEPT : base_type(static_cast< storage_type >(v)) {}
+    base_atomic() = default;
+    BOOST_FORCEINLINE constexpr explicit base_atomic(value_arg_type v) noexcept : base_type(static_cast< storage_type >(v)) {}
+
+    base_atomic(base_atomic const&) = delete;
+    base_atomic& operator=(base_atomic const&) = delete;
 
     // Standard methods
-    BOOST_FORCEINLINE void store(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE void store(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         BOOST_ASSERT(order != memory_order_consume);
         BOOST_ASSERT(order != memory_order_acquire);
@@ -788,7 +1028,7 @@ public:
         core_operations::store(this->storage(), static_cast< storage_type >(v), order);
     }
 
-    BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile noexcept
     {
         BOOST_ASSERT(order != memory_order_release);
         BOOST_ASSERT(order != memory_order_acq_rel);
@@ -796,12 +1036,12 @@ public:
         return !!core_operations::load(this->storage(), order);
     }
 
-    BOOST_FORCEINLINE value_type exchange(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type exchange(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return !!core_operations::exchange(this->storage(), static_cast< storage_type >(v), order);
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile noexcept
     {
         BOOST_ASSERT(failure_order != memory_order_release);
         BOOST_ASSERT(failure_order != memory_order_acq_rel);
@@ -810,12 +1050,12 @@ public:
         return compare_exchange_strong_impl(expected, desired, success_order, failure_order, cxchg_use_bitwise_cast());
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return compare_exchange_strong(expected, desired, order, atomics::detail::deduce_failure_order(order));
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile noexcept
     {
         BOOST_ASSERT(failure_order != memory_order_release);
         BOOST_ASSERT(failure_order != memory_order_acq_rel);
@@ -824,12 +1064,12 @@ public:
         return compare_exchange_weak_impl(expected, desired, success_order, failure_order, cxchg_use_bitwise_cast());
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return compare_exchange_weak(expected, desired, order, atomics::detail::deduce_failure_order(order));
     }
 
-    BOOST_FORCEINLINE value_type wait(value_type old_val, memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type wait(value_arg_type 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);
@@ -837,16 +1077,44 @@ public:
         return !!wait_operations::wait(this->storage(), static_cast< storage_type >(old_val), order);
     }
 
-    BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&))
-    BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&))
+    template< typename Clock, typename Duration >
+    BOOST_FORCEINLINE wait_result< value_type >
+    wait_until(value_arg_type 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(this->storage(), static_cast< storage_type >(old_val), timeout, order, timed_out);
+        return wait_result< value_type >(!!new_value, timed_out);
+    }
+
+    template< typename Rep, typename Period >
+    BOOST_FORCEINLINE wait_result< value_type >
+    wait_for(value_arg_type 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(this->storage(), static_cast< storage_type >(old_val), timeout, order, timed_out);
+        return wait_result< value_type >(!!new_value, timed_out);
+    }
 
 private:
-    BOOST_FORCEINLINE bool compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::false_type) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool
+    compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, std::false_type) volatile noexcept
     {
-        return core_operations::compare_exchange_strong(this->storage(), reinterpret_cast< storage_type& >(expected), static_cast< storage_type >(desired), success_order, failure_order);
+        return core_operations::compare_exchange_strong(
+            this->storage(), reinterpret_cast< storage_type& >(expected), static_cast< storage_type >(desired), success_order, failure_order);
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::true_type) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool
+    compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, std::true_type) volatile noexcept
     {
         storage_type old_value = static_cast< storage_type >(expected);
         const bool res = core_operations::compare_exchange_strong(this->storage(), old_value, static_cast< storage_type >(desired), success_order, failure_order);
@@ -854,12 +1122,15 @@ private:
         return res;
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::false_type) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool
+    compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, std::false_type) volatile noexcept
     {
-        return core_operations::compare_exchange_weak(this->storage(), reinterpret_cast< storage_type& >(expected), static_cast< storage_type >(desired), success_order, failure_order);
+        return core_operations::compare_exchange_weak(
+            this->storage(), reinterpret_cast< storage_type& >(expected), static_cast< storage_type >(desired), success_order, failure_order);
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::true_type) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool
+    compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, std::true_type) volatile noexcept
     {
         storage_type old_value = static_cast< storage_type >(expected);
         const bool res = core_operations::compare_exchange_weak(this->storage(), old_value, static_cast< storage_type >(desired), success_order, failure_order);
@@ -877,38 +1148,44 @@ class base_atomic< T, float, Interprocess > :
     public base_atomic_common< T, false, Interprocess >
 {
 private:
-    typedef base_atomic_common< T, false, Interprocess > base_type;
+    using base_type = base_atomic_common< T, false, Interprocess >;
 
 public:
-    typedef typename base_type::value_type value_type;
-    typedef value_type difference_type;
+    using value_type = typename base_type::value_type;
+    using difference_type = value_type;
 
 protected:
-    typedef typename base_type::core_operations core_operations;
-    typedef typename base_type::wait_operations wait_operations;
-    typedef atomics::detail::extra_operations< core_operations > extra_operations;
-    typedef atomics::detail::fp_operations< extra_operations, value_type > fp_operations;
-    typedef atomics::detail::extra_fp_operations< fp_operations > extra_fp_operations;
-    typedef typename base_type::storage_type storage_type;
-    typedef value_type value_arg_type;
+    using core_operations = typename base_type::core_operations;
+    using wait_operations = typename base_type::wait_operations;
+    using extra_operations = atomics::detail::extra_operations< core_operations >;
+    using fp_operations = atomics::detail::fp_operations< extra_operations, value_type >;
+    using extra_fp_operations = atomics::detail::extra_fp_operations< fp_operations >;
+    using storage_type = typename base_type::storage_type;
+    using value_arg_type = value_type;
 
 private:
+    using cxchg_use_bitwise_cast =
 #if !defined(BOOST_ATOMIC_DETAIL_STORAGE_TYPE_MAY_ALIAS) || !defined(BOOST_ATOMIC_NO_CLEAR_PADDING)
-    typedef atomics::detail::true_type cxchg_use_bitwise_cast;
+        std::true_type;
 #else
-    typedef atomics::detail::integral_constant< bool,
-        atomics::detail::value_size_of< value_type >::value != sizeof(storage_type) || atomics::detail::alignment_of< value_type >::value <= core_operations::storage_alignment
-    > cxchg_use_bitwise_cast;
+        std::integral_constant<
+            bool,
+            atomics::detail::value_size_of< value_type >::value != sizeof(storage_type) ||
+                atomics::detail::alignment_of< value_type >::value <= core_operations::storage_alignment
+        >;
 #endif
 
 public:
-    BOOST_DEFAULTED_FUNCTION(base_atomic() BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_DECL, BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_IMPL {})
-    BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_ATOMIC_CTOR explicit base_atomic(value_arg_type v) BOOST_NOEXCEPT :
+    base_atomic() = default;
+    BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_ATOMIC_CTOR explicit base_atomic(value_arg_type v) noexcept :
         base_type(atomics::detail::bitwise_fp_cast< storage_type >(v))
     {
     }
 
-    BOOST_FORCEINLINE void store(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    base_atomic(base_atomic const&) = delete;
+    base_atomic& operator=(base_atomic const&) = delete;
+
+    BOOST_FORCEINLINE void store(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         BOOST_ASSERT(order != memory_order_consume);
         BOOST_ASSERT(order != memory_order_acquire);
@@ -917,7 +1194,7 @@ public:
         core_operations::store(this->storage(), atomics::detail::bitwise_fp_cast< storage_type >(v), order);
     }
 
-    BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile noexcept
     {
         BOOST_ASSERT(order != memory_order_release);
         BOOST_ASSERT(order != memory_order_acq_rel);
@@ -925,22 +1202,22 @@ public:
         return atomics::detail::bitwise_fp_cast< value_type >(core_operations::load(this->storage(), order));
     }
 
-    BOOST_FORCEINLINE value_type fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return fp_operations::fetch_add(this->storage(), v, order);
     }
 
-    BOOST_FORCEINLINE value_type fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return fp_operations::fetch_sub(this->storage(), v, order);
     }
 
-    BOOST_FORCEINLINE value_type exchange(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type exchange(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return atomics::detail::bitwise_fp_cast< value_type >(core_operations::exchange(this->storage(), atomics::detail::bitwise_fp_cast< storage_type >(v), order));
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile noexcept
     {
         BOOST_ASSERT(failure_order != memory_order_release);
         BOOST_ASSERT(failure_order != memory_order_acq_rel);
@@ -949,12 +1226,12 @@ public:
         return compare_exchange_strong_impl(expected, desired, success_order, failure_order, cxchg_use_bitwise_cast());
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return compare_exchange_strong(expected, desired, order, atomics::detail::deduce_failure_order(order));
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile noexcept
     {
         BOOST_ASSERT(failure_order != memory_order_release);
         BOOST_ASSERT(failure_order != memory_order_acq_rel);
@@ -963,59 +1240,59 @@ public:
         return compare_exchange_weak_impl(expected, desired, success_order, failure_order, cxchg_use_bitwise_cast());
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return compare_exchange_weak(expected, desired, order, atomics::detail::deduce_failure_order(order));
     }
 
     // Boost.Atomic extensions
-    BOOST_FORCEINLINE value_type fetch_negate(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type fetch_negate(memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return extra_fp_operations::fetch_negate(this->storage(), order);
     }
 
-    BOOST_FORCEINLINE value_type add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type add(difference_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return extra_fp_operations::add(this->storage(), v, order);
     }
 
-    BOOST_FORCEINLINE value_type sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type sub(difference_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return extra_fp_operations::sub(this->storage(), v, order);
     }
 
-    BOOST_FORCEINLINE value_type negate(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type negate(memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return extra_fp_operations::negate(this->storage(), order);
     }
 
-    BOOST_FORCEINLINE void opaque_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE void opaque_add(difference_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         extra_fp_operations::opaque_add(this->storage(), v, order);
     }
 
-    BOOST_FORCEINLINE void opaque_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE void opaque_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         extra_fp_operations::opaque_sub(this->storage(), v, order);
     }
 
-    BOOST_FORCEINLINE void opaque_negate(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE void opaque_negate(memory_order order = memory_order_seq_cst) volatile noexcept
     {
         extra_fp_operations::opaque_negate(this->storage(), order);
     }
 
     // Operators
-    BOOST_FORCEINLINE value_type operator+=(difference_type v) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type operator+=(difference_type v) volatile noexcept
     {
         return add(v);
     }
 
-    BOOST_FORCEINLINE value_type operator-=(difference_type v) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type operator-=(difference_type v) volatile noexcept
     {
         return sub(v);
     }
 
-    BOOST_FORCEINLINE value_type wait(value_arg_type old_val, memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type wait(value_arg_type 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);
@@ -1023,32 +1300,65 @@ public:
         return atomics::detail::bitwise_fp_cast< value_type >(wait_operations::wait(this->storage(), atomics::detail::bitwise_fp_cast< storage_type >(old_val), order));
     }
 
-    BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&))
-    BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&))
+    template< typename Clock, typename Duration >
+    BOOST_FORCEINLINE wait_result< value_type >
+    wait_until(value_arg_type 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(this->storage(), atomics::detail::bitwise_fp_cast< storage_type >(old_val), timeout, order, timed_out);
+        return wait_result< value_type >(atomics::detail::bitwise_fp_cast< value_type >(new_value), timed_out);
+    }
+
+    template< typename Rep, typename Period >
+    BOOST_FORCEINLINE wait_result< value_type >
+    wait_for(value_arg_type 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(this->storage(), atomics::detail::bitwise_fp_cast< storage_type >(old_val), timeout, order, timed_out);
+        return wait_result< value_type >(atomics::detail::bitwise_fp_cast< value_type >(new_value), timed_out);
+    }
 
 private:
-    BOOST_FORCEINLINE bool compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::false_type) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool
+    compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, std::false_type) volatile noexcept
     {
-        return core_operations::compare_exchange_strong(this->storage(), reinterpret_cast< storage_type& >(expected), atomics::detail::bitwise_fp_cast< storage_type >(desired), success_order, failure_order);
+        return core_operations::compare_exchange_strong(
+            this->storage(), reinterpret_cast< storage_type& >(expected), atomics::detail::bitwise_fp_cast< storage_type >(desired), success_order, failure_order);
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::true_type) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool
+    compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, std::true_type) volatile noexcept
     {
         storage_type old_value = atomics::detail::bitwise_fp_cast< storage_type >(expected);
-        const bool res = core_operations::compare_exchange_strong(this->storage(), old_value, atomics::detail::bitwise_fp_cast< storage_type >(desired), success_order, failure_order);
+        const bool res = core_operations::compare_exchange_strong(
+            this->storage(), old_value, atomics::detail::bitwise_fp_cast< storage_type >(desired), success_order, failure_order);
         expected = atomics::detail::bitwise_fp_cast< value_type >(old_value);
         return res;
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::false_type) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool
+    compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, std::false_type) volatile noexcept
     {
-        return core_operations::compare_exchange_weak(this->storage(), reinterpret_cast< storage_type& >(expected), atomics::detail::bitwise_fp_cast< storage_type >(desired), success_order, failure_order);
+        return core_operations::compare_exchange_weak(
+            this->storage(), reinterpret_cast< storage_type& >(expected), atomics::detail::bitwise_fp_cast< storage_type >(desired), success_order, failure_order);
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::true_type) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool
+    compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, std::true_type) volatile noexcept
     {
         storage_type old_value = atomics::detail::bitwise_fp_cast< storage_type >(expected);
-        const bool res = core_operations::compare_exchange_weak(this->storage(), old_value, atomics::detail::bitwise_fp_cast< storage_type >(desired), success_order, failure_order);
+        const bool res = core_operations::compare_exchange_weak(
+            this->storage(), old_value, atomics::detail::bitwise_fp_cast< storage_type >(desired), success_order, failure_order);
         expected = atomics::detail::bitwise_fp_cast< value_type >(old_value);
         return res;
     }
@@ -1063,39 +1373,46 @@ class base_atomic< T*, void*, Interprocess > :
     public base_atomic_common< T*, false, Interprocess >
 {
 private:
-    typedef base_atomic_common< T*, false, Interprocess > base_type;
+    using base_type = base_atomic_common< T*, false, Interprocess >;
 
 public:
-    typedef typename base_type::value_type value_type;
-    typedef std::ptrdiff_t difference_type;
+    using value_type = typename base_type::value_type;
+    using difference_type = std::ptrdiff_t;
 
 protected:
-    typedef typename base_type::core_operations core_operations;
-    typedef typename base_type::wait_operations wait_operations;
-    typedef atomics::detail::extra_operations< core_operations > extra_operations;
-    typedef typename base_type::storage_type storage_type;
-    typedef value_type value_arg_type;
+    using core_operations = typename base_type::core_operations;
+    using wait_operations = typename base_type::wait_operations;
+    using extra_operations = atomics::detail::extra_operations< core_operations >;
+    using storage_type = typename base_type::storage_type;
+    using value_arg_type = value_type;
 
 private:
+    using cxchg_use_bitwise_cast =
 #if !defined(BOOST_ATOMIC_DETAIL_STORAGE_TYPE_MAY_ALIAS) || !defined(BOOST_ATOMIC_NO_CLEAR_PADDING)
-    typedef atomics::detail::true_type cxchg_use_bitwise_cast;
+        std::true_type;
 #else
-    typedef atomics::detail::integral_constant< bool, sizeof(value_type) != sizeof(storage_type) || atomics::detail::alignment_of< value_type >::value <= core_operations::storage_alignment > cxchg_use_bitwise_cast;
+        std::integral_constant<
+            bool,
+            sizeof(value_type) != sizeof(storage_type) || atomics::detail::alignment_of< value_type >::value <= core_operations::storage_alignment
+        >;
 #endif
 
     // uintptr_storage_type is the minimal storage type that is enough to store pointers. The actual storage_type theoretically may be larger,
     // if the target architecture only supports atomic ops on larger data. Typically, though, they are the same type.
-    typedef atomics::detail::uintptr_t uintptr_storage_type;
+    using uintptr_storage_type = atomics::detail::uintptr_t;
 
 public:
-    BOOST_DEFAULTED_FUNCTION(base_atomic() BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_DECL, BOOST_ATOMIC_DETAIL_DEF_NOEXCEPT_IMPL {})
-    BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_ATOMIC_CTOR explicit base_atomic(value_arg_type v) BOOST_NOEXCEPT :
+    base_atomic() = default;
+    BOOST_FORCEINLINE BOOST_ATOMIC_DETAIL_CONSTEXPR_ATOMIC_CTOR explicit base_atomic(value_arg_type v) noexcept :
         base_type(atomics::detail::bitwise_cast< uintptr_storage_type >(v))
     {
     }
 
+    base_atomic(base_atomic const&) = delete;
+    base_atomic& operator=(base_atomic const&) = delete;
+
     // Standard methods
-    BOOST_FORCEINLINE void store(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE void store(value_arg_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         BOOST_ASSERT(order != memory_order_consume);
         BOOST_ASSERT(order != memory_order_acquire);
@@ -1104,7 +1421,7 @@ public:
         core_operations::store(this->storage(), atomics::detail::bitwise_cast< uintptr_storage_type >(v), order);
     }
 
-    BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile noexcept
     {
         BOOST_ASSERT(order != memory_order_release);
         BOOST_ASSERT(order != memory_order_acq_rel);
@@ -1112,22 +1429,25 @@ public:
         return atomics::detail::bitwise_cast< value_type >(static_cast< uintptr_storage_type >(core_operations::load(this->storage(), order)));
     }
 
-    BOOST_FORCEINLINE value_type fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
-        return atomics::detail::bitwise_cast< value_type >(static_cast< uintptr_storage_type >(core_operations::fetch_add(this->storage(), static_cast< uintptr_storage_type >(v * sizeof(T)), order)));
+        return atomics::detail::bitwise_cast< value_type >(static_cast< uintptr_storage_type >(
+            core_operations::fetch_add(this->storage(), static_cast< uintptr_storage_type >(v * sizeof(T)), order)));
     }
 
-    BOOST_FORCEINLINE value_type fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
-        return atomics::detail::bitwise_cast< value_type >(static_cast< uintptr_storage_type >(core_operations::fetch_sub(this->storage(), static_cast< uintptr_storage_type >(v * sizeof(T)), order)));
+        return atomics::detail::bitwise_cast< value_type >(static_cast< uintptr_storage_type >(
+            core_operations::fetch_sub(this->storage(), static_cast< uintptr_storage_type >(v * sizeof(T)), order)));
     }
 
-    BOOST_FORCEINLINE value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
-        return atomics::detail::bitwise_cast< value_type >(static_cast< uintptr_storage_type >(core_operations::exchange(this->storage(), atomics::detail::bitwise_cast< uintptr_storage_type >(v), order)));
+        return atomics::detail::bitwise_cast< value_type >(static_cast< uintptr_storage_type >(
+            core_operations::exchange(this->storage(), atomics::detail::bitwise_cast< uintptr_storage_type >(v), order)));
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile noexcept
     {
         BOOST_ASSERT(failure_order != memory_order_release);
         BOOST_ASSERT(failure_order != memory_order_acq_rel);
@@ -1136,12 +1456,12 @@ public:
         return compare_exchange_strong_impl(expected, desired, success_order, failure_order, cxchg_use_bitwise_cast());
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return compare_exchange_strong(expected, desired, order, atomics::detail::deduce_failure_order(order));
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile noexcept
     {
         BOOST_ASSERT(failure_order != memory_order_release);
         BOOST_ASSERT(failure_order != memory_order_acq_rel);
@@ -1150,107 +1470,143 @@ public:
         return compare_exchange_weak_impl(expected, desired, success_order, failure_order, cxchg_use_bitwise_cast());
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return compare_exchange_weak(expected, desired, order, atomics::detail::deduce_failure_order(order));
     }
 
     // Boost.Atomic extensions
-    BOOST_FORCEINLINE value_type add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type add(difference_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
-        return atomics::detail::bitwise_cast< value_type >(static_cast< uintptr_storage_type >(extra_operations::add(this->storage(), static_cast< uintptr_storage_type >(v * sizeof(T)), order)));
+        return atomics::detail::bitwise_cast< value_type >(static_cast< uintptr_storage_type >(
+            extra_operations::add(this->storage(), static_cast< uintptr_storage_type >(v * sizeof(T)), order)));
     }
 
-    BOOST_FORCEINLINE value_type sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type sub(difference_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
-        return atomics::detail::bitwise_cast< value_type >(static_cast< uintptr_storage_type >(extra_operations::sub(this->storage(), static_cast< uintptr_storage_type >(v * sizeof(T)), order)));
+        return atomics::detail::bitwise_cast< value_type >(static_cast< uintptr_storage_type >(
+            extra_operations::sub(this->storage(), static_cast< uintptr_storage_type >(v * sizeof(T)), order)));
     }
 
-    BOOST_FORCEINLINE void opaque_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE void opaque_add(difference_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         extra_operations::opaque_add(this->storage(), static_cast< uintptr_storage_type >(v * sizeof(T)), order);
     }
 
-    BOOST_FORCEINLINE void opaque_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE void opaque_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         extra_operations::opaque_sub(this->storage(), static_cast< uintptr_storage_type >(v * sizeof(T)), order);
     }
 
-    BOOST_FORCEINLINE bool add_and_test(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool add_and_test(difference_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return extra_operations::add_and_test(this->storage(), static_cast< uintptr_storage_type >(v * sizeof(T)), order);
     }
 
-    BOOST_FORCEINLINE bool sub_and_test(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool sub_and_test(difference_type v, memory_order order = memory_order_seq_cst) volatile noexcept
     {
         return extra_operations::sub_and_test(this->storage(), static_cast< uintptr_storage_type >(v * sizeof(T)), order);
     }
 
     // Operators
-    BOOST_FORCEINLINE value_type operator++(int) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type operator++(int) volatile noexcept
     {
         return fetch_add(1);
     }
 
-    BOOST_FORCEINLINE value_type operator++() volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type operator++() volatile noexcept
     {
         return add(1);
     }
 
-    BOOST_FORCEINLINE value_type operator--(int) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type operator--(int) volatile noexcept
     {
         return fetch_sub(1);
     }
 
-    BOOST_FORCEINLINE value_type operator--() volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type operator--() volatile noexcept
     {
         return sub(1);
     }
 
-    BOOST_FORCEINLINE value_type operator+=(difference_type v) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type operator+=(difference_type v) volatile noexcept
     {
         return add(v);
     }
 
-    BOOST_FORCEINLINE value_type operator-=(difference_type v) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type operator-=(difference_type v) volatile noexcept
     {
         return sub(v);
     }
 
-    BOOST_FORCEINLINE value_type wait(value_arg_type old_val, memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE value_type wait(value_arg_type 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);
 
-        return atomics::detail::bitwise_cast< value_type >(static_cast< uintptr_storage_type >(wait_operations::wait(this->storage(), atomics::detail::bitwise_cast< uintptr_storage_type >(old_val), order)));
+        return atomics::detail::bitwise_cast< value_type >(static_cast< uintptr_storage_type >(
+            wait_operations::wait(this->storage(), atomics::detail::bitwise_cast< uintptr_storage_type >(old_val), order)));
     }
 
-    BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&))
-    BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&))
+    template< typename Clock, typename Duration >
+    BOOST_FORCEINLINE wait_result< value_type >
+    wait_until(value_arg_type 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(this->storage(), atomics::detail::bitwise_cast< uintptr_storage_type >(old_val), timeout, order, timed_out);
+        return wait_result< value_type >(atomics::detail::bitwise_cast< value_type >(new_value), timed_out);
+    }
+
+    template< typename Rep, typename Period >
+    BOOST_FORCEINLINE wait_result< value_type >
+    wait_for(value_arg_type 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(this->storage(), atomics::detail::bitwise_cast< uintptr_storage_type >(old_val), timeout, order, timed_out);
+        return wait_result< value_type >(atomics::detail::bitwise_cast< value_type >(new_value), timed_out);
+    }
 
 private:
-    BOOST_FORCEINLINE bool compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::false_type) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool
+    compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, std::false_type) volatile noexcept
     {
-        return core_operations::compare_exchange_strong(this->storage(), reinterpret_cast< storage_type& >(expected), atomics::detail::bitwise_cast< uintptr_storage_type >(desired), success_order, failure_order);
+        return core_operations::compare_exchange_strong(
+            this->storage(), reinterpret_cast< storage_type& >(expected), atomics::detail::bitwise_cast< uintptr_storage_type >(desired), success_order, failure_order);
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::true_type) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool
+    compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, std::true_type) volatile noexcept
     {
         storage_type old_value = atomics::detail::bitwise_cast< uintptr_storage_type >(expected);
-        const bool res = core_operations::compare_exchange_strong(this->storage(), old_value, atomics::detail::bitwise_cast< uintptr_storage_type >(desired), success_order, failure_order);
+        const bool res = core_operations::compare_exchange_strong(
+            this->storage(), old_value, atomics::detail::bitwise_cast< uintptr_storage_type >(desired), success_order, failure_order);
         expected = atomics::detail::bitwise_cast< value_type >(static_cast< uintptr_storage_type >(old_value));
         return res;
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::false_type) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool
+    compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, std::false_type) volatile noexcept
     {
-        return core_operations::compare_exchange_weak(this->storage(), reinterpret_cast< storage_type& >(expected), atomics::detail::bitwise_cast< uintptr_storage_type >(desired), success_order, failure_order);
+        return core_operations::compare_exchange_weak(
+            this->storage(), reinterpret_cast< storage_type& >(expected), atomics::detail::bitwise_cast< uintptr_storage_type >(desired), success_order, failure_order);
     }
 
-    BOOST_FORCEINLINE bool compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, atomics::detail::true_type) volatile BOOST_NOEXCEPT
+    BOOST_FORCEINLINE bool
+    compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, std::true_type) volatile noexcept
     {
         storage_type old_value = atomics::detail::bitwise_cast< uintptr_storage_type >(expected);
-        const bool res = core_operations::compare_exchange_weak(this->storage(), old_value, atomics::detail::bitwise_cast< uintptr_storage_type >(desired), success_order, failure_order);
+        const bool res = core_operations::compare_exchange_weak(
+            this->storage(), old_value, atomics::detail::bitwise_cast< uintptr_storage_type >(desired), success_order, failure_order);
         expected = atomics::detail::bitwise_cast< value_type >(static_cast< uintptr_storage_type >(old_value));
         return res;
     }