rc4/include/__mutex_base - third_party/libcxx - Git at Google

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

 #ifndef _LIBCPP___MUTEX_BASE
 #define _LIBCPP___MUTEX_BASE

 #include <__config>
 #include <chrono>
 #include <system_error>
 #include <pthread.h>

 #pragma GCC system_header

 #ifdef _LIBCPP_SHARED_LOCK

 namespace ting {
 template <class _Mutex> class shared_lock;
 template <class _Mutex> class upgrade_lock;
 }

 #endif  // _LIBCPP_SHARED_LOCK


 _LIBCPP_BEGIN_NAMESPACE_STD

 class _LIBCPP_VISIBLE mutex
 {
     pthread_mutex_t __m_;

 public:
     _LIBCPP_INLINE_VISIBILITY
      mutex() {__m_ = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;}
      ~mutex();

 private:
     mutex(const mutex&);// = delete;
     mutex& operator=(const mutex&);// = delete;

 public:
     void lock();
     bool try_lock();
     void unlock();

     typedef pthread_mutex_t* native_handle_type;
     _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() {return &__m_;}
 };

 struct _LIBCPP_VISIBLE defer_lock_t {};
 struct _LIBCPP_VISIBLE try_to_lock_t {};
 struct _LIBCPP_VISIBLE adopt_lock_t {};

 //constexpr
 extern const
 defer_lock_t  defer_lock;

 //constexpr
 extern const
 try_to_lock_t try_to_lock;

 //constexpr
 extern const
 adopt_lock_t  adopt_lock;

 template <class _Mutex>
 class _LIBCPP_VISIBLE lock_guard
 {
 public:
     typedef _Mutex mutex_type;

 private:
     mutex_type& __m_;
 public:

     _LIBCPP_INLINE_VISIBILITY
     explicit lock_guard(mutex_type& __m)
         : __m_(__m) {__m_.lock();}
     _LIBCPP_INLINE_VISIBILITY
     lock_guard(mutex_type& __m, adopt_lock_t)
         : __m_(__m) {}
     _LIBCPP_INLINE_VISIBILITY
     ~lock_guard() {__m_.unlock();}

 private:
     lock_guard(lock_guard const&);// = delete;
     lock_guard& operator=(lock_guard const&);// = delete;
 };

 template <class _Mutex>
 class _LIBCPP_VISIBLE unique_lock
 {
 public:
     typedef _Mutex mutex_type;

 private:
     mutex_type* __m_;
     bool __owns_;

 public:
     _LIBCPP_INLINE_VISIBILITY
     unique_lock() : __m_(nullptr), __owns_(false) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit unique_lock(mutex_type& __m)
         : __m_(&__m), __owns_(true) {__m_->lock();}
     _LIBCPP_INLINE_VISIBILITY
     unique_lock(mutex_type& __m, defer_lock_t)
         : __m_(&__m), __owns_(false) {}
     _LIBCPP_INLINE_VISIBILITY
     unique_lock(mutex_type& __m, try_to_lock_t)
         : __m_(&__m), __owns_(__m.try_lock()) {}
     _LIBCPP_INLINE_VISIBILITY
     unique_lock(mutex_type& __m, adopt_lock_t)
         : __m_(&__m), __owns_(true) {}
     template <class _Clock, class _Duration>
     _LIBCPP_INLINE_VISIBILITY
         unique_lock(mutex_type& __m, const chrono::time_point<_Clock, _Duration>& __t)
             : __m_(&__m), __owns_(__m.try_lock_until(__t)) {}
     template <class _Rep, class _Period>
     _LIBCPP_INLINE_VISIBILITY
         unique_lock(mutex_type& __m, const chrono::duration<_Rep, _Period>& __d)
             : __m_(&__m), __owns_(__m.try_lock_for(__d)) {}
     _LIBCPP_INLINE_VISIBILITY
     ~unique_lock()
     {
         if (__owns_)
             __m_->unlock();
     }

 private:
     unique_lock(unique_lock const&); // = delete;
     unique_lock& operator=(unique_lock const&); // = delete;

 public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     unique_lock(unique_lock&& __u)
         : __m_(__u.__m_), __owns_(__u.__owns_)
         {__u.__m_ = nullptr; __u.__owns_ = false;}
     _LIBCPP_INLINE_VISIBILITY
     unique_lock& operator=(unique_lock&& __u)
         {
             if (__owns_)
                 __m_->unlock();
             __m_ = __u.__m_;
             __owns_ = __u.__owns_;
             __u.__m_ = nullptr;
             __u.__owns_ = false;
             return *this;
         }

 #ifdef _LIBCPP_SHARED_LOCK

     unique_lock(ting::shared_lock<mutex_type>&&, try_to_lock_t);
     template <class _Clock, class _Duration>
         unique_lock(ting::shared_lock<mutex_type>&&,
                     const chrono::time_point<_Clock, _Duration>&);
     template <class _Rep, class _Period>
         unique_lock(ting::shared_lock<mutex_type>&&,
                     const chrono::duration<_Rep, _Period>&);

     explicit unique_lock(ting::upgrade_lock<mutex_type>&&);
     unique_lock(ting::upgrade_lock<mutex_type>&&, try_to_lock_t);
     template <class _Clock, class _Duration>
         unique_lock(ting::upgrade_lock<mutex_type>&&,
                     const chrono::time_point<_Clock, _Duration>&);
     template <class _Rep, class _Period>
         unique_lock(ting::upgrade_lock<mutex_type>&&,
                     const chrono::duration<_Rep, _Period>&);

 #endif  // _LIBCPP_SHARED_LOCK

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

     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_INLINE_VISIBILITY
     void swap(unique_lock& __u)
     {
         _VSTD::swap(__m_, __u.__m_);
         _VSTD::swap(__owns_, __u.__owns_);
     }
     _LIBCPP_INLINE_VISIBILITY
     mutex_type* release()
     {
         mutex_type* __m = __m_;
         __m_ = nullptr;
         __owns_ = false;
         return __m;
     }

     _LIBCPP_INLINE_VISIBILITY
     bool owns_lock() const {return __owns_;}
     _LIBCPP_INLINE_VISIBILITY
 //    explicit
         operator bool () const {return __owns_;}
     _LIBCPP_INLINE_VISIBILITY
     mutex_type* mutex() const {return __m_;}
 };

 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_INLINE_VISIBILITY
 void
 swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) {__x.swap(__y);}

 struct _LIBCPP_VISIBLE cv_status
 {
     enum _ {
         no_timeout,
         timeout
     };

     _ __v_;

     _LIBCPP_INLINE_VISIBILITY cv_status(_ __v) : __v_(__v) {}
     _LIBCPP_INLINE_VISIBILITY operator int() const {return __v_;}

 };

 class _LIBCPP_VISIBLE condition_variable
 {
     pthread_cond_t __cv_;
 public:
     _LIBCPP_INLINE_VISIBILITY
     condition_variable() {__cv_ = (pthread_cond_t)PTHREAD_COND_INITIALIZER;}
     ~condition_variable();

 private:
     condition_variable(const condition_variable&); // = delete;
     condition_variable& operator=(const condition_variable&); // = delete;

 public:
     void notify_one();
     void notify_all();

     void wait(unique_lock<mutex>& __lk);
     template <class _Predicate>
         void wait(unique_lock<mutex>& __lk, _Predicate __pred);

     template <class _Duration>
         cv_status
         wait_until(unique_lock<mutex>& __lk,
                    const chrono::time_point<chrono::system_clock, _Duration>& __t);

     template <class _Clock, class _Duration>
         cv_status
         wait_until(unique_lock<mutex>& __lk,
                    const chrono::time_point<_Clock, _Duration>& __t);

     template <class _Clock, class _Duration, class _Predicate>
         bool
         wait_until(unique_lock<mutex>& __lk,
                    const chrono::time_point<_Clock, _Duration>& __t,
                    _Predicate __pred);

     template <class _Rep, class _Period>
         cv_status
         wait_for(unique_lock<mutex>& __lk,
                  const chrono::duration<_Rep, _Period>& __d);

     template <class _Rep, class _Period, class _Predicate>
         bool
         wait_for(unique_lock<mutex>& __lk,
                  const chrono::duration<_Rep, _Period>& __d,
                  _Predicate __pred);

     typedef pthread_cond_t* native_handle_type;
     _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() {return &__cv_;}

 private:
     void __do_timed_wait(unique_lock<mutex>& __lk,
                  chrono::time_point<chrono::system_clock, chrono::nanoseconds>);
 };

 template <class _To, class _Rep, class _Period>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     chrono::__is_duration<_To>::value,
     _To
 >::type
 __ceil(chrono::duration<_Rep, _Period> __d)
 {
     using namespace chrono;
     _To __r = duration_cast<_To>(__d);
     if (__r < __d)
         ++__r;
     return __r;
 }

 template <class _Predicate>
 void
 condition_variable::wait(unique_lock<mutex>& __lk, _Predicate __pred)
 {
     while (!__pred())
         wait(__lk);
 }

 template <class _Duration>
 cv_status
 condition_variable::wait_until(unique_lock<mutex>& __lk,
                  const chrono::time_point<chrono::system_clock, _Duration>& __t)
 {
     using namespace chrono;
     typedef time_point<system_clock, nanoseconds> __nano_sys_tmpt;
     __do_timed_wait(__lk,
                   __nano_sys_tmpt(__ceil<nanoseconds>(__t.time_since_epoch())));
     return system_clock::now() < __t ? cv_status::no_timeout :
                                        cv_status::timeout;
 }

 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;
     system_clock::time_point     __s_now = system_clock::now();
     typename _Clock::time_point  __c_now = _Clock::now();
     __do_timed_wait(__lk, __s_now + __ceil<nanoseconds>(__t - __c_now));
     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;
     system_clock::time_point __s_now = system_clock::now();
     steady_clock::time_point __c_now = steady_clock::now();
     __do_timed_wait(__lk, __s_now + __ceil<nanoseconds>(__d));
     return steady_clock::now() - __c_now < __d ? cv_status::no_timeout :
                                                  cv_status::timeout;
 }

 template <class _Rep, class _Period, class _Predicate>
 inline _LIBCPP_INLINE_VISIBILITY
 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,
                       _VSTD::move(__pred));
 }

 _LIBCPP_END_NAMESPACE_STD

 #endif  // _LIBCPP___MUTEX_BASE
	// -- C++ --
	//===----------------------------------------------------------------------===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is dual licensed under the MIT and the University of Illinois Open
	// Source Licenses. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#ifndef _LIBCPP___MUTEX_BASE
	#define _LIBCPP___MUTEX_BASE

	#include <__config>
	#include <chrono>
	#include <system_error>
	#include <pthread.h>

	#pragma GCC system_header

	#ifdef _LIBCPP_SHARED_LOCK

	namespace ting {
	template <class _Mutex> class shared_lock;
	template <class _Mutex> class upgrade_lock;
	}

	#endif // _LIBCPP_SHARED_LOCK


	_LIBCPP_BEGIN_NAMESPACE_STD

	class _LIBCPP_VISIBLE mutex
	{
	pthread_mutex_t __m_;

	public:
	_LIBCPP_INLINE_VISIBILITY
	mutex() {__m_ = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;}
	~mutex();

	private:
	mutex(const mutex&);// = delete;
	mutex& operator=(const mutex&);// = delete;

	public:
	void lock();
	bool try_lock();
	void unlock();

	typedef pthread_mutex_t* native_handle_type;
	_LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() {return &__m_;}
	};

	struct _LIBCPP_VISIBLE defer_lock_t {};
	struct _LIBCPP_VISIBLE try_to_lock_t {};
	struct _LIBCPP_VISIBLE adopt_lock_t {};

	//constexpr
	extern const
	defer_lock_t defer_lock;

	//constexpr
	extern const
	try_to_lock_t try_to_lock;

	//constexpr
	extern const
	adopt_lock_t adopt_lock;

	template <class _Mutex>
	class _LIBCPP_VISIBLE lock_guard
	{
	public:
	typedef _Mutex mutex_type;

	private:
	mutex_type& __m_;
	public:

	_LIBCPP_INLINE_VISIBILITY
	explicit lock_guard(mutex_type& __m)
	: __m_(__m) {__m_.lock();}
	_LIBCPP_INLINE_VISIBILITY
	lock_guard(mutex_type& __m, adopt_lock_t)
	: __m_(__m) {}
	_LIBCPP_INLINE_VISIBILITY
	~lock_guard() {__m_.unlock();}

	private:
	lock_guard(lock_guard const&);// = delete;
	lock_guard& operator=(lock_guard const&);// = delete;
	};

	template <class _Mutex>
	class _LIBCPP_VISIBLE unique_lock
	{
	public:
	typedef _Mutex mutex_type;

	private:
	mutex_type* __m_;
	bool __owns_;

	public:
	_LIBCPP_INLINE_VISIBILITY
	unique_lock() : __m_(nullptr), __owns_(false) {}
	_LIBCPP_INLINE_VISIBILITY
	explicit unique_lock(mutex_type& __m)
	: __m_(&__m), __owns_(true) {__m_->lock();}
	_LIBCPP_INLINE_VISIBILITY
	unique_lock(mutex_type& __m, defer_lock_t)
	: __m_(&__m), __owns_(false) {}
	_LIBCPP_INLINE_VISIBILITY
	unique_lock(mutex_type& __m, try_to_lock_t)
	: __m_(&__m), __owns_(__m.try_lock()) {}
	_LIBCPP_INLINE_VISIBILITY
	unique_lock(mutex_type& __m, adopt_lock_t)
	: __m_(&__m), __owns_(true) {}
	template <class _Clock, class _Duration>
	_LIBCPP_INLINE_VISIBILITY
	unique_lock(mutex_type& __m, const chrono::time_point<_Clock, _Duration>& __t)
	: __m_(&__m), __owns_(__m.try_lock_until(__t)) {}
	template <class _Rep, class _Period>
	_LIBCPP_INLINE_VISIBILITY
	unique_lock(mutex_type& __m, const chrono::duration<_Rep, _Period>& __d)
	: __m_(&__m), __owns_(__m.try_lock_for(__d)) {}
	_LIBCPP_INLINE_VISIBILITY
	~unique_lock()
	{
	if (__owns_)
	__m_->unlock();
	}

	private:
	unique_lock(unique_lock const&); // = delete;
	unique_lock& operator=(unique_lock const&); // = delete;

	public:
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	unique_lock(unique_lock&& __u)
	: __m_(__u.__m_), __owns_(__u.__owns_)
	{__u.__m_ = nullptr; __u.__owns_ = false;}
	_LIBCPP_INLINE_VISIBILITY
	unique_lock& operator=(unique_lock&& __u)
	{
	if (__owns_)
	__m_->unlock();
	__m_ = __u.__m_;
	__owns_ = __u.__owns_;
	__u.__m_ = nullptr;
	__u.__owns_ = false;
	return *this;
	}

	#ifdef _LIBCPP_SHARED_LOCK

	unique_lock(ting::shared_lock<mutex_type>&&, try_to_lock_t);
	template <class _Clock, class _Duration>
	unique_lock(ting::shared_lock<mutex_type>&&,
	const chrono::time_point<_Clock, _Duration>&);
	template <class _Rep, class _Period>
	unique_lock(ting::shared_lock<mutex_type>&&,
	const chrono::duration<_Rep, _Period>&);

	explicit unique_lock(ting::upgrade_lock<mutex_type>&&);
	unique_lock(ting::upgrade_lock<mutex_type>&&, try_to_lock_t);
	template <class _Clock, class _Duration>
	unique_lock(ting::upgrade_lock<mutex_type>&&,
	const chrono::time_point<_Clock, _Duration>&);
	template <class _Rep, class _Period>
	unique_lock(ting::upgrade_lock<mutex_type>&&,
	const chrono::duration<_Rep, _Period>&);

	#endif // _LIBCPP_SHARED_LOCK

	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	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_INLINE_VISIBILITY
	void swap(unique_lock& __u)
	{
	_VSTD::swap(__m_, __u.__m_);
	_VSTD::swap(__owns_, __u.__owns_);
	}
	_LIBCPP_INLINE_VISIBILITY
	mutex_type* release()
	{
	mutex_type* __m = __m_;
	__m_ = nullptr;
	__owns_ = false;
	return __m;
	}

	_LIBCPP_INLINE_VISIBILITY
	bool owns_lock() const {return __owns_;}
	_LIBCPP_INLINE_VISIBILITY
	// explicit
	operator bool () const {return __owns_;}
	_LIBCPP_INLINE_VISIBILITY
	mutex_type* mutex() const {return __m_;}
	};

	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_INLINE_VISIBILITY
	void
	swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) {__x.swap(__y);}

	struct _LIBCPP_VISIBLE cv_status
	{
	enum _ {
	no_timeout,
	timeout
	};

	_ __v_;

	_LIBCPP_INLINE_VISIBILITY cv_status(_ __v) : __v_(__v) {}
	_LIBCPP_INLINE_VISIBILITY operator int() const {return __v_;}

	};

	class _LIBCPP_VISIBLE condition_variable
	{
	pthread_cond_t __cv_;
	public:
	_LIBCPP_INLINE_VISIBILITY
	condition_variable() {__cv_ = (pthread_cond_t)PTHREAD_COND_INITIALIZER;}
	~condition_variable();

	private:
	condition_variable(const condition_variable&); // = delete;
	condition_variable& operator=(const condition_variable&); // = delete;

	public:
	void notify_one();
	void notify_all();

	void wait(unique_lock<mutex>& __lk);
	template <class _Predicate>
	void wait(unique_lock<mutex>& __lk, _Predicate __pred);

	template <class _Duration>
	cv_status
	wait_until(unique_lock<mutex>& __lk,
	const chrono::time_point<chrono::system_clock, _Duration>& __t);

	template <class _Clock, class _Duration>
	cv_status
	wait_until(unique_lock<mutex>& __lk,
	const chrono::time_point<_Clock, _Duration>& __t);

	template <class _Clock, class _Duration, class _Predicate>
	bool
	wait_until(unique_lock<mutex>& __lk,
	const chrono::time_point<_Clock, _Duration>& __t,
	_Predicate __pred);

	template <class _Rep, class _Period>
	cv_status
	wait_for(unique_lock<mutex>& __lk,
	const chrono::duration<_Rep, _Period>& __d);

	template <class _Rep, class _Period, class _Predicate>
	bool
	wait_for(unique_lock<mutex>& __lk,
	const chrono::duration<_Rep, _Period>& __d,
	_Predicate __pred);

	typedef pthread_cond_t* native_handle_type;
	_LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() {return &__cv_;}

	private:
	void __do_timed_wait(unique_lock<mutex>& __lk,
	chrono::time_point<chrono::system_clock, chrono::nanoseconds>);
	};

	template <class _To, class _Rep, class _Period>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	chrono::__is_duration<_To>::value,
	_To
	>::type
	__ceil(chrono::duration<_Rep, _Period> __d)
	{
	using namespace chrono;
	_To __r = duration_cast<_To>(__d);
	if (__r < __d)
	++__r;
	return __r;
	}

	template <class _Predicate>
	void
	condition_variable::wait(unique_lock<mutex>& __lk, _Predicate __pred)
	{
	while (!__pred())
	wait(__lk);
	}

	template <class _Duration>
	cv_status
	condition_variable::wait_until(unique_lock<mutex>& __lk,
	const chrono::time_point<chrono::system_clock, _Duration>& __t)
	{
	using namespace chrono;
	typedef time_point<system_clock, nanoseconds> __nano_sys_tmpt;
	__do_timed_wait(__lk,
	__nano_sys_tmpt(__ceil<nanoseconds>(__t.time_since_epoch())));
	return system_clock::now() < __t ? cv_status::no_timeout :
	cv_status::timeout;
	}

	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;
	system_clock::time_point __s_now = system_clock::now();
	typename _Clock::time_point __c_now = _Clock::now();
	__do_timed_wait(__lk, __s_now + __ceil<nanoseconds>(__t - __c_now));
	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;
	system_clock::time_point __s_now = system_clock::now();
	steady_clock::time_point __c_now = steady_clock::now();
	__do_timed_wait(__lk, __s_now + __ceil<nanoseconds>(__d));
	return steady_clock::now() - __c_now < __d ? cv_status::no_timeout :
	cv_status::timeout;
	}

	template <class _Rep, class _Period, class _Predicate>
	inline _LIBCPP_INLINE_VISIBILITY
	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,
	_VSTD::move(__pred));
	}

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP___MUTEX_BASE