This also updates the moved code to the current style. (i.e. `_VSTD` -> `std`, `_LIBCPP_INLINE_VISIBILITY` -> `_LIBCPP_HIDE_FROM_ABI`, clang-format).
Reviewed By: Mordante, #libc, EricWF
Spies: arichardson, libcxx-commits, mikhail.ramalho
Differential Revision: https://reviews.llvm.org/D146228
includes are removed based on the language version used. Incidental transitive
inclusions of the following headers have been removed:
- - C++2b: ``atomic``, ``bit``, ``cstring``, ``type_traits``
+ - C++2b: ``atomic``, ``bit``, ``cstdint``, ``cstdlib``, ``cstring``, ``initializer_list``, ``new``, ``stdexcept``,
+ ``type_traits``, ``typeinfo``
- The headers ``<experimental/algorithm>`` and ``<experimental/functional>`` have been removed, since all the contents
have been implemented in namespace ``std`` for at least two releases.
__concepts/semiregular.h
__concepts/swappable.h
__concepts/totally_ordered.h
+ __condition_variable/condition_variable.h
__config
__coroutine/coroutine_handle.h
__coroutine/coroutine_traits.h
__memory_resource/pool_options.h
__memory_resource/synchronized_pool_resource.h
__memory_resource/unsynchronized_pool_resource.h
- __mutex_base
+ __mutex/lock_guard.h
+ __mutex/mutex.h
+ __mutex/tag_types.h
+ __mutex/unique_lock.h
__node_handle
__numeric/accumulate.h
__numeric/adjacent_difference.h
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CONDITION_VARIABLE_CONDITION_VARIABLE_H
+#define _LIBCPP___CONDITION_VARIABLE_CONDITION_VARIABLE_H
+
+#include <__chrono/steady_clock.h>
+#include <__chrono/system_clock.h>
+#include <__chrono/time_point.h>
+#include <__config>
+#include <__mutex/mutex.h>
+#include <__mutex/unique_lock.h>
+#include <__threading_support>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_floating_point.h>
+#include <__utility/move.h>
+#include <ratio>
+#include <system_error>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// enum class cv_status
+_LIBCPP_DECLARE_STRONG_ENUM(cv_status){no_timeout, timeout};
+_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(cv_status)
+
+class _LIBCPP_TYPE_VIS condition_variable {
+ __libcpp_condvar_t __cv_ = _LIBCPP_CONDVAR_INITIALIZER;
+
+public:
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR condition_variable() _NOEXCEPT = default;
+
+# ifdef _LIBCPP_HAS_TRIVIAL_CONDVAR_DESTRUCTION
+ ~condition_variable() = default;
+# else
+ ~condition_variable();
+# endif
+
+ condition_variable(const condition_variable&) = delete;
+ condition_variable& operator=(const condition_variable&) = delete;
+
+ void notify_one() _NOEXCEPT;
+ void notify_all() _NOEXCEPT;
+
+ void wait(unique_lock<mutex>& __lk) _NOEXCEPT;
+ template <class _Predicate>
+ _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS void wait(unique_lock<mutex>& __lk, _Predicate __pred);
+
+ template <class _Clock, class _Duration>
+ _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS cv_status
+ wait_until(unique_lock<mutex>& __lk, const chrono::time_point<_Clock, _Duration>& __t);
+
+ template <class _Clock, class _Duration, class _Predicate>
+ _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS bool
+ wait_until(unique_lock<mutex>& __lk, const chrono::time_point<_Clock, _Duration>& __t, _Predicate __pred);
+
+ template <class _Rep, class _Period>
+ _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS cv_status
+ wait_for(unique_lock<mutex>& __lk, const chrono::duration<_Rep, _Period>& __d);
+
+ template <class _Rep, class _Period, class _Predicate>
+ bool _LIBCPP_HIDE_FROM_ABI
+ wait_for(unique_lock<mutex>& __lk, const chrono::duration<_Rep, _Period>& __d, _Predicate __pred);
+
+ typedef __libcpp_condvar_t* native_handle_type;
+ _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() { return &__cv_; }
+
+private:
+ void
+ __do_timed_wait(unique_lock<mutex>& __lk, chrono::time_point<chrono::system_clock, chrono::nanoseconds>) _NOEXCEPT;
+# if defined(_LIBCPP_HAS_COND_CLOCKWAIT)
+ void
+ __do_timed_wait(unique_lock<mutex>& __lk, chrono::time_point<chrono::steady_clock, chrono::nanoseconds>) _NOEXCEPT;
+# endif
+ template <class _Clock>
+ void __do_timed_wait(unique_lock<mutex>& __lk, chrono::time_point<_Clock, chrono::nanoseconds>) _NOEXCEPT;
+};
+#endif // !_LIBCPP_HAS_NO_THREADS
+
+template <class _Rep, class _Period>
+inline _LIBCPP_HIDE_FROM_ABI __enable_if_t<is_floating_point<_Rep>::value, chrono::nanoseconds>
+__safe_nanosecond_cast(chrono::duration<_Rep, _Period> __d) {
+ using namespace chrono;
+ using __ratio = ratio_divide<_Period, nano>;
+ using __ns_rep = nanoseconds::rep;
+ _Rep __result_float = __d.count() * __ratio::num / __ratio::den;
+
+ _Rep __result_max = numeric_limits<__ns_rep>::max();
+ if (__result_float >= __result_max) {
+ return nanoseconds::max();
+ }
+
+ _Rep __result_min = numeric_limits<__ns_rep>::min();
+ if (__result_float <= __result_min) {
+ return nanoseconds::min();
+ }
+
+ return nanoseconds(static_cast<__ns_rep>(__result_float));
+}
+
+template <class _Rep, class _Period>
+inline _LIBCPP_HIDE_FROM_ABI __enable_if_t<!is_floating_point<_Rep>::value, chrono::nanoseconds>
+__safe_nanosecond_cast(chrono::duration<_Rep, _Period> __d) {
+ using namespace chrono;
+ if (__d.count() == 0) {
+ return nanoseconds(0);
+ }
+
+ using __ratio = ratio_divide<_Period, nano>;
+ using __ns_rep = nanoseconds::rep;
+ __ns_rep __result_max = numeric_limits<__ns_rep>::max();
+ if (__d.count() > 0 && __d.count() > __result_max / __ratio::num) {
+ return nanoseconds::max();
+ }
+
+ __ns_rep __result_min = numeric_limits<__ns_rep>::min();
+ if (__d.count() < 0 && __d.count() < __result_min / __ratio::num) {
+ return nanoseconds::min();
+ }
+
+ __ns_rep __result = __d.count() * __ratio::num / __ratio::den;
+ if (__result == 0) {
+ return nanoseconds(1);
+ }
+
+ return nanoseconds(__result);
+}
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+template <class _Predicate>
+void condition_variable::wait(unique_lock<mutex>& __lk, _Predicate __pred) {
+ while (!__pred())
+ wait(__lk);
+}
+
+template <class _Clock, class _Duration>
+cv_status condition_variable::wait_until(unique_lock<mutex>& __lk, const chrono::time_point<_Clock, _Duration>& __t) {
+ using namespace chrono;
+ using __clock_tp_ns = time_point<_Clock, nanoseconds>;
+
+ typename _Clock::time_point __now = _Clock::now();
+ if (__t <= __now)
+ return cv_status::timeout;
+
+ __clock_tp_ns __t_ns = __clock_tp_ns(std::__safe_nanosecond_cast(__t.time_since_epoch()));
+
+ __do_timed_wait(__lk, __t_ns);
+ return _Clock::now() < __t ? cv_status::no_timeout : cv_status::timeout;
+}
+
+template <class _Clock, class _Duration, class _Predicate>
+bool condition_variable::wait_until(
+ unique_lock<mutex>& __lk, const chrono::time_point<_Clock, _Duration>& __t, _Predicate __pred) {
+ while (!__pred()) {
+ if (wait_until(__lk, __t) == cv_status::timeout)
+ return __pred();
+ }
+ return true;
+}
+
+template <class _Rep, class _Period>
+cv_status condition_variable::wait_for(unique_lock<mutex>& __lk, const chrono::duration<_Rep, _Period>& __d) {
+ using namespace chrono;
+ if (__d <= __d.zero())
+ return cv_status::timeout;
+ using __ns_rep = nanoseconds::rep;
+ steady_clock::time_point __c_now = steady_clock::now();
+
+# if defined(_LIBCPP_HAS_COND_CLOCKWAIT)
+ using __clock_tp_ns = time_point<steady_clock, nanoseconds>;
+ __ns_rep __now_count_ns = std::__safe_nanosecond_cast(__c_now.time_since_epoch()).count();
+# else
+ using __clock_tp_ns = time_point<system_clock, nanoseconds>;
+ __ns_rep __now_count_ns = std::__safe_nanosecond_cast(system_clock::now().time_since_epoch()).count();
+# endif
+
+ __ns_rep __d_ns_count = std::__safe_nanosecond_cast(__d).count();
+
+ if (__now_count_ns > numeric_limits<__ns_rep>::max() - __d_ns_count) {
+ __do_timed_wait(__lk, __clock_tp_ns::max());
+ } else {
+ __do_timed_wait(__lk, __clock_tp_ns(nanoseconds(__now_count_ns + __d_ns_count)));
+ }
+
+ return steady_clock::now() - __c_now < __d ? cv_status::no_timeout : cv_status::timeout;
+}
+
+template <class _Rep, class _Period, class _Predicate>
+inline bool
+condition_variable::wait_for(unique_lock<mutex>& __lk, const chrono::duration<_Rep, _Period>& __d, _Predicate __pred) {
+ return wait_until(__lk, chrono::steady_clock::now() + __d, std::move(__pred));
+}
+
+# if defined(_LIBCPP_HAS_COND_CLOCKWAIT)
+inline void condition_variable::__do_timed_wait(
+ unique_lock<mutex>& __lk, chrono::time_point<chrono::steady_clock, chrono::nanoseconds> __tp) _NOEXCEPT {
+ using namespace chrono;
+ if (!__lk.owns_lock())
+ __throw_system_error(EPERM, "condition_variable::timed wait: mutex not locked");
+ nanoseconds __d = __tp.time_since_epoch();
+ timespec __ts;
+ seconds __s = duration_cast<seconds>(__d);
+ using __ts_sec = decltype(__ts.tv_sec);
+ const __ts_sec __ts_sec_max = numeric_limits<__ts_sec>::max();
+ if (__s.count() < __ts_sec_max) {
+ __ts.tv_sec = static_cast<__ts_sec>(__s.count());
+ __ts.tv_nsec = (__d - __s).count();
+ } else {
+ __ts.tv_sec = __ts_sec_max;
+ __ts.tv_nsec = giga::num - 1;
+ }
+ int __ec = pthread_cond_clockwait(&__cv_, __lk.mutex()->native_handle(), CLOCK_MONOTONIC, &__ts);
+ if (__ec != 0 && __ec != ETIMEDOUT)
+ __throw_system_error(__ec, "condition_variable timed_wait failed");
+}
+# endif // _LIBCPP_HAS_COND_CLOCKWAIT
+
+template <class _Clock>
+inline void condition_variable::__do_timed_wait(unique_lock<mutex>& __lk,
+ chrono::time_point<_Clock, chrono::nanoseconds> __tp) _NOEXCEPT {
+ wait_for(__lk, __tp - _Clock::now());
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_HAS_NO_THREADS
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___CONDITION_VARIABLE_CONDITION_VARIABLE_H
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MUTEX_LOCK_GUARD_H
+#define _LIBCPP___MUTEX_LOCK_GUARD_H
+
+#include <__config>
+#include <__mutex/tag_types.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Mutex>
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_THREAD_SAFETY_ANNOTATION(scoped_lockable) lock_guard {
+public:
+ typedef _Mutex mutex_type;
+
+private:
+ mutex_type& __m_;
+
+public:
+ _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI explicit lock_guard(mutex_type& __m)
+ _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability(__m))
+ : __m_(__m) {
+ __m_.lock();
+ }
+
+ _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI lock_guard(mutex_type& __m, adopt_lock_t)
+ _LIBCPP_THREAD_SAFETY_ANNOTATION(requires_capability(__m))
+ : __m_(__m) {}
+ _LIBCPP_HIDE_FROM_ABI ~lock_guard() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability()) { __m_.unlock(); }
+
+private:
+ lock_guard(lock_guard const&) = delete;
+ lock_guard& operator=(lock_guard const&) = delete;
+};
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(lock_guard);
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_HAS_NO_THREADS
+
+#endif // _LIBCPP___MUTEX_LOCK_GUARD_H
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MUTEX_MUTEX_H
+#define _LIBCPP___MUTEX_MUTEX_H
+
+#include <__config>
+#include <__threading_support>
+#include <__type_traits/is_nothrow_default_constructible.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+class _LIBCPP_TYPE_VIS _LIBCPP_THREAD_SAFETY_ANNOTATION(capability("mutex")) mutex {
+ __libcpp_mutex_t __m_ = _LIBCPP_MUTEX_INITIALIZER;
+
+public:
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR mutex() = default;
+
+ mutex(const mutex&) = delete;
+ mutex& operator=(const mutex&) = delete;
+
+# if defined(_LIBCPP_HAS_TRIVIAL_MUTEX_DESTRUCTION)
+ ~mutex() = default;
+# else
+ ~mutex() _NOEXCEPT;
+# endif
+
+ void lock() _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability());
+ bool try_lock() _NOEXCEPT _LIBCPP_THREAD_SAFETY_ANNOTATION(try_acquire_capability(true));
+ void unlock() _NOEXCEPT _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability());
+
+ typedef __libcpp_mutex_t* native_handle_type;
+ _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() { return &__m_; }
+};
+
+static_assert(is_nothrow_default_constructible<mutex>::value, "the default constructor for std::mutex must be nothrow");
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_HAS_NO_THREADS
+
+#endif // _LIBCPP___MUTEX_MUTEX_H
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MUTEX_TAG_TYPES_H
+#define _LIBCPP___MUTEX_TAG_TYPES_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+struct _LIBCPP_TYPE_VIS defer_lock_t {
+ explicit defer_lock_t() = default;
+};
+
+struct _LIBCPP_TYPE_VIS try_to_lock_t {
+ explicit try_to_lock_t() = default;
+};
+
+struct _LIBCPP_TYPE_VIS adopt_lock_t {
+ explicit adopt_lock_t() = default;
+};
+
+# if defined(_LIBCPP_BUILDING_LIBRARY)
+extern _LIBCPP_EXPORTED_FROM_ABI const defer_lock_t defer_lock;
+extern _LIBCPP_EXPORTED_FROM_ABI const try_to_lock_t try_to_lock;
+extern _LIBCPP_EXPORTED_FROM_ABI const adopt_lock_t adopt_lock;
+# elif !defined(_LIBCPP_CXX03_LANG)
+/* inline */ constexpr defer_lock_t defer_lock = defer_lock_t();
+/* inline */ constexpr try_to_lock_t try_to_lock = try_to_lock_t();
+/* inline */ constexpr adopt_lock_t adopt_lock = adopt_lock_t();
+# endif
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_HAS_NO_THREADS
+
+#endif // _LIBCPP___MUTEX_TAG_TYPES_H
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MUTEX_UNIQUE_LOCK_H
+#define _LIBCPP___MUTEX_UNIQUE_LOCK_H
+
+#include <__chrono/duration.h>
+#include <__chrono/time_point.h>
+#include <__config>
+#include <__memory/addressof.h>
+#include <__mutex/tag_types.h>
+#include <__utility/swap.h>
+#include <system_error>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Mutex>
+class _LIBCPP_TEMPLATE_VIS unique_lock {
+public:
+ typedef _Mutex mutex_type;
+
+private:
+ mutex_type* __m_;
+ bool __owns_;
+
+public:
+ _LIBCPP_HIDE_FROM_ABI unique_lock() _NOEXCEPT : __m_(nullptr), __owns_(false) {}
+ _LIBCPP_HIDE_FROM_ABI explicit unique_lock(mutex_type& __m) : __m_(std::addressof(__m)), __owns_(true) {
+ __m_->lock();
+ }
+
+ _LIBCPP_HIDE_FROM_ABI unique_lock(mutex_type& __m, defer_lock_t) _NOEXCEPT
+ : __m_(std::addressof(__m)),
+ __owns_(false) {}
+
+ _LIBCPP_HIDE_FROM_ABI unique_lock(mutex_type& __m, try_to_lock_t)
+ : __m_(std::addressof(__m)), __owns_(__m.try_lock()) {}
+
+ _LIBCPP_HIDE_FROM_ABI unique_lock(mutex_type& __m, adopt_lock_t) : __m_(std::addressof(__m)), __owns_(true) {}
+
+ template <class _Clock, class _Duration>
+ _LIBCPP_HIDE_FROM_ABI unique_lock(mutex_type& __m, const chrono::time_point<_Clock, _Duration>& __t)
+ : __m_(std::addressof(__m)), __owns_(__m.try_lock_until(__t)) {}
+
+ template <class _Rep, class _Period>
+ _LIBCPP_HIDE_FROM_ABI unique_lock(mutex_type& __m, const chrono::duration<_Rep, _Period>& __d)
+ : __m_(std::addressof(__m)), __owns_(__m.try_lock_for(__d)) {}
+
+ _LIBCPP_HIDE_FROM_ABI ~unique_lock() {
+ if (__owns_)
+ __m_->unlock();
+ }
+
+ unique_lock(unique_lock const&) = delete;
+ unique_lock& operator=(unique_lock const&) = delete;
+
+ _LIBCPP_HIDE_FROM_ABI unique_lock(unique_lock&& __u) _NOEXCEPT : __m_(__u.__m_), __owns_(__u.__owns_) {
+ __u.__m_ = nullptr;
+ __u.__owns_ = false;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI unique_lock& operator=(unique_lock&& __u) _NOEXCEPT {
+ if (__owns_)
+ __m_->unlock();
+
+ __m_ = __u.__m_;
+ __owns_ = __u.__owns_;
+ __u.__m_ = nullptr;
+ __u.__owns_ = false;
+ return *this;
+ }
+
+ void lock();
+ bool try_lock();
+
+ template <class _Rep, class _Period>
+ bool try_lock_for(const chrono::duration<_Rep, _Period>& __d);
+
+ template <class _Clock, class _Duration>
+ bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
+
+ void unlock();
+
+ _LIBCPP_HIDE_FROM_ABI void swap(unique_lock& __u) _NOEXCEPT {
+ std::swap(__m_, __u.__m_);
+ std::swap(__owns_, __u.__owns_);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI mutex_type* release() _NOEXCEPT {
+ mutex_type* __m = __m_;
+ __m_ = nullptr;
+ __owns_ = false;
+ return __m;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI bool owns_lock() const _NOEXCEPT { return __owns_; }
+ _LIBCPP_HIDE_FROM_ABI explicit operator bool() const _NOEXCEPT { return __owns_; }
+ _LIBCPP_HIDE_FROM_ABI mutex_type* mutex() const _NOEXCEPT { return __m_; }
+};
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(unique_lock);
+
+template <class _Mutex>
+void unique_lock<_Mutex>::lock() {
+ if (__m_ == nullptr)
+ __throw_system_error(EPERM, "unique_lock::lock: references null mutex");
+ if (__owns_)
+ __throw_system_error(EDEADLK, "unique_lock::lock: already locked");
+ __m_->lock();
+ __owns_ = true;
+}
+
+template <class _Mutex>
+bool unique_lock<_Mutex>::try_lock() {
+ if (__m_ == nullptr)
+ __throw_system_error(EPERM, "unique_lock::try_lock: references null mutex");
+ if (__owns_)
+ __throw_system_error(EDEADLK, "unique_lock::try_lock: already locked");
+ __owns_ = __m_->try_lock();
+ return __owns_;
+}
+
+template <class _Mutex>
+template <class _Rep, class _Period>
+bool unique_lock<_Mutex>::try_lock_for(const chrono::duration<_Rep, _Period>& __d) {
+ if (__m_ == nullptr)
+ __throw_system_error(EPERM, "unique_lock::try_lock_for: references null mutex");
+ if (__owns_)
+ __throw_system_error(EDEADLK, "unique_lock::try_lock_for: already locked");
+ __owns_ = __m_->try_lock_for(__d);
+ return __owns_;
+}
+
+template <class _Mutex>
+template <class _Clock, class _Duration>
+bool unique_lock<_Mutex>::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t) {
+ if (__m_ == nullptr)
+ __throw_system_error(EPERM, "unique_lock::try_lock_until: references null mutex");
+ if (__owns_)
+ __throw_system_error(EDEADLK, "unique_lock::try_lock_until: already locked");
+ __owns_ = __m_->try_lock_until(__t);
+ return __owns_;
+}
+
+template <class _Mutex>
+void unique_lock<_Mutex>::unlock() {
+ if (!__owns_)
+ __throw_system_error(EPERM, "unique_lock::unlock: not locked");
+ __m_->unlock();
+ __owns_ = false;
+}
+
+template <class _Mutex>
+inline _LIBCPP_HIDE_FROM_ABI void swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) _NOEXCEPT {
+ __x.swap(__y);
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_HAS_NO_THREADS
+
+#endif // _LIBCPP___MUTEX_UNIQUE_LOCK_H
*/
#include <__assert> // all public C++ headers provide the assertion handler
+#include <__chrono/duration.h>
+#include <__chrono/steady_clock.h>
+#include <__chrono/time_point.h>
+#include <__condition_variable/condition_variable.h>
#include <__config>
#include <__memory/shared_ptr.h>
#include <__memory/unique_ptr.h>
-#include <__mutex_base>
+#include <__mutex/lock_guard.h>
+#include <__mutex/mutex.h>
+#include <__mutex/tag_types.h>
+#include <__mutex/unique_lock.h>
+#include <__utility/move.h>
#include <version>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <atomic>
# include <concepts>
+# include <cstdint>
+# include <cstdlib>
+# include <cstring>
+# include <initializer_list>
+# include <new>
+# include <stdexcept>
# include <type_traits>
+# include <typeinfo>
#endif
#endif // _LIBCPP_CONDITION_VARIABLE
{ include: [ "@<__chrono/.*>", "private", "<chrono>", "public" ] },
{ include: [ "@<__compare/.*>", "private", "<compare>", "public" ] },
{ include: [ "@<__concepts/.*>", "private", "<concepts>", "public" ] },
+ { include: [ "@<__condition_variable/.*>", "private", "<condition_variable>", "public" ] },
{ include: [ "@<__coroutine/.*>", "private", "<coroutine>", "public" ] },
{ include: [ "@<__debug_utils/.*>", "private", "<debug_utils>", "public" ] },
{ include: [ "@<__exception/.*>", "private", "<exception>", "public" ] },
{ include: [ "@<__iterator/.*>", "private", "<iterator>", "public" ] },
{ include: [ "@<__memory/.*>", "private", "<memory>", "public" ] },
{ include: [ "@<__memory_resource/.*>", "private", "<memory_resource>", "public" ] },
+ { include: [ "@<__mutex/.*>", "private", "<mutex>", "public" ] },
{ include: [ "@<__numeric/.*>", "private", "<numeric>", "public" ] },
{ include: [ "@<__random/.*>", "private", "<random>", "public" ] },
{ include: [ "@<__ranges/.*>", "private", "<ranges>", "public" ] },
module condition_variable {
header "condition_variable"
export *
+
+ module __condition_variable {
+ module condition_variable { private header "__condition_variable/condition_variable.h" }
+ }
}
module coroutine {
header "coroutine"
@requires_LIBCXX_ENABLE_THREADS@
header "mutex"
export *
+
+ module __mutex {
+ module lock_guard { private header "__mutex/lock_guard.h" }
+ module mutex { private header "__mutex/mutex.h" }
+ module tag_types { private header "__mutex/tag_types.h" }
+ module unique_lock { private header "__mutex/unique_lock.h" }
+ }
}
module new {
header "new"
private header "__locale" export *
}
module __mbstate_t { private header "__mbstate_t.h" export * }
- module __mutex_base { private header "__mutex_base" export * }
module __node_handle { private header "__node_handle" export * }
module __split_buffer { private header "__split_buffer" export * }
module __std_stream {
*/
#include <__assert> // all public C++ headers provide the assertion handler
+#include <__chrono/steady_clock.h>
+#include <__chrono/time_point.h>
+#include <__condition_variable/condition_variable.h>
#include <__config>
#include <__memory/shared_ptr.h>
-#include <__mutex_base>
+#include <__mutex/lock_guard.h>
+#include <__mutex/mutex.h>
+#include <__mutex/tag_types.h>
+#include <__mutex/unique_lock.h>
#include <__threading_support>
#include <__utility/forward.h>
#include <cstdint>
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <atomic>
# include <concepts>
+# include <cstdlib>
+# include <cstring>
# include <ctime>
# include <functional>
+# include <initializer_list>
+# include <new>
+# include <stdexcept>
# include <type_traits>
+# include <typeinfo>
#endif
#endif // _LIBCPP_MUTEX
#include <__assert> // all public C++ headers provide the assertion handler
#include <__availability>
+#include <__chrono/duration.h>
+#include <__chrono/steady_clock.h>
+#include <__chrono/time_point.h>
+#include <__condition_variable/condition_variable.h>
#include <__config>
+#include <__memory/addressof.h>
+#include <__mutex/mutex.h>
+#include <__mutex/tag_types.h>
+#include <__mutex/unique_lock.h>
+#include <__utility/swap.h>
+#include <cerrno>
+#include <system_error>
#include <version>
_LIBCPP_PUSH_MACROS
#if _LIBCPP_STD_VER >= 14 || defined(_LIBCPP_BUILDING_LIBRARY)
-#include <__mutex_base>
-
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#endif
*/
#include <__assert> // all public C++ headers provide the assertion handler
+#include <__chrono/steady_clock.h>
+#include <__chrono/time_point.h>
+#include <__condition_variable/condition_variable.h>
#include <__config>
#include <__exception/terminate.h>
#include <__functional/hash.h>
#include <__memory/addressof.h>
#include <__memory/unique_ptr.h>
-#include <__mutex_base>
+#include <__mutex/mutex.h>
+#include <__mutex/unique_lock.h>
#include <__thread/poll_with_backoff.h>
#include <__thread/timed_backoff_policy.h>
#include <__threading_support>
#endif
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+# include <cstdint>
+# include <cstring>
# include <functional>
+# include <new>
#endif
#endif // _LIBCPP_THREAD
#ifndef _LIBCPP_HAS_NO_THREADS
+#include <mutex>
#include <shared_mutex>
#if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
# pragma comment(lib, "pthread")
#include <__concepts/semiregular.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/semiregular.h'}}
#include <__concepts/swappable.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/swappable.h'}}
#include <__concepts/totally_ordered.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/totally_ordered.h'}}
+#include <__condition_variable/condition_variable.h> // expected-error@*:* {{use of private header from outside its module: '__condition_variable/condition_variable.h'}}
#include <__coroutine/coroutine_handle.h> // expected-error@*:* {{use of private header from outside its module: '__coroutine/coroutine_handle.h'}}
#include <__coroutine/coroutine_traits.h> // expected-error@*:* {{use of private header from outside its module: '__coroutine/coroutine_traits.h'}}
#include <__coroutine/noop_coroutine_handle.h> // expected-error@*:* {{use of private header from outside its module: '__coroutine/noop_coroutine_handle.h'}}
#include <__memory_resource/pool_options.h> // expected-error@*:* {{use of private header from outside its module: '__memory_resource/pool_options.h'}}
#include <__memory_resource/synchronized_pool_resource.h> // expected-error@*:* {{use of private header from outside its module: '__memory_resource/synchronized_pool_resource.h'}}
#include <__memory_resource/unsynchronized_pool_resource.h> // expected-error@*:* {{use of private header from outside its module: '__memory_resource/unsynchronized_pool_resource.h'}}
-#include <__mutex_base> // expected-error@*:* {{use of private header from outside its module: '__mutex_base'}}
+#include <__mutex/lock_guard.h> // expected-error@*:* {{use of private header from outside its module: '__mutex/lock_guard.h'}}
+#include <__mutex/mutex.h> // expected-error@*:* {{use of private header from outside its module: '__mutex/mutex.h'}}
+#include <__mutex/tag_types.h> // expected-error@*:* {{use of private header from outside its module: '__mutex/tag_types.h'}}
+#include <__mutex/unique_lock.h> // expected-error@*:* {{use of private header from outside its module: '__mutex/unique_lock.h'}}
#include <__node_handle> // expected-error@*:* {{use of private header from outside its module: '__node_handle'}}
#include <__numeric/accumulate.h> // expected-error@*:* {{use of private header from outside its module: '__numeric/accumulate.h'}}
#include <__numeric/adjacent_difference.h> // expected-error@*:* {{use of private header from outside its module: '__numeric/adjacent_difference.h'}}
// typedef pthread_cond_t* native_handle_type;
// native_handle_type native_handle();
-#include <condition_variable>
#include <cassert>
+#include <condition_variable>
+#include <pthread.h>
+#include <type_traits>
#include "test_macros.h"
set tuple
set type_traits
set version
+shared_mutex cerrno
+shared_mutex cstddef
+shared_mutex ctime
+shared_mutex iosfwd
+shared_mutex limits
+shared_mutex ratio
+shared_mutex system_error
+shared_mutex type_traits
shared_mutex version
source_location cstdint
source_location version
set tuple
set type_traits
set version
+shared_mutex cerrno
+shared_mutex cstddef
+shared_mutex ctime
+shared_mutex iosfwd
+shared_mutex limits
+shared_mutex ratio
+shared_mutex system_error
+shared_mutex type_traits
shared_mutex version
source_location cstdint
source_location version
set tuple
set type_traits
set version
+shared_mutex cerrno
shared_mutex cstddef
shared_mutex ctime
shared_mutex iosfwd
set tuple
set type_traits
set version
+shared_mutex cerrno
shared_mutex cstddef
shared_mutex ctime
shared_mutex iosfwd
set tuple
set type_traits
set version
+shared_mutex cerrno
shared_mutex cstddef
shared_mutex ctime
shared_mutex iosfwd
concepts cstddef
concepts version
condition_variable cstddef
-condition_variable cstdint
condition_variable cstdlib
-condition_variable cstring
condition_variable ctime
-condition_variable initializer_list
condition_variable iosfwd
condition_variable limits
condition_variable new
mutex cstddef
mutex cstdint
mutex cstdlib
-mutex cstring
mutex ctime
-mutex initializer_list
mutex iosfwd
mutex limits
mutex new
set stdexcept
set tuple
set version
+shared_mutex cerrno
shared_mutex cstddef
shared_mutex ctime
shared_mutex iosfwd
system_error version
thread compare
thread cstddef
-thread cstdint
-thread cstring
thread ctime
thread iosfwd
thread limits
-thread new
thread ratio
thread system_error
thread tuple
#include <cassert>
#include <chrono>
#include <future>
+#include <ratio>
#include "make_test_thread.h"
#include "test_macros.h"
#include <cassert>
#include <chrono>
#include <future>
+#include <ratio>
#include "make_test_thread.h"
#include "test_macros.h"
// template<class _Mutex> shared_lock(shared_lock<_Mutex>)
// -> shared_lock<_Mutex>; // C++17
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
#include <shared_mutex>
#include <thread>
#include <vector>
-#include <cstdlib>
-#include <cassert>
#include "make_test_thread.h"
#include "test_macros.h"
// shared_lock(mutex_type& m, try_to_lock_t);
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
+#include <mutex>
#include <shared_mutex>
#include <thread>
#include <vector>
-#include <cstdlib>
-#include <cassert>
#include "make_test_thread.h"
#include "test_macros.h"
// void lock();
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
+#include <mutex>
#include <shared_mutex>
#include <thread>
#include <vector>
-#include <cstdlib>
-#include <cassert>
#include "make_test_thread.h"
#include "test_macros.h"
// bool try_lock();
-#include <shared_mutex>
#include <cassert>
#include <mutex>
+#include <shared_mutex>
+#include <system_error>
#include "test_macros.h"
// template <class Rep, class Period>
// bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
-#include <shared_mutex>
#include <cassert>
#include <chrono>
#include <mutex>
+#include <shared_mutex>
+#include <system_error>
#include "test_macros.h"
// template <class Clock, class Duration>
// bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
-#include <shared_mutex>
#include <cassert>
#include <chrono>
#include <mutex>
+#include <shared_mutex>
+#include <system_error>
#include "test_macros.h"
// template<class _Mutex> unique_lock(unique_lock<_Mutex>)
// -> unique_lock<_Mutex>; // C++17
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
#include <mutex>
#include <thread>
-#include <cstdlib>
-#include <cassert>
#include "make_test_thread.h"
#include "test_macros.h"
// unique_lock(mutex_type& m, try_to_lock_t);
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
#include <mutex>
#include <thread>
-#include <cstdlib>
-#include <cassert>
#include "make_test_thread.h"
#include "test_macros.h"
// void lock();
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
#include <mutex>
#include <thread>
-#include <cstdlib>
-#include <cassert>
#include "make_test_thread.h"
#include "test_macros.h"
// bool try_lock();
-#include <mutex>
#include <cassert>
+#include <mutex>
+#include <system_error>
#include "test_macros.h"
// template <class Rep, class Period>
// bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
-#include <mutex>
#include <cassert>
+#include <mutex>
+#include <system_error>
#include "test_macros.h"
// template <class Clock, class Duration>
// bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
-#include <mutex>
#include <cassert>
+#include <mutex>
+#include <system_error>
#include "test_macros.h"
// void unlock();
-#include <mutex>
#include <cassert>
+#include <mutex>
+#include <system_error>
#include "test_macros.h"
// void lock();
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
#include <mutex>
#include <thread>
-#include <cstdlib>
-#include <cassert>
#include "make_test_thread.h"
#include "test_macros.h"
// bool try_lock();
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
#include <mutex>
#include <thread>
-#include <cstdlib>
-#include <cassert>
#include "make_test_thread.h"
#include "test_macros.h"
// void lock();
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
#include <mutex>
#include <thread>
-#include <cstdlib>
-#include <cassert>
#include "make_test_thread.h"
#include "test_macros.h"
// bool try_lock();
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
#include <mutex>
#include <thread>
-#include <cstdlib>
-#include <cassert>
#include "make_test_thread.h"
#include "test_macros.h"
// void lock();
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
#include <shared_mutex>
#include <thread>
-#include <cstdlib>
-#include <cassert>
#include "make_test_thread.h"
#include "test_macros.h"
// void lock_shared();
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
#include <shared_mutex>
#include <thread>
#include <vector>
-#include <cstdlib>
-#include <cassert>
#include "make_test_thread.h"
#include "test_macros.h"
// bool try_lock();
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
#include <shared_mutex>
#include <thread>
-#include <cstdlib>
-#include <cassert>
#include "make_test_thread.h"
#include "test_macros.h"
// bool try_lock_shared();
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
#include <shared_mutex>
#include <thread>
#include <vector>
-#include <cstdlib>
-#include <cassert>
#include "make_test_thread.h"
#include "test_macros.h"
// void lock();
-#include <thread>
-
#include <atomic>
-#include <cstdlib>
#include <cassert>
+#include <chrono>
+#include <cstdlib>
#include <shared_mutex>
+#include <thread>
#include "make_test_thread.h"
#include "test_macros.h"
// void lock_shared();
-#include <thread>
#include <atomic>
#include <cassert>
+#include <chrono>
#include <cstdlib>
#include <shared_mutex>
+#include <thread>
#include <vector>
#include "make_test_thread.h"
// bool try_lock();
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
#include <shared_mutex>
#include <thread>
-#include <cstdlib>
-#include <cassert>
#include "make_test_thread.h"
#include "test_macros.h"
// bool try_lock_shared();
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
#include <shared_mutex>
#include <thread>
#include <vector>
-#include <cstdlib>
-#include <cassert>
#include "make_test_thread.h"
#include "test_macros.h"
// void lock();
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
#include <mutex>
#include <thread>
-#include <cstdlib>
-#include <cassert>
#include "make_test_thread.h"
#include "test_macros.h"
// bool try_lock();
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
#include <mutex>
#include <thread>
-#include <cstdlib>
-#include <cassert>
#include "make_test_thread.h"
#include "test_macros.h"
// void lock();
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
#include <mutex>
#include <thread>
-#include <cstdlib>
-#include <cassert>
#include "make_test_thread.h"
#include "test_macros.h"
// bool try_lock();
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
#include <mutex>
#include <thread>
-#include <cstdlib>
-#include <cassert>
#include "make_test_thread.h"
#include "test_macros.h"
// template <class Clock, class Duration>
// void sleep_until(const chrono::time_point<Clock, Duration>& abs_time);
-#include <thread>
-#include <cstdlib>
#include <cassert>
+#include <chrono>
+#include <cstdlib>
+#include <thread>
#include "test_macros.h"
#include <cassert>
#include <concepts>
+#include <ratio>
#include <sstream>
#include "make_string.h"
// basic_ostream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& os, const hh_mm_ss<Duration>& hms);
-#include <chrono>
#include <cassert>
+#include <chrono>
+#include <ratio>
#include <sstream>
#include "make_string.h"
#include <concepts>
#include <locale>
#include <iostream>
+#include <ratio>
#include <type_traits>
#include "formatter_tests.h"
#include <concepts>
#include <locale>
#include <iostream>
+#include <ratio>
#include <type_traits>
#include "formatter_tests.h"
libcxx/include/__memory/unique_ptr.h
libcxx/include/__memory/uses_allocator.h
libcxx/include/mutex
-libcxx/include/__mutex_base
libcxx/include/new
libcxx/include/__node_handle
libcxx/include/numbers