1 //===------------------------- future.cpp ---------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
13 _LIBCPP_BEGIN_NAMESPACE_STD
15 class _LIBCPP_HIDDEN __future_error_category
19 virtual const char* name() const _NOEXCEPT;
20 virtual string message(int ev) const;
24 __future_error_category::name() const _NOEXCEPT
29 #pragma clang diagnostic push
30 #pragma clang diagnostic ignored "-Wswitch"
33 __future_error_category::message(int ev) const
35 switch (static_cast<future_errc>(ev))
37 case future_errc(0): // For backwards compatibility with C++11 (LWG 2056)
38 case future_errc::broken_promise:
39 return string("The associated promise has been destructed prior "
40 "to the associated state becoming ready.");
41 case future_errc::future_already_retrieved:
42 return string("The future has already been retrieved from "
43 "the promise or packaged_task.");
44 case future_errc::promise_already_satisfied:
45 return string("The state of the promise has already been set.");
46 case future_errc::no_state:
47 return string("Operation not permitted on an object without "
48 "an associated state.");
50 return string("unspecified future_errc value\n");
53 #pragma clang diagnostic pop
56 future_category() _NOEXCEPT
58 static __future_error_category __f;
62 future_error::future_error(error_code __ec)
63 : logic_error(__ec.message()),
68 future_error::~future_error() _NOEXCEPT
73 __assoc_sub_state::__on_zero_shared() _NOEXCEPT
79 __assoc_sub_state::set_value()
81 unique_lock<mutex> __lk(__mut_);
82 #ifndef _LIBCPP_NO_EXCEPTIONS
84 throw future_error(make_error_code(future_errc::promise_already_satisfied));
86 __state_ |= __constructed | ready;
92 __assoc_sub_state::set_value_at_thread_exit()
94 unique_lock<mutex> __lk(__mut_);
95 #ifndef _LIBCPP_NO_EXCEPTIONS
97 throw future_error(make_error_code(future_errc::promise_already_satisfied));
99 __state_ |= __constructed;
100 __thread_local_data()->__make_ready_at_thread_exit(this);
105 __assoc_sub_state::set_exception(exception_ptr __p)
107 unique_lock<mutex> __lk(__mut_);
108 #ifndef _LIBCPP_NO_EXCEPTIONS
110 throw future_error(make_error_code(future_errc::promise_already_satisfied));
119 __assoc_sub_state::set_exception_at_thread_exit(exception_ptr __p)
121 unique_lock<mutex> __lk(__mut_);
122 #ifndef _LIBCPP_NO_EXCEPTIONS
124 throw future_error(make_error_code(future_errc::promise_already_satisfied));
127 __thread_local_data()->__make_ready_at_thread_exit(this);
132 __assoc_sub_state::__make_ready()
134 unique_lock<mutex> __lk(__mut_);
141 __assoc_sub_state::copy()
143 unique_lock<mutex> __lk(__mut_);
145 if (__exception_ != nullptr)
146 rethrow_exception(__exception_);
150 __assoc_sub_state::wait()
152 unique_lock<mutex> __lk(__mut_);
157 __assoc_sub_state::__sub_wait(unique_lock<mutex>& __lk)
161 if (__state_ & static_cast<unsigned>(deferred))
163 __state_ &= ~static_cast<unsigned>(deferred);
168 while (!__is_ready())
174 __assoc_sub_state::__execute()
176 #ifndef _LIBCPP_NO_EXCEPTIONS
177 throw future_error(make_error_code(future_errc::no_state));
181 future<void>::future(__assoc_sub_state* __state)
184 #ifndef _LIBCPP_NO_EXCEPTIONS
185 if (__state_->__has_future_attached())
186 throw future_error(make_error_code(future_errc::future_already_retrieved));
188 __state_->__add_shared();
189 __state_->__set_future_attached();
192 future<void>::~future()
195 __state_->__release_shared();
201 unique_ptr<__shared_count, __release_shared_count> __(__state_);
202 __assoc_sub_state* __s = __state_;
207 promise<void>::promise()
208 : __state_(new __assoc_sub_state)
212 promise<void>::~promise()
216 if (!__state_->__has_value() && __state_->use_count() > 1)
217 __state_->set_exception(make_exception_ptr(
218 future_error(make_error_code(future_errc::broken_promise))
220 __state_->__release_shared();
225 promise<void>::get_future()
227 #ifndef _LIBCPP_NO_EXCEPTIONS
228 if (__state_ == nullptr)
229 throw future_error(make_error_code(future_errc::no_state));
231 return future<void>(__state_);
235 promise<void>::set_value()
237 #ifndef _LIBCPP_NO_EXCEPTIONS
238 if (__state_ == nullptr)
239 throw future_error(make_error_code(future_errc::no_state));
241 __state_->set_value();
245 promise<void>::set_exception(exception_ptr __p)
247 #ifndef _LIBCPP_NO_EXCEPTIONS
248 if (__state_ == nullptr)
249 throw future_error(make_error_code(future_errc::no_state));
251 __state_->set_exception(__p);
255 promise<void>::set_value_at_thread_exit()
257 #ifndef _LIBCPP_NO_EXCEPTIONS
258 if (__state_ == nullptr)
259 throw future_error(make_error_code(future_errc::no_state));
261 __state_->set_value_at_thread_exit();
265 promise<void>::set_exception_at_thread_exit(exception_ptr __p)
267 #ifndef _LIBCPP_NO_EXCEPTIONS
268 if (__state_ == nullptr)
269 throw future_error(make_error_code(future_errc::no_state));
271 __state_->set_exception_at_thread_exit(__p);
274 shared_future<void>::~shared_future()
277 __state_->__release_shared();
281 shared_future<void>::operator=(const shared_future& __rhs)
284 __rhs.__state_->__add_shared();
286 __state_->__release_shared();
287 __state_ = __rhs.__state_;
291 _LIBCPP_END_NAMESPACE_STD