diff options
Diffstat (limited to 'system/include/libcxx/future')
| -rw-r--r-- | system/include/libcxx/future | 1044 |
1 files changed, 517 insertions, 527 deletions
diff --git a/system/include/libcxx/future b/system/include/libcxx/future index 62529d97..fa605e7d 100644 --- a/system/include/libcxx/future +++ b/system/include/libcxx/future @@ -40,10 +40,10 @@ enum class future_status }; template <> struct is_error_code_enum<future_errc> : public true_type { }; -error_code make_error_code(future_errc e); -error_condition make_error_condition(future_errc e); +error_code make_error_code(future_errc e) noexcept; +error_condition make_error_condition(future_errc e) noexcept; -const error_category& future_category(); +const error_category& future_category() noexcept; class future_error : public logic_error @@ -51,8 +51,8 @@ class future_error public: future_error(error_code ec); // exposition only - const error_code& code() const throw(); - const char* what() const throw(); + const error_code& code() const noexcept; + const char* what() const noexcept; }; template <class R> @@ -62,14 +62,14 @@ public: promise(); template <class Allocator> promise(allocator_arg_t, const Allocator& a); - promise(promise&& rhs); + promise(promise&& rhs) noexcept; promise(const promise& rhs) = delete; ~promise(); // assignment - promise& operator=(promise&& rhs); + promise& operator=(promise&& rhs) noexcept; promise& operator=(const promise& rhs) = delete; - void swap(promise& other); + void swap(promise& other) noexcept; // retrieving the result future<R> get_future(); @@ -92,14 +92,14 @@ public: promise(); template <class Allocator> promise(allocator_arg_t, const Allocator& a); - promise(promise&& rhs); + promise(promise&& rhs) noexcept; promise(const promise& rhs) = delete; ~promise(); // assignment - promise& operator=(promise&& rhs); + promise& operator=(promise&& rhs) noexcept; promise& operator=(const promise& rhs) = delete; - void swap(promise& other); + void swap(promise& other) noexcept; // retrieving the result future<R&> get_future(); @@ -120,14 +120,14 @@ public: promise(); template <class Allocator> promise(allocator_arg_t, const Allocator& a); - promise(promise&& rhs); + promise(promise&& rhs) noexcept; promise(const promise& rhs) = delete; ~promise(); // assignment - promise& operator=(promise&& rhs); + promise& operator=(promise&& rhs) noexcept; promise& operator=(const promise& rhs) = delete; - void swap(promise& other); + void swap(promise& other) noexcept; // retrieving the result future<void> get_future(); @@ -141,7 +141,7 @@ public: void set_exception_at_thread_exit(exception_ptr p); }; -template <class R> void swap(promise<R>& x, promise<R>& y); +template <class R> void swap(promise<R>& x, promise<R>& y) noexcept; template <class R, class Alloc> struct uses_allocator<promise<R>, Alloc> : public true_type {}; @@ -150,19 +150,19 @@ template <class R> class future { public: - future(); - future(future&&); + future() noexcept; + future(future&&) noexcept; future(const future& rhs) = delete; ~future(); future& operator=(const future& rhs) = delete; - future& operator=(future&&); - shared_future<R> share() &&; + future& operator=(future&&) noexcept; + shared_future<R> share(); // retrieving the value R get(); // functions to check state - bool valid() const; + bool valid() const noexcept; void wait() const; template <class Rep, class Period> @@ -177,19 +177,19 @@ template <class R> class future<R&> { public: - future(); - future(future&&); + future() noexcept; + future(future&&) noexcept; future(const future& rhs) = delete; ~future(); future& operator=(const future& rhs) = delete; - future& operator=(future&&); - shared_future<R&> share() &&; + future& operator=(future&&) noexcept; + shared_future<R&> share(); // retrieving the value R& get(); // functions to check state - bool valid() const; + bool valid() const noexcept; void wait() const; template <class Rep, class Period> @@ -204,19 +204,19 @@ template <> class future<void> { public: - future(); - future(future&&); + future() noexcept; + future(future&&) noexcept; future(const future& rhs) = delete; ~future(); future& operator=(const future& rhs) = delete; - future& operator=(future&&); - shared_future<void> share() &&; + future& operator=(future&&) noexcept; + shared_future<void> share(); // retrieving the value void get(); // functions to check state - bool valid() const; + bool valid() const noexcept; void wait() const; template <class Rep, class Period> @@ -231,19 +231,19 @@ template <class R> class shared_future { public: - shared_future(); + shared_future() noexcept; shared_future(const shared_future& rhs); - shared_future(future<R>&&); - shared_future(shared_future&& rhs); + shared_future(future<R>&&) noexcept; + shared_future(shared_future&& rhs) noexcept; ~shared_future(); shared_future& operator=(const shared_future& rhs); - shared_future& operator=(shared_future&& rhs); + shared_future& operator=(shared_future&& rhs) noexcept; // retrieving the value const R& get() const; // functions to check state - bool valid() const; + bool valid() const noexcept; void wait() const; template <class Rep, class Period> @@ -258,19 +258,19 @@ template <class R> class shared_future<R&> { public: - shared_future(); + shared_future() noexcept; shared_future(const shared_future& rhs); - shared_future(future<R&>&&); - shared_future(shared_future&& rhs); + shared_future(future<R&>&&) noexcept; + shared_future(shared_future&& rhs) noexcept; ~shared_future(); shared_future& operator=(const shared_future& rhs); - shared_future& operator=(shared_future&& rhs); + shared_future& operator=(shared_future&& rhs) noexcept; // retrieving the value R& get() const; // functions to check state - bool valid() const; + bool valid() const noexcept; void wait() const; template <class Rep, class Period> @@ -285,19 +285,19 @@ template <> class shared_future<void> { public: - shared_future(); + shared_future() noexcept; shared_future(const shared_future& rhs); - shared_future(future<void>&&); - shared_future(shared_future&& rhs); + shared_future(future<void>&&) noexcept; + shared_future(shared_future&& rhs) noexcept; ~shared_future(); shared_future& operator=(const shared_future& rhs); - shared_future& operator=(shared_future&& rhs); + shared_future& operator=(shared_future&& rhs) noexcept; // retrieving the value void get() const; // functions to check state - bool valid() const; + bool valid() const noexcept; void wait() const; template <class Rep, class Period> @@ -325,7 +325,7 @@ public: typedef R result_type; // construction and destruction - packaged_task(); + packaged_task() noexcept; template <class F> explicit packaged_task(F&& f); template <class F, class Allocator> @@ -333,15 +333,15 @@ public: ~packaged_task(); // no copy - packaged_task(packaged_task&) = delete; - packaged_task& operator=(packaged_task&) = delete; + packaged_task(const packaged_task&) = delete; + packaged_task& operator=(const packaged_task&) = delete; // move support - packaged_task(packaged_task&& other); - packaged_task& operator=(packaged_task&& other); - void swap(packaged_task& other); + packaged_task(packaged_task&& other) noexcept; + packaged_task& operator=(packaged_task&& other) noexcept; + void swap(packaged_task& other) noexcept; - bool valid() const; + bool valid() const noexcept; // result retrieval future<R> get_future(); @@ -354,7 +354,7 @@ public: }; template <class R> - void swap(packaged_task<R(ArgTypes...)&, packaged_task<R(ArgTypes...)>&); + void swap(packaged_task<R(ArgTypes...)&, packaged_task<R(ArgTypes...)>&) noexcept; template <class R, class Alloc> struct uses_allocator<packaged_task<R>, Alloc>; @@ -370,75 +370,61 @@ template <class R, class Alloc> struct uses_allocator<packaged_task<R>, Alloc>; #include <mutex> #include <thread> +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #pragma GCC system_header +#endif _LIBCPP_BEGIN_NAMESPACE_STD //enum class future_errc -struct _LIBCPP_VISIBLE future_errc +_LIBCPP_DECLARE_STRONG_ENUM(future_errc) { -enum _ { broken_promise, future_already_retrieved, promise_already_satisfied, no_state }; - - _ __v_; - - _LIBCPP_INLINE_VISIBILITY future_errc(_ __v) : __v_(__v) {} - _LIBCPP_INLINE_VISIBILITY operator int() const {return __v_;} - -}; +_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_errc) template <> struct _LIBCPP_VISIBLE is_error_code_enum<future_errc> : public true_type {}; +#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS +template <> +struct _LIBCPP_VISIBLE is_error_code_enum<future_errc::__lx> : public true_type { }; +#endif + //enum class launch -struct _LIBCPP_VISIBLE launch +_LIBCPP_DECLARE_STRONG_ENUM(launch) { -enum _ { async = 1, deferred = 2, any = async | deferred }; - - _ __v_; - - _LIBCPP_INLINE_VISIBILITY launch(_ __v) : __v_(__v) {} - _LIBCPP_INLINE_VISIBILITY operator int() const {return __v_;} - -}; +_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(launch) //enum class future_status -struct _LIBCPP_VISIBLE future_status +_LIBCPP_DECLARE_STRONG_ENUM(future_status) { -enum _ { ready, timeout, deferred }; - - _ __v_; - - _LIBCPP_INLINE_VISIBILITY future_status(_ __v) : __v_(__v) {} - _LIBCPP_INLINE_VISIBILITY operator int() const {return __v_;} - -}; +_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_status) _LIBCPP_VISIBLE -const error_category& future_category(); +const error_category& future_category() _NOEXCEPT; inline _LIBCPP_INLINE_VISIBILITY error_code -make_error_code(future_errc __e) +make_error_code(future_errc __e) _NOEXCEPT { return error_code(static_cast<int>(__e), future_category()); } inline _LIBCPP_INLINE_VISIBILITY error_condition -make_error_condition(future_errc __e) +make_error_condition(future_errc __e) _NOEXCEPT { return error_condition(static_cast<int>(__e), future_category()); } @@ -451,7 +437,7 @@ public: future_error(error_code __ec); _LIBCPP_INLINE_VISIBILITY - const error_code& code() const throw() {return __ec_;} + const error_code& code() const _NOEXCEPT {return __ec_;} virtual ~future_error() _NOEXCEPT; }; @@ -484,7 +470,11 @@ public: {return (__state_ & __constructed) || (__exception_ != nullptr);} _LIBCPP_INLINE_VISIBILITY - void __set_future_attached() {__state_ |= __future_attached;} + void __set_future_attached() + { + lock_guard<mutex> __lk(__mut_); + __state_ |= __future_attached; + } _LIBCPP_INLINE_VISIBILITY bool __has_future_attached() const {return __state_ & __future_attached;} @@ -536,14 +526,14 @@ __assoc_sub_state::wait_for(const chrono::duration<_Rep, _Period>& __rel_time) c return wait_until(chrono::steady_clock::now() + __rel_time); } -template <class _R> +template <class _Rp> class __assoc_state : public __assoc_sub_state { typedef __assoc_sub_state base; - typedef typename aligned_storage<sizeof(_R), alignment_of<_R>::value>::type _U; + typedef typename aligned_storage<sizeof(_Rp), alignment_of<_Rp>::value>::type _Up; protected: - _U __value_; + _Up __value_; virtual void __on_zero_shared() _NOEXCEPT; public: @@ -562,26 +552,26 @@ public: void set_value_at_thread_exit(_Arg& __arg); #endif - _R move(); - typename add_lvalue_reference<_R>::type copy(); + _Rp move(); + typename add_lvalue_reference<_Rp>::type copy(); }; -template <class _R> +template <class _Rp> void -__assoc_state<_R>::__on_zero_shared() _NOEXCEPT +__assoc_state<_Rp>::__on_zero_shared() _NOEXCEPT { if (this->__state_ & base::__constructed) - reinterpret_cast<_R*>(&__value_)->~_R(); + reinterpret_cast<_Rp*>(&__value_)->~_Rp(); delete this; } -template <class _R> +template <class _Rp> template <class _Arg> void #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES -__assoc_state<_R>::set_value(_Arg&& __arg) +__assoc_state<_Rp>::set_value(_Arg&& __arg) #else -__assoc_state<_R>::set_value(_Arg& __arg) +__assoc_state<_Rp>::set_value(_Arg& __arg) #endif { unique_lock<mutex> __lk(this->__mut_); @@ -589,19 +579,19 @@ __assoc_state<_R>::set_value(_Arg& __arg) if (this->__has_value()) throw future_error(make_error_code(future_errc::promise_already_satisfied)); #endif - ::new(&__value_) _R(_VSTD::forward<_Arg>(__arg)); + ::new(&__value_) _Rp(_VSTD::forward<_Arg>(__arg)); this->__state_ |= base::__constructed | base::ready; __lk.unlock(); __cv_.notify_all(); } -template <class _R> +template <class _Rp> template <class _Arg> void #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES -__assoc_state<_R>::set_value_at_thread_exit(_Arg&& __arg) +__assoc_state<_Rp>::set_value_at_thread_exit(_Arg&& __arg) #else -__assoc_state<_R>::set_value_at_thread_exit(_Arg& __arg) +__assoc_state<_Rp>::set_value_at_thread_exit(_Arg& __arg) #endif { unique_lock<mutex> __lk(this->__mut_); @@ -609,62 +599,62 @@ __assoc_state<_R>::set_value_at_thread_exit(_Arg& __arg) if (this->__has_value()) throw future_error(make_error_code(future_errc::promise_already_satisfied)); #endif - ::new(&__value_) _R(_VSTD::forward<_Arg>(__arg)); + ::new(&__value_) _Rp(_VSTD::forward<_Arg>(__arg)); this->__state_ |= base::__constructed; __thread_local_data()->__make_ready_at_thread_exit(this); __lk.unlock(); } -template <class _R> -_R -__assoc_state<_R>::move() +template <class _Rp> +_Rp +__assoc_state<_Rp>::move() { unique_lock<mutex> __lk(this->__mut_); this->__sub_wait(__lk); if (this->__exception_ != nullptr) rethrow_exception(this->__exception_); - return _VSTD::move(*reinterpret_cast<_R*>(&__value_)); + return _VSTD::move(*reinterpret_cast<_Rp*>(&__value_)); } -template <class _R> -typename add_lvalue_reference<_R>::type -__assoc_state<_R>::copy() +template <class _Rp> +typename add_lvalue_reference<_Rp>::type +__assoc_state<_Rp>::copy() { unique_lock<mutex> __lk(this->__mut_); this->__sub_wait(__lk); if (this->__exception_ != nullptr) rethrow_exception(this->__exception_); - return *reinterpret_cast<_R*>(&__value_); + return *reinterpret_cast<_Rp*>(&__value_); } -template <class _R> -class __assoc_state<_R&> +template <class _Rp> +class __assoc_state<_Rp&> : public __assoc_sub_state { typedef __assoc_sub_state base; - typedef _R* _U; + typedef _Rp* _Up; protected: - _U __value_; + _Up __value_; virtual void __on_zero_shared() _NOEXCEPT; public: - void set_value(_R& __arg); - void set_value_at_thread_exit(_R& __arg); + void set_value(_Rp& __arg); + void set_value_at_thread_exit(_Rp& __arg); - _R& copy(); + _Rp& copy(); }; -template <class _R> +template <class _Rp> void -__assoc_state<_R&>::__on_zero_shared() _NOEXCEPT +__assoc_state<_Rp&>::__on_zero_shared() _NOEXCEPT { delete this; } -template <class _R> +template <class _Rp> void -__assoc_state<_R&>::set_value(_R& __arg) +__assoc_state<_Rp&>::set_value(_Rp& __arg) { unique_lock<mutex> __lk(this->__mut_); #ifndef _LIBCPP_NO_EXCEPTIONS @@ -677,9 +667,9 @@ __assoc_state<_R&>::set_value(_R& __arg) __cv_.notify_all(); } -template <class _R> +template <class _Rp> void -__assoc_state<_R&>::set_value_at_thread_exit(_R& __arg) +__assoc_state<_Rp&>::set_value_at_thread_exit(_Rp& __arg) { unique_lock<mutex> __lk(this->__mut_); #ifndef _LIBCPP_NO_EXCEPTIONS @@ -692,9 +682,9 @@ __assoc_state<_R&>::set_value_at_thread_exit(_R& __arg) __lk.unlock(); } -template <class _R> -_R& -__assoc_state<_R&>::copy() +template <class _Rp> +_Rp& +__assoc_state<_Rp&>::copy() { unique_lock<mutex> __lk(this->__mut_); this->__sub_wait(__lk); @@ -703,11 +693,11 @@ __assoc_state<_R&>::copy() return *__value_; } -template <class _R, class _Alloc> +template <class _Rp, class _Alloc> class __assoc_state_alloc - : public __assoc_state<_R> + : public __assoc_state<_Rp> { - typedef __assoc_state<_R> base; + typedef __assoc_state<_Rp> base; _Alloc __alloc_; virtual void __on_zero_shared() _NOEXCEPT; @@ -717,22 +707,22 @@ public: : __alloc_(__a) {} }; -template <class _R, class _Alloc> +template <class _Rp, class _Alloc> void -__assoc_state_alloc<_R, _Alloc>::__on_zero_shared() _NOEXCEPT +__assoc_state_alloc<_Rp, _Alloc>::__on_zero_shared() _NOEXCEPT { if (this->__state_ & base::__constructed) - reinterpret_cast<_R*>(&this->__value_)->~_R(); + reinterpret_cast<_Rp*>(&this->__value_)->~_Rp(); typename _Alloc::template rebind<__assoc_state_alloc>::other __a(__alloc_); this->~__assoc_state_alloc(); __a.deallocate(this, 1); } -template <class _R, class _Alloc> -class __assoc_state_alloc<_R&, _Alloc> - : public __assoc_state<_R&> +template <class _Rp, class _Alloc> +class __assoc_state_alloc<_Rp&, _Alloc> + : public __assoc_state<_Rp&> { - typedef __assoc_state<_R&> base; + typedef __assoc_state<_Rp&> base; _Alloc __alloc_; virtual void __on_zero_shared() _NOEXCEPT; @@ -742,9 +732,9 @@ public: : __alloc_(__a) {} }; -template <class _R, class _Alloc> +template <class _Rp, class _Alloc> void -__assoc_state_alloc<_R&, _Alloc>::__on_zero_shared() _NOEXCEPT +__assoc_state_alloc<_Rp&, _Alloc>::__on_zero_shared() _NOEXCEPT { typename _Alloc::template rebind<__assoc_state_alloc>::other __a(__alloc_); this->~__assoc_state_alloc(); @@ -769,23 +759,22 @@ template <class _Alloc> void __assoc_sub_state_alloc<_Alloc>::__on_zero_shared() _NOEXCEPT { - this->~base(); typename _Alloc::template rebind<__assoc_sub_state_alloc>::other __a(__alloc_); this->~__assoc_sub_state_alloc(); __a.deallocate(this, 1); } -template <class _R, class _F> +template <class _Rp, class _Fp> class __deferred_assoc_state - : public __assoc_state<_R> + : public __assoc_state<_Rp> { - typedef __assoc_state<_R> base; + typedef __assoc_state<_Rp> base; - _F __func_; + _Fp __func_; public: #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES - explicit __deferred_assoc_state(_F&& __f); + explicit __deferred_assoc_state(_Fp&& __f); #endif virtual void __execute(); @@ -793,19 +782,19 @@ public: #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES -template <class _R, class _F> +template <class _Rp, class _Fp> inline _LIBCPP_INLINE_VISIBILITY -__deferred_assoc_state<_R, _F>::__deferred_assoc_state(_F&& __f) - : __func_(_VSTD::forward<_F>(__f)) +__deferred_assoc_state<_Rp, _Fp>::__deferred_assoc_state(_Fp&& __f) + : __func_(_VSTD::forward<_Fp>(__f)) { this->__set_deferred(); } #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES -template <class _R, class _F> +template <class _Rp, class _Fp> void -__deferred_assoc_state<_R, _F>::__execute() +__deferred_assoc_state<_Rp, _Fp>::__execute() { #ifndef _LIBCPP_NO_EXCEPTIONS try @@ -821,17 +810,17 @@ __deferred_assoc_state<_R, _F>::__execute() #endif // _LIBCPP_NO_EXCEPTIONS } -template <class _F> -class __deferred_assoc_state<void, _F> +template <class _Fp> +class __deferred_assoc_state<void, _Fp> : public __assoc_sub_state { typedef __assoc_sub_state base; - _F __func_; + _Fp __func_; public: #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES - explicit __deferred_assoc_state(_F&& __f); + explicit __deferred_assoc_state(_Fp&& __f); #endif virtual void __execute(); @@ -839,19 +828,19 @@ public: #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES -template <class _F> +template <class _Fp> inline _LIBCPP_INLINE_VISIBILITY -__deferred_assoc_state<void, _F>::__deferred_assoc_state(_F&& __f) - : __func_(_VSTD::forward<_F>(__f)) +__deferred_assoc_state<void, _Fp>::__deferred_assoc_state(_Fp&& __f) + : __func_(_VSTD::forward<_Fp>(__f)) { this->__set_deferred(); } #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES -template <class _F> +template <class _Fp> void -__deferred_assoc_state<void, _F>::__execute() +__deferred_assoc_state<void, _Fp>::__execute() { #ifndef _LIBCPP_NO_EXCEPTIONS try @@ -868,18 +857,18 @@ __deferred_assoc_state<void, _F>::__execute() #endif // _LIBCPP_NO_EXCEPTIONS } -template <class _R, class _F> +template <class _Rp, class _Fp> class __async_assoc_state - : public __assoc_state<_R> + : public __assoc_state<_Rp> { - typedef __assoc_state<_R> base; + typedef __assoc_state<_Rp> base; - _F __func_; + _Fp __func_; virtual void __on_zero_shared() _NOEXCEPT; public: #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES - explicit __async_assoc_state(_F&& __f); + explicit __async_assoc_state(_Fp&& __f); #endif virtual void __execute(); @@ -887,18 +876,18 @@ public: #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES -template <class _R, class _F> +template <class _Rp, class _Fp> inline _LIBCPP_INLINE_VISIBILITY -__async_assoc_state<_R, _F>::__async_assoc_state(_F&& __f) - : __func_(_VSTD::forward<_F>(__f)) +__async_assoc_state<_Rp, _Fp>::__async_assoc_state(_Fp&& __f) + : __func_(_VSTD::forward<_Fp>(__f)) { } #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES -template <class _R, class _F> +template <class _Rp, class _Fp> void -__async_assoc_state<_R, _F>::__execute() +__async_assoc_state<_Rp, _Fp>::__execute() { #ifndef _LIBCPP_NO_EXCEPTIONS try @@ -914,26 +903,26 @@ __async_assoc_state<_R, _F>::__execute() #endif // _LIBCPP_NO_EXCEPTIONS } -template <class _R, class _F> +template <class _Rp, class _Fp> void -__async_assoc_state<_R, _F>::__on_zero_shared() _NOEXCEPT +__async_assoc_state<_Rp, _Fp>::__on_zero_shared() _NOEXCEPT { this->wait(); base::__on_zero_shared(); } -template <class _F> -class __async_assoc_state<void, _F> +template <class _Fp> +class __async_assoc_state<void, _Fp> : public __assoc_sub_state { typedef __assoc_sub_state base; - _F __func_; + _Fp __func_; virtual void __on_zero_shared() _NOEXCEPT; public: #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES - explicit __async_assoc_state(_F&& __f); + explicit __async_assoc_state(_Fp&& __f); #endif virtual void __execute(); @@ -941,18 +930,18 @@ public: #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES -template <class _F> +template <class _Fp> inline _LIBCPP_INLINE_VISIBILITY -__async_assoc_state<void, _F>::__async_assoc_state(_F&& __f) - : __func_(_VSTD::forward<_F>(__f)) +__async_assoc_state<void, _Fp>::__async_assoc_state(_Fp&& __f) + : __func_(_VSTD::forward<_Fp>(__f)) { } #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES -template <class _F> +template <class _Fp> void -__async_assoc_state<void, _F>::__execute() +__async_assoc_state<void, _Fp>::__execute() { #ifndef _LIBCPP_NO_EXCEPTIONS try @@ -969,70 +958,70 @@ __async_assoc_state<void, _F>::__execute() #endif // _LIBCPP_NO_EXCEPTIONS } -template <class _F> +template <class _Fp> void -__async_assoc_state<void, _F>::__on_zero_shared() _NOEXCEPT +__async_assoc_state<void, _Fp>::__on_zero_shared() _NOEXCEPT { this->wait(); base::__on_zero_shared(); } -template <class _R> class promise; -template <class _R> class shared_future; +template <class _Rp> class _LIBCPP_VISIBLE promise; +template <class _Rp> class _LIBCPP_VISIBLE shared_future; // future -template <class _R> class future; +template <class _Rp> class _LIBCPP_VISIBLE future; -template <class _R, class _F> -future<_R> +template <class _Rp, class _Fp> +future<_Rp> #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES -__make_deferred_assoc_state(_F&& __f); +__make_deferred_assoc_state(_Fp&& __f); #else -__make_deferred_assoc_state(_F __f); +__make_deferred_assoc_state(_Fp __f); #endif -template <class _R, class _F> -future<_R> +template <class _Rp, class _Fp> +future<_Rp> #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES -__make_async_assoc_state(_F&& __f); +__make_async_assoc_state(_Fp&& __f); #else -__make_async_assoc_state(_F __f); +__make_async_assoc_state(_Fp __f); #endif -template <class _R> +template <class _Rp> class _LIBCPP_VISIBLE future { - __assoc_state<_R>* __state_; + __assoc_state<_Rp>* __state_; - explicit future(__assoc_state<_R>* __state); + explicit future(__assoc_state<_Rp>* __state); template <class> friend class promise; template <class> friend class shared_future; #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES - template <class _R1, class _F> - friend future<_R1> __make_deferred_assoc_state(_F&& __f); - template <class _R1, class _F> - friend future<_R1> __make_async_assoc_state(_F&& __f); + template <class _R1, class _Fp> + friend future<_R1> __make_deferred_assoc_state(_Fp&& __f); + template <class _R1, class _Fp> + friend future<_R1> __make_async_assoc_state(_Fp&& __f); #else - template <class _R1, class _F> - friend future<_R1> __make_deferred_assoc_state(_F __f); - template <class _R1, class _F> - friend future<_R1> __make_async_assoc_state(_F __f); + template <class _R1, class _Fp> + friend future<_R1> __make_deferred_assoc_state(_Fp __f); + template <class _R1, class _Fp> + friend future<_R1> __make_async_assoc_state(_Fp __f); #endif public: _LIBCPP_INLINE_VISIBILITY - future() : __state_(nullptr) {} + future() _NOEXCEPT : __state_(nullptr) {} #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY - future(future&& __rhs) + future(future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;} future(const future&) = delete; future& operator=(const future&) = delete; _LIBCPP_INLINE_VISIBILITY - future& operator=(future&& __rhs) + future& operator=(future&& __rhs) _NOEXCEPT { future(std::move(__rhs)).swap(*this); return *this; @@ -1044,17 +1033,17 @@ private: public: #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES ~future(); - shared_future<_R> share(); + shared_future<_Rp> share(); // retrieving the value - _R get(); + _Rp get(); _LIBCPP_INLINE_VISIBILITY - void swap(future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);} + void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);} // functions to check state _LIBCPP_INLINE_VISIBILITY - bool valid() const {return __state_ != nullptr;} + bool valid() const _NOEXCEPT {return __state_ != nullptr;} _LIBCPP_INLINE_VISIBILITY void wait() const {__state_->wait();} @@ -1070,8 +1059,8 @@ public: {return __state_->wait_until(__abs_time);} }; -template <class _R> -future<_R>::future(__assoc_state<_R>* __state) +template <class _Rp> +future<_Rp>::future(__assoc_state<_Rp>* __state) : __state_(__state) { #ifndef _LIBCPP_NO_EXCEPTIONS @@ -1087,56 +1076,56 @@ struct __release_shared_count void operator()(__shared_count* p) {p->__release_shared();} }; -template <class _R> -future<_R>::~future() +template <class _Rp> +future<_Rp>::~future() { if (__state_) __state_->__release_shared(); } -template <class _R> -_R -future<_R>::get() +template <class _Rp> +_Rp +future<_Rp>::get() { unique_ptr<__shared_count, __release_shared_count> __(__state_); - __assoc_state<_R>* __s = __state_; + __assoc_state<_Rp>* __s = __state_; __state_ = nullptr; return __s->move(); } -template <class _R> -class _LIBCPP_VISIBLE future<_R&> +template <class _Rp> +class _LIBCPP_VISIBLE future<_Rp&> { - __assoc_state<_R&>* __state_; + __assoc_state<_Rp&>* __state_; - explicit future(__assoc_state<_R&>* __state); + explicit future(__assoc_state<_Rp&>* __state); template <class> friend class promise; template <class> friend class shared_future; #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES - template <class _R1, class _F> - friend future<_R1> __make_deferred_assoc_state(_F&& __f); - template <class _R1, class _F> - friend future<_R1> __make_async_assoc_state(_F&& __f); + template <class _R1, class _Fp> + friend future<_R1> __make_deferred_assoc_state(_Fp&& __f); + template <class _R1, class _Fp> + friend future<_R1> __make_async_assoc_state(_Fp&& __f); #else - template <class _R1, class _F> - friend future<_R1> __make_deferred_assoc_state(_F __f); - template <class _R1, class _F> - friend future<_R1> __make_async_assoc_state(_F __f); + template <class _R1, class _Fp> + friend future<_R1> __make_deferred_assoc_state(_Fp __f); + template <class _R1, class _Fp> + friend future<_R1> __make_async_assoc_state(_Fp __f); #endif public: _LIBCPP_INLINE_VISIBILITY - future() : __state_(nullptr) {} + future() _NOEXCEPT : __state_(nullptr) {} #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY - future(future&& __rhs) + future(future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;} future(const future&) = delete; future& operator=(const future&) = delete; _LIBCPP_INLINE_VISIBILITY - future& operator=(future&& __rhs) + future& operator=(future&& __rhs) _NOEXCEPT { future(std::move(__rhs)).swap(*this); return *this; @@ -1148,17 +1137,17 @@ private: public: #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES ~future(); - shared_future<_R&> share(); + shared_future<_Rp&> share(); // retrieving the value - _R& get(); + _Rp& get(); _LIBCPP_INLINE_VISIBILITY - void swap(future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);} + void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);} // functions to check state _LIBCPP_INLINE_VISIBILITY - bool valid() const {return __state_ != nullptr;} + bool valid() const _NOEXCEPT {return __state_ != nullptr;} _LIBCPP_INLINE_VISIBILITY void wait() const {__state_->wait();} @@ -1174,8 +1163,8 @@ public: {return __state_->wait_until(__abs_time);} }; -template <class _R> -future<_R&>::future(__assoc_state<_R&>* __state) +template <class _Rp> +future<_Rp&>::future(__assoc_state<_Rp&>* __state) : __state_(__state) { #ifndef _LIBCPP_NO_EXCEPTIONS @@ -1186,19 +1175,19 @@ future<_R&>::future(__assoc_state<_R&>* __state) __state_->__set_future_attached(); } -template <class _R> -future<_R&>::~future() +template <class _Rp> +future<_Rp&>::~future() { if (__state_) __state_->__release_shared(); } -template <class _R> -_R&</ |