"`3737 <https://wg21.link/LWG3737>`__","``take_view::sentinel`` should provide ``operator-``", "November 2022","","","|ranges|"
"`3738 <https://wg21.link/LWG3738>`__","Missing preconditions for ``take_view`` constructor", "November 2022","","","|ranges|"
"`3743 <https://wg21.link/LWG3743>`__","``ranges::to``'s reserve may be ill-formed", "November 2022","","","|ranges|"
-"`3745 <https://wg21.link/LWG3745>`__","``std::atomic_wait`` and its friends lack ``noexcept``", "November 2022","","",""
+"`3745 <https://wg21.link/LWG3745>`__","``std::atomic_wait`` and its friends lack ``noexcept``", "November 2022","|Complete|","16.0",""
"`3746 <https://wg21.link/LWG3746>`__","``optional``'s spaceship with ``U`` with a type derived from optional causes infinite constraint meta-recursion", "November 2022","","","|spaceship|"
"`3747 <https://wg21.link/LWG3747>`__","``ranges::uninitialized_copy_n``, ``ranges::uninitialized_move_n``, and ``ranges::destroy_n`` should use ``std::move``", "November 2022","","","|ranges|"
"`3750 <https://wg21.link/LWG3750>`__","Too many papers bump ``__cpp_lib_format``", "November 2022","","","|format|"
memory_order) noexcept;
template<class T>
- void atomic_wait(const volatile atomic<T>*, atomic<T>::value_type);
+ void atomic_wait(const volatile atomic<T>*, atomic<T>::value_type) noexcept;
template<class T>
- void atomic_wait(const atomic<T>*, atomic<T>::value_type);
+ void atomic_wait(const atomic<T>*, atomic<T>::value_type) noexcept;
template<class T>
void atomic_wait_explicit(const volatile atomic<T>*, atomic<T>::value_type,
- memory_order);
+ memory_order) noexcept;
template<class T>
void atomic_wait_explicit(const atomic<T>*, atomic<T>::value_type,
- memory_order);
+ memory_order) noexcept;
template<class T>
- void atomic_notify_one(volatile atomic<T>*);
+ void atomic_notify_one(volatile atomic<T>*) noexcept;
template<class T>
- void atomic_notify_one(atomic<T>*);
+ void atomic_notify_one(atomic<T>*) noexcept;
template<class T>
- void atomic_notify_all(volatile atomic<T>*);
+ void atomic_notify_all(volatile atomic<T>*) noexcept;
template<class T>
- void atomic_notify_all(atomic<T>*);
+ void atomic_notify_all(atomic<T>*) noexcept;
// Atomics for standard typedef types
__o->notify_one();
}
-// atomic_notify_one
+// atomic_notify_all
template <class _Tp>
_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
// template<class T>
// void
-// atomic_notify_all(volatile atomic<T>*);
+// atomic_notify_all(volatile atomic<T>*) noexcept;
//
// template<class T>
// void
-// atomic_notify_all(atomic<T>*);
+// atomic_notify_all(atomic<T>*) noexcept;
#include <atomic>
#include <type_traits>
{
A a(T(1));
+ static_assert(noexcept(std::atomic_notify_all(&a)), "");
auto f = [&]() {
assert(std::atomic_load(&a) == T(1));
std::atomic_wait(&a, T(1));
}
{
volatile A a(T(2));
+ static_assert(noexcept(std::atomic_notify_all(&a)), "");
auto f = [&]() {
assert(std::atomic_load(&a) == T(2));
std::atomic_wait(&a, T(2));
// template<class T>
// void
-// atomic_notify_one(volatile atomic<T>*);
+// atomic_notify_one(volatile atomic<T>*) noexcept;
//
// template<class T>
// void
-// atomic_notify_one(atomic<T>*);
+// atomic_notify_one(atomic<T>*) noexcept;
#include <atomic>
#include <type_traits>
{
A a(T(1));
+ static_assert(noexcept(std::atomic_notify_one(&a)), "");
std::thread t = support::make_test_thread([&]() {
std::atomic_store(&a, T(3));
std::atomic_notify_one(&a);
}
{
volatile A a(T(2));
+ static_assert(noexcept(std::atomic_notify_one(&a)), "");
std::thread t = support::make_test_thread([&]() {
std::atomic_store(&a, T(4));
std::atomic_notify_one(&a);
// template<class T>
// void
-// atomic_wait(const volatile atomic<T>*, atomic<T>::value_type);
+// atomic_wait(const volatile atomic<T>*, atomic<T>::value_type) noexcept;
//
// template<class T>
// void
-// atomic_wait(const atomic<T>*, atomic<T>::value_type);
+// atomic_wait(const atomic<T>*, atomic<T>::value_type) noexcept;
#include <atomic>
#include <type_traits>
typedef std::atomic<T> A;
{
A t(T(1));
+ static_assert(noexcept(std::atomic_wait(&t, T(0))), "");
assert(std::atomic_load(&t) == T(1));
std::atomic_wait(&t, T(0));
std::thread t1 = support::make_test_thread([&]() {
}
{
volatile A vt(T(2));
+ static_assert(noexcept(std::atomic_wait(&vt, T(0))), "");
assert(std::atomic_load(&vt) == T(2));
std::atomic_wait(&vt, T(1));
std::thread t2 = support::make_test_thread([&]() {
// template<class T>
// void
// atomic_wait_explicit(const volatile atomic<T>*, atomic<T>::value_type,
-// memory_order);
+// memory_order) noexcept;
//
// template<class T>
// void
// atomic_wait_explicit(const volatile atomic<T>*, atomic<T>::value_type,
-// memory_order);
+// memory_order) noexcept;
#include <atomic>
#include <type_traits>
typedef std::atomic<T> A;
{
A t(T(1));
+ static_assert(noexcept(std::atomic_wait_explicit(&t, T(0), std::memory_order_seq_cst)), "");
assert(std::atomic_load(&t) == T(1));
std::atomic_wait_explicit(&t, T(0), std::memory_order_seq_cst);
std::thread t1 = support::make_test_thread([&]() {
}
{
volatile A vt(T(2));
+ static_assert(noexcept(std::atomic_wait_explicit(&vt, T(0), std::memory_order_seq_cst)), "");
assert(std::atomic_load(&vt) == T(2));
std::atomic_wait_explicit(&vt, T(1), std::memory_order_seq_cst);
std::thread t2 = support::make_test_thread([&]() {