1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include <__config>
10 
11 #ifndef _LIBCPP_HAS_NO_THREADS
12 
13 #include <future>
14 #include <string>
15 
16 _LIBCPP_BEGIN_NAMESPACE_STD
17 
18 class _LIBCPP_HIDDEN __future_error_category
19     : public __do_message
20 {
21 public:
22     virtual const char* name() const noexcept;
23     virtual string message(int ev) const;
24 };
25 
26 const char*
27 __future_error_category::name() const noexcept
28 {
29     return "future";
30 }
31 
32 _LIBCPP_DIAGNOSTIC_PUSH
33 _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wswitch")
34 _LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wswitch")
35 
36 string
37 __future_error_category::message(int ev) const
38 {
39     switch (static_cast<future_errc>(ev))
40     {
41     case future_errc(0):  // For backwards compatibility with C++11 (LWG 2056)
42     case future_errc::broken_promise:
43         return string("The associated promise has been destructed prior "
44                       "to the associated state becoming ready.");
45     case future_errc::future_already_retrieved:
46         return string("The future has already been retrieved from "
47                       "the promise or packaged_task.");
48     case future_errc::promise_already_satisfied:
49         return string("The state of the promise has already been set.");
50     case future_errc::no_state:
51         return string("Operation not permitted on an object without "
52                       "an associated state.");
53     }
54     return string("unspecified future_errc value\n");
55 }
56 
57 _LIBCPP_DIAGNOSTIC_POP
58 
59 const error_category&
60 future_category() noexcept
61 {
62     static __future_error_category __f;
63     return __f;
64 }
65 
66 future_error::future_error(error_code __ec)
67     : logic_error(__ec.message()),
68       __ec_(__ec)
69 {
70 }
71 
72 future_error::~future_error() noexcept
73 {
74 }
75 
76 void
77 __assoc_sub_state::__on_zero_shared() noexcept
78 {
79     delete this;
80 }
81 
82 void
83 __assoc_sub_state::set_value()
84 {
85     unique_lock<mutex> __lk(__mut_);
86     if (__has_value())
87         __throw_future_error(future_errc::promise_already_satisfied);
88     __state_ |= __constructed | ready;
89     __cv_.notify_all();
90 }
91 
92 void
93 __assoc_sub_state::set_value_at_thread_exit()
94 {
95     unique_lock<mutex> __lk(__mut_);
96     if (__has_value())
97         __throw_future_error(future_errc::promise_already_satisfied);
98     __state_ |= __constructed;
99     __thread_local_data()->__make_ready_at_thread_exit(this);
100 }
101 
102 void
103 __assoc_sub_state::set_exception(exception_ptr __p)
104 {
105     unique_lock<mutex> __lk(__mut_);
106     if (__has_value())
107         __throw_future_error(future_errc::promise_already_satisfied);
108     __exception_ = __p;
109     __state_ |= ready;
110     __cv_.notify_all();
111 }
112 
113 void
114 __assoc_sub_state::set_exception_at_thread_exit(exception_ptr __p)
115 {
116     unique_lock<mutex> __lk(__mut_);
117     if (__has_value())
118         __throw_future_error(future_errc::promise_already_satisfied);
119     __exception_ = __p;
120     __thread_local_data()->__make_ready_at_thread_exit(this);
121 }
122 
123 void
124 __assoc_sub_state::__make_ready()
125 {
126     unique_lock<mutex> __lk(__mut_);
127     __state_ |= ready;
128     __cv_.notify_all();
129 }
130 
131 void
132 __assoc_sub_state::copy()
133 {
134     unique_lock<mutex> __lk(__mut_);
135     __sub_wait(__lk);
136     if (__exception_ != nullptr)
137         rethrow_exception(__exception_);
138 }
139 
140 void
141 __assoc_sub_state::wait()
142 {
143     unique_lock<mutex> __lk(__mut_);
144     __sub_wait(__lk);
145 }
146 
147 void
148 __assoc_sub_state::__sub_wait(unique_lock<mutex>& __lk)
149 {
150     if (!__is_ready())
151     {
152         if (__state_ & static_cast<unsigned>(deferred))
153         {
154             __state_ &= ~static_cast<unsigned>(deferred);
155             __lk.unlock();
156             __execute();
157         }
158         else
159             while (!__is_ready())
160                 __cv_.wait(__lk);
161     }
162 }
163 
164 void
165 __assoc_sub_state::__execute()
166 {
167     __throw_future_error(future_errc::no_state);
168 }
169 
170 future<void>::future(__assoc_sub_state* __state)
171     : __state_(__state)
172 {
173     __state_->__attach_future();
174 }
175 
176 future<void>::~future()
177 {
178     if (__state_)
179         __state_->__release_shared();
180 }
181 
182 void
183 future<void>::get()
184 {
185     unique_ptr<__shared_count, __release_shared_count> __(__state_);
186     __assoc_sub_state* __s = __state_;
187     __state_ = nullptr;
188     __s->copy();
189 }
190 
191 promise<void>::promise()
192     : __state_(new __assoc_sub_state)
193 {
194 }
195 
196 promise<void>::~promise()
197 {
198     if (__state_)
199     {
200 #ifndef _LIBCPP_NO_EXCEPTIONS
201         if (!__state_->__has_value() && __state_->use_count() > 1)
202             __state_->set_exception(make_exception_ptr(
203                       future_error(make_error_code(future_errc::broken_promise))
204                                                       ));
205 #endif // _LIBCPP_NO_EXCEPTIONS
206         __state_->__release_shared();
207     }
208 }
209 
210 future<void>
211 promise<void>::get_future()
212 {
213     if (__state_ == nullptr)
214         __throw_future_error(future_errc::no_state);
215     return future<void>(__state_);
216 }
217 
218 void
219 promise<void>::set_value()
220 {
221     if (__state_ == nullptr)
222         __throw_future_error(future_errc::no_state);
223     __state_->set_value();
224 }
225 
226 void
227 promise<void>::set_exception(exception_ptr __p)
228 {
229     if (__state_ == nullptr)
230         __throw_future_error(future_errc::no_state);
231     __state_->set_exception(__p);
232 }
233 
234 void
235 promise<void>::set_value_at_thread_exit()
236 {
237     if (__state_ == nullptr)
238         __throw_future_error(future_errc::no_state);
239     __state_->set_value_at_thread_exit();
240 }
241 
242 void
243 promise<void>::set_exception_at_thread_exit(exception_ptr __p)
244 {
245     if (__state_ == nullptr)
246         __throw_future_error(future_errc::no_state);
247     __state_->set_exception_at_thread_exit(__p);
248 }
249 
250 shared_future<void>::~shared_future()
251 {
252     if (__state_)
253         __state_->__release_shared();
254 }
255 
256 shared_future<void>&
257 shared_future<void>::operator=(const shared_future& __rhs)
258 {
259     if (__rhs.__state_)
260         __rhs.__state_->__add_shared();
261     if (__state_)
262         __state_->__release_shared();
263     __state_ = __rhs.__state_;
264     return *this;
265 }
266 
267 _LIBCPP_END_NAMESPACE_STD
268 
269 #endif // !_LIBCPP_HAS_NO_THREADS
270