1 files changed, 0 insertions, 368 deletions
diff --git a/third_party/libcxx/include/c++/v1/condition_variable b/third_party/libcxx/include/c++/v1/condition_variable
deleted file mode 100644
index d42a480..0000000
--- a/third_party/libcxx/include/c++/v1/condition_variable
+++ /dev/null
@@ -1,368 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// 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
-#define _LIBCPP_CONDITION_VARIABLE
-
-/*
-    condition_variable synopsis
-
-namespace std
-{
-
-enum class cv_status { no_timeout, timeout };
-
-class condition_variable
-{
-public:
-    condition_variable();
-    ~condition_variable();
-
-    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>& lock);
-    template <class Predicate>
-        void wait(unique_lock<mutex>& lock, Predicate pred);
-
-    template <class Clock, class Duration>
-        cv_status
-        wait_until(unique_lock<mutex>& lock,
-                   const chrono::time_point<Clock, Duration>& abs_time);
-
-    template <class Clock, class Duration, class Predicate>
-        bool
-        wait_until(unique_lock<mutex>& lock,
-                   const chrono::time_point<Clock, Duration>& abs_time,
-                   Predicate pred);
-
-    template <class Rep, class Period>
-        cv_status
-        wait_for(unique_lock<mutex>& lock,
-                 const chrono::duration<Rep, Period>& rel_time);
-
-    template <class Rep, class Period, class Predicate>
-        bool
-        wait_for(unique_lock<mutex>& lock,
-                 const chrono::duration<Rep, Period>& rel_time,
-                 Predicate pred);
-
-    typedef pthread_cond_t* native_handle_type;
-    native_handle_type native_handle();
-};
-
-void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
-
-class condition_variable_any
-{
-public:
-    condition_variable_any();
-    ~condition_variable_any();
-
-    condition_variable_any(const condition_variable_any&) = delete;
-    condition_variable_any& operator=(const condition_variable_any&) = delete;
-
-    void notify_one() noexcept;
-    void notify_all() noexcept;
-
-    template <class Lock>
-        void wait(Lock& lock);
-    template <class Lock, class Predicate>
-        void wait(Lock& lock, Predicate pred);
-
-    template <class Lock, class Clock, class Duration>
-        cv_status
-        wait_until(Lock& lock,
-                   const chrono::time_point<Clock, Duration>& abs_time);
-
-    template <class Lock, class Clock, class Duration, class Predicate>
-        bool
-        wait_until(Lock& lock,
-                   const chrono::time_point<Clock, Duration>& abs_time,
-                   Predicate pred);
-
-    template <class Lock, class Rep, class Period>
-        cv_status
-        wait_for(Lock& lock,
-                 const chrono::duration<Rep, Period>& rel_time);
-
-    template <class Lock, class Rep, class Period, class Predicate>
-        bool
-        wait_for(Lock& lock,
-                 const chrono::duration<Rep, Period>& rel_time,
-                 Predicate pred);
-
-    // [thread.condvarany.intwait], interruptible waits
-    template <class Lock, class Predicate>
-      bool wait(Lock& lock, stop_token stoken, Predicate pred);                               // since C++20
-
-    template <class Lock, class Clock, class Duration, class Predicate>
-      bool wait_until(Lock& lock, stop_token stoken,
-                      const chrono::time_point<Clock, Duration>& abs_time, Predicate pred);   // since C++20
-
-    template <class Lock, class Rep, class Period, class Predicate>
-      bool wait_for(Lock& lock, stop_token stoken,
-                    const chrono::duration<Rep, Period>& rel_time, Predicate pred);           // since C++20
-};
-
-}  // std
-
-*/
-
-#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
-#  include <__cxx03/condition_variable>
-#else
-#  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 <__mutex/lock_guard.h>
-#  include <__mutex/mutex.h>
-#  include <__mutex/tag_types.h>
-#  include <__mutex/unique_lock.h>
-#  include <__stop_token/stop_callback.h>
-#  include <__stop_token/stop_token.h>
-#  include <__utility/move.h>
-#  include <version>
-
-#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#    pragma GCC system_header
-#  endif
-
-_LIBCPP_PUSH_MACROS
-#  include <__undef_macros>
-
-#  if _LIBCPP_HAS_THREADS
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Lock>
-struct __unlock_guard {
-  _Lock& __lock_;
-
-  _LIBCPP_HIDE_FROM_ABI __unlock_guard(_Lock& __lock) : __lock_(__lock) { __lock_.unlock(); }
-
-  _LIBCPP_HIDE_FROM_ABI ~__unlock_guard() _NOEXCEPT // turns exception to std::terminate
-  {
-    __lock_.lock();
-  }
-
-  __unlock_guard(const __unlock_guard&)            = delete;
-  __unlock_guard& operator=(const __unlock_guard&) = delete;
-};
-
-class _LIBCPP_EXPORTED_FROM_ABI condition_variable_any {
-  condition_variable __cv_;
-  shared_ptr<mutex> __mut_;
-
-public:
-  _LIBCPP_HIDE_FROM_ABI condition_variable_any();
-
-  _LIBCPP_HIDE_FROM_ABI void notify_one() _NOEXCEPT;
-  _LIBCPP_HIDE_FROM_ABI void notify_all() _NOEXCEPT;
-
-  template <class _Lock>
-  _LIBCPP_HIDE_FROM_ABI void wait(_Lock& __lock) {
-    shared_ptr<mutex> __mut = __mut_;
-    unique_lock<mutex> __lk(*__mut);
-    __unlock_guard<_Lock> __unlock(__lock);
-    lock_guard<unique_lock<mutex> > __lx(__lk, adopt_lock_t());
-    __cv_.wait(__lk);
-  } // __mut_.unlock(), __lock.lock()
-
-  template <class _Lock, class _Predicate>
-  _LIBCPP_HIDE_FROM_ABI void wait(_Lock& __lock, _Predicate __pred);
-
-  template <class _Lock, class _Clock, class _Duration>
-  _LIBCPP_HIDE_FROM_ABI cv_status wait_until(_Lock& __lock, const chrono::time_point<_Clock, _Duration>& __t) {
-    shared_ptr<mutex> __mut = __mut_;
-    unique_lock<mutex> __lk(*__mut);
-    __unlock_guard<_Lock> __unlock(__lock);
-    lock_guard<unique_lock<mutex> > __lx(__lk, adopt_lock_t());
-    return __cv_.wait_until(__lk, __t);
-  } // __mut_.unlock(), __lock.lock()
-
-  template <class _Lock, class _Clock, class _Duration, class _Predicate>
-  bool _LIBCPP_HIDE_FROM_ABI
-  wait_until(_Lock& __lock, const chrono::time_point<_Clock, _Duration>& __t, _Predicate __pred);
-
-  template <class _Lock, class _Rep, class _Period>
-  cv_status _LIBCPP_HIDE_FROM_ABI wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __d);
-
-  template <class _Lock, class _Rep, class _Period, class _Predicate>
-  bool _LIBCPP_HIDE_FROM_ABI wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __d, _Predicate __pred);
-
-#    if _LIBCPP_STD_VER >= 20
-
-  template <class _Lock, class _Predicate>
-  _LIBCPP_HIDE_FROM_ABI bool wait(_Lock& __lock, stop_token __stoken, _Predicate __pred);
-
-  template <class _Lock, class _Clock, class _Duration, class _Predicate>
-  _LIBCPP_HIDE_FROM_ABI bool wait_until(
-      _Lock& __lock, stop_token __stoken, const chrono::time_point<_Clock, _Duration>& __abs_time, _Predicate __pred);
-
-  template <class _Lock, class _Rep, class _Period, class _Predicate>
-  _LIBCPP_HIDE_FROM_ABI bool
-  wait_for(_Lock& __lock, stop_token __stoken, const chrono::duration<_Rep, _Period>& __rel_time, _Predicate __pred);
-
-#    endif // _LIBCPP_STD_VER >= 20
-};
-
-inline condition_variable_any::condition_variable_any() : __mut_(make_shared<mutex>()) {}
-
-inline void condition_variable_any::notify_one() _NOEXCEPT {
-  { lock_guard<mutex> __lx(*__mut_); }
-  __cv_.notify_one();
-}
-
-inline void condition_variable_any::notify_all() _NOEXCEPT {
-  { lock_guard<mutex> __lx(*__mut_); }
-  __cv_.notify_all();
-}
-
-template <class _Lock, class _Predicate>
-inline void condition_variable_any::wait(_Lock& __lock, _Predicate __pred) {
-  while (!__pred())
-    wait(__lock);
-}
-
-template <class _Lock, class _Clock, class _Duration, class _Predicate>
-inline bool
-condition_variable_any::wait_until(_Lock& __lock, const chrono::time_point<_Clock, _Duration>& __t, _Predicate __pred) {
-  while (!__pred())
-    if (wait_until(__lock, __t) == cv_status::timeout)
-      return __pred();
-  return true;
-}
-
-template <class _Lock, class _Rep, class _Period>
-inline cv_status condition_variable_any::wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __d) {
-  return wait_until(__lock, chrono::steady_clock::now() + __d);
-}
-
-template <class _Lock, class _Rep, class _Period, class _Predicate>
-inline bool
-condition_variable_any::wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __d, _Predicate __pred) {
-  return wait_until(__lock, chrono::steady_clock::now() + __d, std::move(__pred));
-}
-
-#    if _LIBCPP_STD_VER >= 20
-
-template <class _Lock, class _Predicate>
-bool condition_variable_any::wait(_Lock& __user_lock, stop_token __stoken, _Predicate __pred) {
-  if (__stoken.stop_requested())
-    return __pred();
-
-  // Per https://eel.is/c++draft/thread.condition.condvarany#general-note-2,
-  // we do need to take a copy of the shared pointer __mut_
-  // This ensures that a thread can call the destructor immediately after calling
-  // notify_all, without waiting all the wait calls.
-  // A thread can also safely call the destructor immediately after calling
-  // request_stop, as the call to request_stop would evaluate the callback,
-  // which accesses the internal condition variable, immediately on the same thread.
-  // In this situation, it is OK even without copying a shared ownership the internal
-  // condition variable. However, this needs the evaluation of stop_callback to
-  // happen-before the destruction.
-  // The spec only says "Only the notification to unblock the wait needs to happen
-  // before destruction". To make this work, we need to copy the shared ownership of
-  // the internal condition variable inside this function, which is not possible
-  // with the current ABI.
-  shared_ptr<mutex> __mut = __mut_;
-
-  stop_callback __cb(__stoken, [this] { notify_all(); });
-
-  while (true) {
-    if (__pred())
-      return true;
-
-    // We need to take the internal lock before checking stop_requested,
-    // so that the notification cannot come in between the stop_requested
-    // check and entering the wait.
-    // Note that the stop_callback takes the same internal lock before notifying
-    unique_lock<mutex> __internal_lock(*__mut);
-    if (__stoken.stop_requested())
-      break;
-
-    __unlock_guard<_Lock> __unlock(__user_lock);
-    unique_lock<mutex> __internal_lock2(
-        std::move(__internal_lock)); // switch unlock order between __internal_lock and __user_lock
-    __cv_.wait(__internal_lock2);
-  } // __internal_lock2.unlock(), __user_lock.lock()
-  return __pred();
-}
-
-template <class _Lock, class _Clock, class _Duration, class _Predicate>
-bool condition_variable_any::wait_until(
-    _Lock& __user_lock,
-    stop_token __stoken,
-    const chrono::time_point<_Clock, _Duration>& __abs_time,
-    _Predicate __pred) {
-  if (__stoken.stop_requested())
-    return __pred();
-
-  shared_ptr<mutex> __mut = __mut_;
-  stop_callback __cb(__stoken, [this] { notify_all(); });
-
-  while (true) {
-    if (__pred())
-      return true;
-
-    unique_lock<mutex> __internal_lock(*__mut);
-    if (__stoken.stop_requested())
-      break;
-
-    __unlock_guard<_Lock> __unlock(__user_lock);
-    unique_lock<mutex> __internal_lock2(
-        std::move(__internal_lock)); // switch unlock order between __internal_lock and __user_lock
-
-    if (__cv_.wait_until(__internal_lock2, __abs_time) == cv_status::timeout)
-      break;
-  } // __internal_lock2.unlock(), __user_lock.lock()
-  return __pred();
-}
-
-template <class _Lock, class _Rep, class _Period, class _Predicate>
-bool condition_variable_any::wait_for(
-    _Lock& __lock, stop_token __stoken, const chrono::duration<_Rep, _Period>& __rel_time, _Predicate __pred) {
-  return wait_until(__lock, std::move(__stoken), chrono::steady_clock::now() + __rel_time, std::move(__pred));
-}
-
-#    endif // _LIBCPP_STD_VER >= 20
-
-_LIBCPP_EXPORTED_FROM_ABI void notify_all_at_thread_exit(condition_variable&, unique_lock<mutex>);
-
-_LIBCPP_END_NAMESPACE_STD
-
-#  endif // _LIBCPP_HAS_THREADS
-
-_LIBCPP_POP_MACROS
-
-#  if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
-#    include <atomic>
-#    include <concepts>
-#    include <cstdint>
-#    include <cstdlib>
-#    include <cstring>
-#    include <initializer_list>
-#    include <iosfwd>
-#    include <new>
-#    include <optional>
-#    include <stdexcept>
-#    include <system_error>
-#    include <type_traits>
-#    include <typeinfo>
-#  endif
-#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
-
-#endif // _LIBCPP_CONDITION_VARIABLE