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 //===----------------------------------------------------------------------===//
12 #ifndef _LIBCPP_HAS_NO_THREADS
17 _LIBCPP_BEGIN_NAMESPACE_STD
19 class _LIBCPP_HIDDEN __future_error_category
23 virtual const char* name() const _NOEXCEPT
;
24 virtual string
message(int ev
) const;
28 __future_error_category::name() const _NOEXCEPT
33 #if defined(__clang__)
34 #pragma clang diagnostic push
35 #pragma clang diagnostic ignored "-Wswitch"
36 #elif defined(__GNUC__) || defined(__GNUG__)
37 #pragma GCC diagnostic push
38 #pragma GCC diagnostic ignored "-Wswitch"
42 __future_error_category::message(int ev
) const
44 switch (static_cast<future_errc
>(ev
))
46 case future_errc(0): // For backwards compatibility with C++11 (LWG 2056)
47 case future_errc::broken_promise
:
48 return string("The associated promise has been destructed prior "
49 "to the associated state becoming ready.");
50 case future_errc::future_already_retrieved
:
51 return string("The future has already been retrieved from "
52 "the promise or packaged_task.");
53 case future_errc::promise_already_satisfied
:
54 return string("The state of the promise has already been set.");
55 case future_errc::no_state
:
56 return string("Operation not permitted on an object without "
57 "an associated state.");
59 return string("unspecified future_errc value\n");
62 #if defined(__clang__)
63 #pragma clang diagnostic pop
64 #elif defined(__GNUC__) || defined(__GNUG__)
65 #pragma GCC diagnostic pop
69 future_category() _NOEXCEPT
71 static __future_error_category __f
;
75 future_error::future_error(error_code __ec
)
76 : logic_error(__ec
.message()),
81 future_error::~future_error() _NOEXCEPT
86 __assoc_sub_state::__on_zero_shared() _NOEXCEPT
92 __assoc_sub_state::set_value()
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
| ready
;
104 __assoc_sub_state::set_value_at_thread_exit()
106 unique_lock
<mutex
> __lk(__mut_
);
107 #ifndef _LIBCPP_NO_EXCEPTIONS
109 throw future_error(make_error_code(future_errc::promise_already_satisfied
));
111 __state_
|= __constructed
;
112 __thread_local_data()->__make_ready_at_thread_exit(this);
116 __assoc_sub_state::set_exception(exception_ptr __p
)
118 unique_lock
<mutex
> __lk(__mut_
);
119 #ifndef _LIBCPP_NO_EXCEPTIONS
121 throw future_error(make_error_code(future_errc::promise_already_satisfied
));
129 __assoc_sub_state::set_exception_at_thread_exit(exception_ptr __p
)
131 unique_lock
<mutex
> __lk(__mut_
);
132 #ifndef _LIBCPP_NO_EXCEPTIONS
134 throw future_error(make_error_code(future_errc::promise_already_satisfied
));
137 __thread_local_data()->__make_ready_at_thread_exit(this);
141 __assoc_sub_state::__make_ready()
143 unique_lock
<mutex
> __lk(__mut_
);
149 __assoc_sub_state::copy()
151 unique_lock
<mutex
> __lk(__mut_
);
153 if (__exception_
!= nullptr)
154 rethrow_exception(__exception_
);
158 __assoc_sub_state::wait()
160 unique_lock
<mutex
> __lk(__mut_
);
165 __assoc_sub_state::__sub_wait(unique_lock
<mutex
>& __lk
)
169 if (__state_
& static_cast<unsigned>(deferred
))
171 __state_
&= ~static_cast<unsigned>(deferred
);
176 while (!__is_ready())
182 __assoc_sub_state::__execute()
184 #ifndef _LIBCPP_NO_EXCEPTIONS
185 throw future_error(make_error_code(future_errc::no_state
));
189 future
<void>::future(__assoc_sub_state
* __state
)
192 #ifndef _LIBCPP_NO_EXCEPTIONS
193 if (__state_
->__has_future_attached())
194 throw future_error(make_error_code(future_errc::future_already_retrieved
));
196 __state_
->__add_shared();
197 __state_
->__set_future_attached();
200 future
<void>::~future()
203 __state_
->__release_shared();
209 unique_ptr
<__shared_count
, __release_shared_count
> __(__state_
);
210 __assoc_sub_state
* __s
= __state_
;
215 promise
<void>::promise()
216 : __state_(new __assoc_sub_state
)
220 promise
<void>::~promise()
224 if (!__state_
->__has_value() && __state_
->use_count() > 1)
225 __state_
->set_exception(make_exception_ptr(
226 future_error(make_error_code(future_errc::broken_promise
))
228 __state_
->__release_shared();
233 promise
<void>::get_future()
235 #ifndef _LIBCPP_NO_EXCEPTIONS
236 if (__state_
== nullptr)
237 throw future_error(make_error_code(future_errc::no_state
));
239 return future
<void>(__state_
);
243 promise
<void>::set_value()
245 #ifndef _LIBCPP_NO_EXCEPTIONS
246 if (__state_
== nullptr)
247 throw future_error(make_error_code(future_errc::no_state
));
249 __state_
->set_value();
253 promise
<void>::set_exception(exception_ptr __p
)
255 #ifndef _LIBCPP_NO_EXCEPTIONS
256 if (__state_
== nullptr)
257 throw future_error(make_error_code(future_errc::no_state
));
259 __state_
->set_exception(__p
);
263 promise
<void>::set_value_at_thread_exit()
265 #ifndef _LIBCPP_NO_EXCEPTIONS
266 if (__state_
== nullptr)
267 throw future_error(make_error_code(future_errc::no_state
));
269 __state_
->set_value_at_thread_exit();
273 promise
<void>::set_exception_at_thread_exit(exception_ptr __p
)
275 #ifndef _LIBCPP_NO_EXCEPTIONS
276 if (__state_
== nullptr)
277 throw future_error(make_error_code(future_errc::no_state
));
279 __state_
->set_exception_at_thread_exit(__p
);
282 shared_future
<void>::~shared_future()
285 __state_
->__release_shared();
289 shared_future
<void>::operator=(const shared_future
& __rhs
)
292 __rhs
.__state_
->__add_shared();
294 __state_
->__release_shared();
295 __state_
= __rhs
.__state_
;
299 _LIBCPP_END_NAMESPACE_STD
301 #endif // !_LIBCPP_HAS_NO_THREADS